lex-agentic-inference 0.1.0

data/lib/legion/extensions/agentic/inference/bayesian/client.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/agentic/inference/bayesian/helpers/constants'
+require 'legion/extensions/agentic/inference/bayesian/helpers/belief'
+require 'legion/extensions/agentic/inference/bayesian/helpers/belief_network'
+require 'legion/extensions/agentic/inference/bayesian/runners/bayesian_belief'
+
+module Legion
+  module Extensions
+    module Agentic
+      module Inference
+        module Bayesian
+          class Client
+            include Runners::BayesianBelief
+
+            def initialize(**)
+              @belief_network = Helpers::BeliefNetwork.new
+            end
+
+            private
+
+            attr_reader :belief_network
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/inference/bayesian/helpers/belief.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+require 'securerandom'
+
+module Legion
+  module Extensions
+    module Agentic
+      module Inference
+        module Bayesian
+          module Helpers
+            class Belief
+              include Constants
+
+              attr_reader :id, :content, :domain, :prior, :posterior,
+                          :evidence_history, :update_count, :created_at, :last_updated_at
+
+              def initialize(content:, domain:, prior: Constants::DEFAULT_PRIOR)
+                @id               = SecureRandom.uuid
+                @content          = content
+                @domain           = domain
+                @prior            = prior.clamp(Constants::PRIOR_FLOOR, Constants::PRIOR_CEILING)
+                @posterior        = @prior
+                @evidence_history = []
+                @update_count     = 0
+                @created_at       = Time.now.utc
+                @last_updated_at  = @created_at
+              end
+
+              def update(likelihood:, evidence_id:)
+                clamped_likelihood = likelihood.clamp(Constants::LIKELIHOOD_FLOOR, Constants::LIKELIHOOD_CEILING)
+                marginal = (clamped_likelihood * @posterior) + ((1.0 - clamped_likelihood) * (1.0 - @posterior))
+                new_posterior = (clamped_likelihood * @posterior) / marginal
+                @posterior = new_posterior.clamp(Constants::PRIOR_FLOOR, Constants::PRIOR_CEILING)
+                @update_count    += 1
+                @last_updated_at  = Time.now.utc
+
+                @evidence_history << {
+                  evidence_id:     evidence_id,
+                  likelihood:      clamped_likelihood,
+                  posterior_after: @posterior
+                }
+                @evidence_history.shift while @evidence_history.size > Constants::MAX_HISTORY
+
+                @posterior
+              end
+
+              def log_odds
+                Math.log(@posterior / (1.0 - @posterior))
+              end
+
+              def confidence_label
+                Constants::CONFIDENCE_LABELS.each do |range, label|
+                  return label if range.cover?(@posterior)
+                end
+                :unknown
+              end
+
+              def surprise(observation_likelihood:)
+                clamped = observation_likelihood.clamp(Constants::LIKELIHOOD_FLOOR, 1.0)
+                -Math.log2(clamped)
+              end
+
+              def reset_to_prior!
+                @posterior       = @prior
+                @update_count    = 0
+                @evidence_history = []
+                @last_updated_at  = Time.now.utc
+                @posterior
+              end
+
+              def stale?(threshold: Constants::STALE_THRESHOLD)
+                (Time.now.utc - @last_updated_at) > threshold
+              end
+
+              def to_h
+                {
+                  id:               @id,
+                  content:          @content,
+                  domain:           @domain,
+                  prior:            @prior,
+                  posterior:        @posterior,
+                  confidence_label: confidence_label,
+                  log_odds:         log_odds,
+                  update_count:     @update_count,
+                  evidence_history: @evidence_history,
+                  created_at:       @created_at,
+                  last_updated_at:  @last_updated_at
+                }
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/inference/bayesian/helpers/belief_network.rb

