Upload ChatIPC.cpp

ChatIPC.cpp

@@ -18,6 +18,8 @@
 #include <unordered_map>
 #include <unordered_set>
 #include <vector>
+#include <cmath>
+#include <limits>
 
 #ifdef _OPENMP
 #include <omp.h>
@@ -284,6 +286,570 @@ 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*;
@@ -815,6 +1381,10 @@ 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;