Home /Modules/impl/chemistry.cpp

chemistry.cpp

impl/subjects/chemistry/chemistry.cpp · 121 line(s) · c

#include "chemistry.h"
#include <algorithm>
#include <cmath>
#include <limits>

namespace sleela {
namespace chemistry {

namespace {
double clamp01(double x) {
    if (!std::isfinite(x)) return 0.0;
    return std::max(0.0, std::min(1.0, x));
}
}

double ratio(double numerator, double denominator) {
    if (!std::isfinite(numerator) || !std::isfinite(denominator) || denominator == 0.0) return 0.0;
    return numerator / denominator;
}

double similarity(double a, double b) {
    if (!std::isfinite(a) || !std::isfinite(b)) return 0.0;
    const double scale = std::max({std::fabs(a), std::fabs(b), 1.0});
    return clamp01(1.0 - std::fabs(a - b) / scale);
}

double stochastic_factor(std::uint64_t seed) {
    // SplitMix64-style deterministic mixing. The output is deliberately
    // narrow: stochastic ranking may perturb a hypothesis, but cannot create
    // evidence or overturn a strong contradictory observation.
    std::uint64_t x = seed + 0x9e3779b97f4a7c15ULL;
    x = (x ^ (x >> 30)) * 0xbf58476d1ce4e5b9ULL;
    x = (x ^ (x >> 27)) * 0x94d049bb133111ebULL;
    x ^= x >> 31;
    const double u = static_cast<double>(x & 0xFFFFFFFFULL) / 4294967295.0;
    return 0.98 + 0.04 * u;
}

InferenceScore evaluate(double observation,
                        double bond,
                        double valence,
                        double similarity_score,
                        double signal,
                        double symmetry,
                        std::uint64_t seed) {
    const double evidence[6] = {
        clamp01(observation), clamp01(bond), clamp01(valence),
        clamp01(similarity_score), clamp01(signal), clamp01(symmetry)
    };
    // Observation and valence receive the strongest weights. Similarity and
    // symmetry are supporting evidence, not substitutes for observation.
    const double weights[6] = {0.24, 0.20, 0.22, 0.13, 0.12, 0.09};
    double weighted = 0.0;
    for (int i = 0; i < 6; ++i) weighted += evidence[i] * weights[i];

    const double stochastic = stochastic_factor(seed);
    const double support = clamp01(weighted * stochastic);
    int level = static_cast<int>(std::floor(support * 25.0));
    if (level > 24) level = 24;

    // Uncertainty remains explicit and cannot fall to zero merely because a
    // model receives a high score.
    const double spread = std::max({evidence[0], evidence[1], evidence[2],
                                    evidence[3], evidence[4], evidence[5]}) -
                          std::min({evidence[0], evidence[1], evidence[2],
                                    evidence[3], evidence[4], evidence[5]});
    const double uncertainty = clamp01(0.55 * (1.0 - support) + 0.45 * spread);
    return {level, support, uncertainty};
}

SubjectNorm presume(const std::string& subject,
                    double observation,
                    double bond,
                    double valence,
                    double similarity_score,
                    double signal,
                    double symmetry,
                    std::uint64_t seed) {
    SubjectNorm result;
    result.subject = subject;
    result.observations.push_back("normalized observation score");
    result.bonds.push_back("bond compatibility");
    result.signals.push_back("available experimental signal");
    result.conferrers.push_back("periodic/structural analogy");
    result.conferrers.push_back("valence consistency");
    result.conferrers.push_back("convergent signal support");
    result.symmetry.push_back("causal evidence ordering");
    result.symmetry.push_back("compound-family similarity");
    result.ratios = {
        {"observation", clamp01(observation), 0.24},
        {"bond", clamp01(bond), 0.20},
        {"valence", clamp01(valence), 0.22},
        {"similarity", clamp01(similarity_score), 0.13},
        {"signal", clamp01(signal), 0.12},
        {"symmetry", clamp01(symmetry), 0.09}
    };
    result.score = evaluate(observation, bond, valence, similarity_score,
                            signal, symmetry, seed);
    return result;
}

const std::vector<std::string>& causal_order() {
    static const std::vector<std::string> order = {
        "observation",
        "measurement",
        "structure",
        "bond",
        "valence",
        "geometry",
        "electronic_state",
        "reaction_relationship",
        "compound_family_similarity",
        "thermodynamic_consequence",
        "astronomical_context"
    };
    return order;
}

} // namespace chemistry
} // namespace sleela