@@ -0,0 +1,147 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Inference
+        module Bayesian
+          module Helpers
+            class BeliefNetwork
+              include Constants
+
+              attr_reader :beliefs
+
+              def initialize
+                @beliefs = {}
+              end
+
+              def add_belief(content:, domain:, prior: Constants::DEFAULT_PRIOR)
+                return nil if @beliefs.size >= Constants::MAX_HYPOTHESES
+
+                belief = Belief.new(content: content, domain: domain, prior: prior)
+                @beliefs[belief.id] = belief
+                belief
+              end
+
+              def update_belief(belief_id:, evidence_id:, likelihood:)
+                belief = @beliefs[belief_id]
+                return nil unless belief
+
+                belief.update(likelihood: likelihood, evidence_id: evidence_id)
+                belief
+              end
+
+              def batch_update(evidence_id:, likelihoods:)
+                return {} if likelihoods.empty?
+
+                updated = {}
+                likelihoods.each do |belief_id, likelihood|
+                  belief = update_belief(belief_id: belief_id, evidence_id: evidence_id, likelihood: likelihood)
+                  updated[belief_id] = belief.posterior if belief
+                end
+
+                normalize_posteriors(updated.keys)
+                updated
+              end
+
+              def most_probable(domain: nil, limit: 5)
+                filtered(domain).sort_by { |b| -b.posterior }.first(limit)
+              end
+
+              def least_probable(domain: nil, limit: 5)
+                filtered(domain).sort_by(&:posterior).first(limit)
+              end
+
+              def by_domain(domain:)
+                @beliefs.values.select { |b| b.domain == domain }
+              end
+
+              def posterior_distribution(domain: nil)
+                subset = filtered(domain)
+                total  = subset.sum(&:posterior)
+                return {} if total.zero?
+
+                subset.to_h { |b| [b.id, b.posterior / total] }
+              end
+
+              def information_gain(belief_id:, evidence_id:, likelihood:) # rubocop:disable Lint/UnusedMethodArgument
+                belief = @beliefs[belief_id]
+                return 0.0 unless belief
+
+                prior_p = belief.posterior
+                clamped = likelihood.clamp(Constants::LIKELIHOOD_FLOOR, Constants::LIKELIHOOD_CEILING)
+                marginal = (clamped * prior_p) + ((1.0 - clamped) * (1.0 - prior_p))
+                post_p = (clamped * prior_p) / marginal
+                post_p = post_p.clamp(Constants::PRIOR_FLOOR, Constants::PRIOR_CEILING)
+
+                kl_divergence(prior_p, post_p)
+              end
+
+              def entropy(domain: nil)
+                dist = posterior_distribution(domain: domain)
+                return 0.0 if dist.empty?
+
+                -dist.values.sum do |prob|
+                  next 0.0 if prob <= 0.0
+
+                  prob * Math.log2(prob)
+                end
+              end
+
+              def decay_all
+                @beliefs.each_value do |belief|
+                  shift = (belief.posterior - belief.prior) * Constants::DECAY_RATE
+                  new_posterior = belief.posterior - shift
+                  belief.instance_variable_set(:@posterior, new_posterior.clamp(Constants::PRIOR_FLOOR, Constants::PRIOR_CEILING))
+                  belief.instance_variable_set(:@last_updated_at, Time.now.utc)
+                end
+                @beliefs.size
+              end
+
+              def count
+                @beliefs.size
+              end
+
+              def to_h
+                {
+                  belief_count: @beliefs.size,
+                  beliefs:      @beliefs.transform_values(&:to_h)
+                }
+              end
+
+              private
+
+              def filtered(domain)
+                return @beliefs.values if domain.nil?
+
+                by_domain(domain: domain)
+              end
+
+              def normalize_posteriors(belief_ids)
+                subset = belief_ids.filter_map { |bid| @beliefs[bid] }
+                total  = subset.sum(&:posterior)
+                return if total.zero?
+
+                subset.each do |belief|
+                  normalized = (belief.posterior / total).clamp(Constants::PRIOR_FLOOR, Constants::PRIOR_CEILING)
+                  belief.instance_variable_set(:@posterior, normalized)
+                end
+              end
+
+              def kl_divergence(prior_p, post_p)
+                return 0.0 if prior_p <= 0.0 || post_p <= 0.0
+
+                prior_q = 1.0 - prior_p
+                post_q  = 1.0 - post_p
+
+                term1 = post_p  * Math.log2(post_p  / prior_p)
+                term2 = post_q  * Math.log2(post_q  / prior_q)
+                term1 + term2
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/inference/bayesian/helpers/constants.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Inference
+        module Bayesian
+          module Helpers
+            module Constants
+              MAX_HYPOTHESES  = 200
+              MAX_EVIDENCE    = 500
+              MAX_HISTORY     = 300
+
+              DEFAULT_PRIOR     = 0.5
+              PRIOR_FLOOR       = 0.001
+              PRIOR_CEILING     = 0.999
+              LIKELIHOOD_FLOOR  = 0.001
+              LIKELIHOOD_CEILING = 0.999
+
+              DECAY_RATE       = 0.01
+              STALE_THRESHOLD  = 120
+
+              CONFIDENCE_LABELS = {
+                (0.9..)     => :certain,
+                (0.7...0.9) => :confident,
+                (0.5...0.7) => :leaning,
+                (0.3...0.5) => :uncertain,
+                (..0.3)     => :doubtful
+              }.freeze
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/inference/bayesian/runners/bayesian_belief.rb

@@ -0,0 +1,125 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Inference
+        module Bayesian
+          module Runners
+            module BayesianBelief
+              include Legion::Extensions::Helpers::Lex if Legion::Extensions.const_defined?(:Helpers) &&
+                                                          Legion::Extensions::Helpers.const_defined?(:Lex)
+
+              def add_bayesian_belief(content:, domain:, prior: nil, **)
+                pri = (prior || Helpers::Constants::DEFAULT_PRIOR).clamp(
+                  Helpers::Constants::PRIOR_FLOOR,
+                  Helpers::Constants::PRIOR_CEILING
+                )
+                belief = belief_network.add_belief(content: content, domain: domain, prior: pri)
+                unless belief
+                  Legion::Logging.warn "[bayesian_belief] add failed: network at capacity (#{Helpers::Constants::MAX_HYPOTHESES})"
+                  return { success: false, reason: :capacity_exceeded, max: Helpers::Constants::MAX_HYPOTHESES }
+                end
+
+                Legion::Logging.debug "[bayesian_belief] add: id=#{belief.id[0..7]} domain=#{domain} prior=#{pri.round(3)}"
+                { success: true, belief_id: belief.id, domain: domain, prior: belief.prior, posterior: belief.posterior }
+              end
+
+              def update_bayesian_belief(belief_id:, evidence_id:, likelihood:, **)
+                clamped = likelihood.clamp(Helpers::Constants::LIKELIHOOD_FLOOR, Helpers::Constants::LIKELIHOOD_CEILING)
+                belief  = belief_network.update_belief(belief_id: belief_id, evidence_id: evidence_id, likelihood: clamped)
+                unless belief
+                  Legion::Logging.debug "[bayesian_belief] update failed: belief_id=#{belief_id} not found"
+                  return { success: false, reason: :not_found, belief_id: belief_id }
+                end
+
+                Legion::Logging.debug "[bayesian_belief] update: id=#{belief_id[0..7]} evidence=#{evidence_id} " \
+                                      "likelihood=#{clamped.round(3)} posterior=#{belief.posterior.round(3)}"
+                {
+                  success:          true,
+                  belief_id:        belief_id,
+                  evidence_id:      evidence_id,
+                  likelihood:       clamped,
+                  posterior:        belief.posterior,
+                  confidence_label: belief.confidence_label,
+                  update_count:     belief.update_count
+                }
+              end
+
+              def batch_bayesian_update(evidence_id:, likelihoods:, **)
+                if likelihoods.nil? || likelihoods.empty?
+                  Legion::Logging.debug '[bayesian_belief] batch_update: empty likelihoods, skipping'
+                  return { success: true, updated: 0, posteriors: {} }
+                end
+
+                posteriors = belief_network.batch_update(evidence_id: evidence_id, likelihoods: likelihoods)
+                Legion::Logging.debug "[bayesian_belief] batch_update: evidence=#{evidence_id} updated=#{posteriors.size}"
+                { success: true, evidence_id: evidence_id, updated: posteriors.size, posteriors: posteriors }
+              end
+
+              def most_probable_beliefs(domain: nil, limit: 5, **)
+                beliefs = belief_network.most_probable(domain: domain, limit: limit)
+                Legion::Logging.debug "[bayesian_belief] most_probable: domain=#{domain.inspect} count=#{beliefs.size}"
+                { success: true, beliefs: beliefs.map(&:to_h), count: beliefs.size }
+              end
+
+              def least_probable_beliefs(domain: nil, limit: 5, **)
+                beliefs = belief_network.least_probable(domain: domain, limit: limit)
+                Legion::Logging.debug "[bayesian_belief] least_probable: domain=#{domain.inspect} count=#{beliefs.size}"
+                { success: true, beliefs: beliefs.map(&:to_h), count: beliefs.size }
+              end
+
+              def posterior_distribution(domain: nil, **)
+                dist = belief_network.posterior_distribution(domain: domain)
+                Legion::Logging.debug "[bayesian_belief] posterior_distribution: domain=#{domain.inspect} size=#{dist.size}"
+                { success: true, distribution: dist, size: dist.size }
+              end
+
+              def information_gain(belief_id:, evidence_id:, likelihood:, **)
+                clamped = likelihood.clamp(Helpers::Constants::LIKELIHOOD_FLOOR, Helpers::Constants::LIKELIHOOD_CEILING)
+                gain    = belief_network.information_gain(belief_id: belief_id, evidence_id: evidence_id, likelihood: clamped)
+                Legion::Logging.debug "[bayesian_belief] information_gain: id=#{belief_id[0..7]} likelihood=#{clamped.round(3)} gain=#{gain.round(4)}"
+                { success: true, belief_id: belief_id, evidence_id: evidence_id, likelihood: clamped, information_gain: gain }
+              end
+
+              def belief_entropy(domain: nil, **)
+                ent = belief_network.entropy(domain: domain)
+                Legion::Logging.debug "[bayesian_belief] entropy: domain=#{domain.inspect} entropy=#{ent.round(4)}"
+                { success: true, domain: domain, entropy: ent }
+              end
+
+              def update_bayesian_beliefs(**)
+                decayed = belief_network.decay_all
+                Legion::Logging.debug "[bayesian_belief] decay cycle: beliefs_updated=#{decayed}"
+                { success: true, decayed: decayed }
+              end
+
+              def bayesian_belief_stats(**)
+                total = belief_network.count
+                ent   = belief_network.entropy
+                most  = belief_network.most_probable(limit: 1).first
+                least = belief_network.least_probable(limit: 1).first
+
+                Legion::Logging.debug "[bayesian_belief] stats: total=#{total} entropy=#{ent.round(4)}"
+                {
+                  success:        true,
+                  total_beliefs:  total,
+                  entropy:        ent,
+                  most_probable:  most&.to_h,
+                  least_probable: least&.to_h,
+                  capacity:       Helpers::Constants::MAX_HYPOTHESES
+                }
+              end
+
+              private
+
+              def belief_network
+                @belief_network ||= Helpers::BeliefNetwork.new
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/inference/bayesian/version.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Inference
+        module Bayesian
+          VERSION = '0.1.0'
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/inference/bayesian.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/agentic/inference/bayesian/version'
+require 'legion/extensions/agentic/inference/bayesian/helpers/constants'
+require 'legion/extensions/agentic/inference/bayesian/helpers/belief'
+require 'legion/extensions/agentic/inference/bayesian/helpers/belief_network'
+require 'legion/extensions/agentic/inference/bayesian/runners/bayesian_belief'
+require 'legion/extensions/agentic/inference/bayesian/client'
+
+module Legion
+  module Extensions
+    module Agentic
+      module Inference
+        module Bayesian
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/inference/belief_revision/client.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Inference
+        module BeliefRevision
+          class Client
+            include Runners::BeliefRevision
+
+            def initialize(network: nil)
+              @network = network || Helpers::BeliefNetwork.new
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/inference/belief_revision/helpers/belief.rb

@@ -0,0 +1,155 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Inference
+        module BeliefRevision
+          module Helpers
+            class Belief
+              include Constants
+
+              attr_reader :id, :proposition, :domain, :credence, :evidence_for, :evidence_against, :entrenchment,
+                          :created_at, :updated_at, :revision_count
+
+              def initialize(id:, proposition:, domain: :general, credence: DEFAULT_CREDENCE)
+                @id               = id
+                @proposition      = proposition
+                @domain           = domain
+                @credence         = credence.to_f.clamp(CREDENCE_FLOOR, CREDENCE_CEILING)
+                @evidence_for     = []
+                @evidence_against = []
+                @entrenchment     = 0.0
+                @revision_count   = 0
+                @created_at       = Time.now.utc
+                @updated_at       = @created_at
+                @protected        = false
+              end
+
+              def add_supporting_evidence(evidence)
+                return nil if @evidence_for.size >= MAX_EVIDENCE_PER_BELIEF
+
+                @evidence_for << evidence
+                update_credence_from_evidence(evidence, :support)
+                evidence
+              end
+
+              def add_opposing_evidence(evidence)
+                return nil if @evidence_against.size >= MAX_EVIDENCE_PER_BELIEF
+
+                @evidence_against << evidence
+                update_credence_from_evidence(evidence, :oppose)
+                evidence
+              end
+
+              def revise(new_credence:)
+                @credence = new_credence.to_f.clamp(CREDENCE_FLOOR, CREDENCE_CEILING)
+                @revision_count += 1
+                @updated_at = Time.now.utc
+                deepen_entrenchment
+              end
+
+              def protect!
+                @protected = true
+              end
+
+              def unprotect!
+                @protected = false
+              end
+
+              def protected?
+                @protected
+              end
+
+              def state
+                return :protected if @protected
+                return :entrenched if @entrenchment >= STATE_THRESHOLDS[:entrenched]
+                return :held if @credence >= STATE_THRESHOLDS[:held]
+
+                :tentative
+              end
+
+              def credence_label
+                CREDENCE_LABELS.each { |range, lbl| return lbl if range.cover?(@credence) }
+                :disbelieved
+              end
+
+              def believed?
+                @credence >= 0.5
+              end
+
+              def disbelieved?
+                @credence < 0.3
+              end
+
+              def contradicts?(other)
+                (believed? && other.disbelieved?) || (disbelieved? && other.believed?)
+              end
+
+              def evidence_ratio
+                total = @evidence_for.size + @evidence_against.size
+                return 0.5 if total.zero?
+
+                @evidence_for.size.to_f / total
+              end
+
+              def total_evidence_count
+                @evidence_for.size + @evidence_against.size
+              end
+
+              def decay
+                return if @protected
+                return if @entrenchment >= STATE_THRESHOLDS[:entrenched]
+
+                @credence = approach_default(@credence)
+              end
+
+              def to_h
+                {
+                  id:               @id,
+                  proposition:      @proposition,
+                  domain:           @domain,
+                  credence:         @credence.round(4),
+                  credence_label:   credence_label,
+                  state:            state,
+                  evidence_for:     @evidence_for.size,
+                  evidence_against: @evidence_against.size,
+                  entrenchment:     @entrenchment.round(4),
+                  revision_count:   @revision_count,
+                  protected:        @protected
+                }
+              end
+
+              private
+
+              def update_credence_from_evidence(evidence, direction)
+                return if @protected
+
+                adjustment = evidence.weight * EVIDENCE_WEIGHT
+                resistance = @entrenchment * 0.5
+                effective = adjustment * (1.0 - resistance)
+
+                @credence = if direction == :support
+                              [@credence + effective, CREDENCE_CEILING].min
+                            else
+                              [@credence - effective, CREDENCE_FLOOR].max
+                            end
+                @updated_at = Time.now.utc
+                deepen_entrenchment
+              end
+
+              def deepen_entrenchment
+                @entrenchment = [@entrenchment + ENTRENCHMENT_ALPHA, 1.0].min
+              end
+
+              def approach_default(value)
+                diff = DEFAULT_CREDENCE - value
+                value + (diff * DECAY_RATE)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end