lex-agentic-inference 0.1.0

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

@@ -0,0 +1,193 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Inference
+        module BeliefRevision
+          module Helpers
+            class BeliefNetwork
+              include Constants
+
+              attr_reader :beliefs, :links, :history
+
+              def initialize
+                @beliefs  = {}
+                @links    = []
+                @counter  = 0
+                @ev_count = 0
+                @history  = []
+              end
+
+              def add_belief(proposition:, domain: :general, credence: DEFAULT_CREDENCE)
+                return nil if @beliefs.size >= MAX_BELIEFS
+
+                @counter += 1
+                belief_id = :"belief_#{@counter}"
+                belief = Belief.new(id: belief_id, proposition: proposition, domain: domain, credence: credence)
+                @beliefs[belief_id] = belief
+                belief
+              end
+
+              def add_evidence(belief_id:, evidence_type:, content:, direction: :support, weight: EVIDENCE_WEIGHT,
+                               source: :unknown)
+                belief = @beliefs[belief_id]
+                return nil unless belief
+
+                @ev_count += 1
+                ev = Evidence.new(id: :"ev_#{@ev_count}", evidence_type: evidence_type,
+                                  content: content, weight: weight, source: source)
+                result = direction == :support ? belief.add_supporting_evidence(ev) : belief.add_opposing_evidence(ev)
+                propagate_evidence(belief_id, direction) if result
+                record_event(:evidence, belief_id: belief_id, direction: direction)
+                result
+              end
+
+              def link_beliefs(from_id:, to_id:, link_type:)
+                return nil unless @beliefs.key?(from_id) && @beliefs.key?(to_id)
+                return nil unless LINK_TYPES.include?(link_type)
+                return nil if @links.size >= MAX_LINKS
+
+                link = { from: from_id, to: to_id, type: link_type }
+                @links << link
+                link
+              end
+
+              def revise_belief(belief_id:, new_credence:)
+                belief = @beliefs[belief_id]
+                return nil unless belief
+
+                belief.revise(new_credence: new_credence)
+                record_event(:revision, belief_id: belief_id, new_credence: new_credence)
+                belief
+              end
+
+              def contradictions
+                pairs = []
+                ids = @beliefs.keys
+                ids.combination(2) do |a, b|
+                  pairs << [a, b] if @beliefs[a].contradicts?(@beliefs[b]) && linked?(a, b)
+                end
+                pairs
+              end
+
+              def beliefs_in(domain:)
+                @beliefs.values.select { |b| b.domain == domain }.map(&:to_h)
+              end
+
+              def believed
+                @beliefs.values.select(&:believed?).map(&:to_h)
+              end
+
+              def disbelieved
+                @beliefs.values.select(&:disbelieved?).map(&:to_h)
+              end
+
+              def entrenched
+                @beliefs.values.select { |b| b.state == :entrenched }.map(&:to_h)
+              end
+
+              def supported_beliefs(belief_id:)
+                linked_ids = @links.select { |l| l[:from] == belief_id && l[:type] == :supports }.map { |l| l[:to] }
+                linked_ids.filter_map { |id| @beliefs[id]&.to_h }
+              end
+
+              def undermining_beliefs(belief_id:)
+                linked_ids = @links.select { |l| l[:to] == belief_id && l[:type] == :undermines }.map { |l| l[:from] }
+                linked_ids.filter_map { |id| @beliefs[id]&.to_h }
+              end
+
+              def decay_all
+                @beliefs.each_value(&:decay)
+              end
+
+              def coherence_score
+                return 1.0 if @links.empty?
+
+                coherent = @links.count { |l| link_coherent?(l) }
+                coherent.to_f / @links.size
+              end
+
+              def to_h
+                {
+                  belief_count:        @beliefs.size,
+                  link_count:          @links.size,
+                  believed_count:      @beliefs.values.count(&:believed?),
+                  disbelieved_count:   @beliefs.values.count(&:disbelieved?),
+                  entrenched_count:    @beliefs.values.count { |b| b.state == :entrenched },
+                  contradiction_count: contradictions.size,
+                  coherence:           coherence_score.round(4),
+                  history_size:        @history.size
+                }
+              end
+
+              PROPAGATION_SIGNS = {
+                %i[supports support]   => 1,
+                %i[supports oppose]    => -1,
+                %i[undermines support] => -1,
+                %i[undermines oppose]  => 1
+              }.freeze
+
+              private
+
+              def propagate_evidence(belief_id, direction)
+                @links.each do |link|
+                  next unless link[:from] == belief_id
+
+                  target = @beliefs[link[:to]]
+                  next unless target
+
+                  apply_propagation(target, link[:type], direction)
+                end
+              end
+
+              def apply_propagation(target, link_type, direction)
+                return if target.protected?
+
+                shift = propagation_shift(link_type, direction)
+                return if shift.zero?
+
+                target.revise(new_credence: target.credence + shift)
+              end
+
+              def propagation_shift(link_type, direction)
+                sign = PROPAGATION_SIGNS.fetch([link_type, direction], 0)
+                EVIDENCE_WEIGHT * 0.5 * sign
+              end
+
+              def linked?(id_a, id_b)
+                @links.any? do |l|
+                  (l[:from] == id_a && l[:to] == id_b) || (l[:from] == id_b && l[:to] == id_a)
+                end
+              end
+
+              def link_coherent?(link)
+                from = @beliefs[link[:from]]
+                to = @beliefs[link[:to]]
+                return true unless from && to
+
+                check_link_coherence(from, to, link[:type])
+              end
+
+              def check_link_coherence(from, to, type)
+                return support_coherent?(from, to) if type == :supports
+                return from.believed? != to.believed? if type == :undermines
+
+                true
+              end
+
+              def support_coherent?(from, to)
+                from.believed? == to.believed?
+              end
+
+              def record_event(type, **details)
+                @history << { type: type, at: Time.now.utc }.merge(details)
+                @history.shift while @history.size > MAX_HISTORY
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Inference
+        module BeliefRevision
+          module Helpers
+            module Constants
+              MAX_BELIEFS = 200
+              MAX_EVIDENCE_PER_BELIEF = 50
+              MAX_LINKS = 500
+              MAX_HISTORY = 300
+
+              DEFAULT_CREDENCE = 0.5
+              CREDENCE_FLOOR = 0.01
+              CREDENCE_CEILING = 0.99
+              ENTRENCHMENT_ALPHA = 0.05
+              EVIDENCE_WEIGHT = 0.15
+              DECAY_RATE = 0.005
+              CONTRADICTION_THRESHOLD = 0.3
+
+              EVIDENCE_TYPES = %i[
+                observation testimony inference analogy
+                authority memory simulation
+              ].freeze
+
+              LINK_TYPES = %i[supports undermines entails independent].freeze
+
+              BELIEF_STATES = %i[
+                tentative held entrenched protected
+              ].freeze
+
+              CREDENCE_LABELS = {
+                (0.9..)     => :near_certain,
+                (0.7...0.9) => :confident,
+                (0.5...0.7) => :leaning,
+                (0.3...0.5) => :uncertain,
+                (0.1...0.3) => :doubtful,
+                (..0.1)     => :disbelieved
+              }.freeze
+
+              STATE_THRESHOLDS = {
+                entrenched: 0.85,
+                held:       0.6,
+                tentative:  0.3
+              }.freeze
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Inference
+        module BeliefRevision
+          module Helpers
+            class Evidence
+              include Constants
+
+              attr_reader :id, :evidence_type, :content, :weight, :source, :created_at
+
+              def initialize(id:, evidence_type:, content:, weight: EVIDENCE_WEIGHT, source: :unknown)
+                raise ArgumentError, "invalid type: #{evidence_type}" unless EVIDENCE_TYPES.include?(evidence_type)
+
+                @id            = id
+                @evidence_type = evidence_type
+                @content       = content
+                @weight        = weight.to_f.clamp(0.0, 1.0)
+                @source        = source
+                @created_at    = Time.now.utc
+              end
+
+              def strong?
+                @weight >= 0.5
+              end
+
+              def weak?
+                @weight < 0.2
+              end
+
+              def to_h
+                {
+                  id:            @id,
+                  evidence_type: @evidence_type,
+                  content:       @content,
+                  weight:        @weight.round(4),
+                  source:        @source,
+                  created_at:    @created_at
+                }
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Inference
+        module BeliefRevision
+          module Runners
+            module BeliefRevision
+              include Helpers::Constants
+              include Legion::Extensions::Helpers::Lex if defined?(Legion::Extensions::Helpers::Lex)
+
+              def add_belief(proposition:, domain: :general, credence: DEFAULT_CREDENCE, **)
+                belief = network.add_belief(proposition: proposition, domain: domain, credence: credence)
+                return { success: false, reason: :limit_reached } unless belief
+
+                { success: true, belief_id: belief.id, credence: belief.credence.round(4) }
+              end
+
+              def submit_evidence(belief_id:, evidence_type:, content:, direction: :support,
+                                  weight: EVIDENCE_WEIGHT, source: :unknown, **)
+                ev = network.add_evidence(
+                  belief_id: belief_id, evidence_type: evidence_type, content: content,
+                  direction: direction, weight: weight, source: source
+                )
+                return { success: false, reason: :not_found_or_full } unless ev
+
+                belief = network.beliefs[belief_id]
+                { success: true, evidence_id: ev.id, belief_credence: belief.credence.round(4) }
+              end
+
+              def link_beliefs(from_id:, to_id:, link_type:, **)
+                result = network.link_beliefs(from_id: from_id, to_id: to_id, link_type: link_type)
+                return { success: false, reason: :invalid_or_limit } unless result
+
+                { success: true, from: from_id, to: to_id, link_type: link_type }
+              end
+
+              def revise_belief(belief_id:, new_credence:, **)
+                belief = network.revise_belief(belief_id: belief_id, new_credence: new_credence)
+                return { success: false, reason: :not_found } unless belief
+
+                { success: true, belief_id: belief_id, credence: belief.credence.round(4), state: belief.state }
+              end
+
+              def belief_status(belief_id:, **)
+                belief = network.beliefs[belief_id]
+                return { success: false, reason: :not_found } unless belief
+
+                { success: true }.merge(belief.to_h)
+              end
+
+              def find_contradictions(**)
+                pairs = network.contradictions
+                { success: true, contradictions: pairs, count: pairs.size }
+              end
+
+              def beliefs_in_domain(domain:, **)
+                beliefs = network.beliefs_in(domain: domain)
+                { success: true, beliefs: beliefs, count: beliefs.size }
+              end
+
+              def coherence_report(**)
+                { success: true, coherence: network.coherence_score.round(4),
+                  believed: network.believed.size, disbelieved: network.disbelieved.size,
+                  entrenched: network.entrenched.size, contradictions: network.contradictions.size }
+              end
+
+              def update_belief_revision(**)
+                network.decay_all
+                { success: true }.merge(network.to_h)
+              end
+
+              def belief_revision_stats(**)
+                { success: true }.merge(network.to_h)
+              end
+
+              private
+
+              def network
+                @network ||= Helpers::BeliefNetwork.new
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

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

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

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require_relative 'belief_revision/version'
+require_relative 'belief_revision/helpers/constants'
+require_relative 'belief_revision/helpers/belief'
+require_relative 'belief_revision/helpers/belief_network'
+require_relative 'belief_revision/helpers/evidence'
+require_relative 'belief_revision/runners/belief_revision'
+require_relative 'belief_revision/client'
+
+module Legion
+  module Extensions
+    module Agentic
+      module Inference
+        module BeliefRevision
+          # Sub-module for belief revision: AGM contraction, expansion, and revision
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/agentic/inference/causal_attribution/helpers/attribution'
+require 'legion/extensions/agentic/inference/causal_attribution/helpers/attribution_engine'
+require 'legion/extensions/agentic/inference/causal_attribution/runners/causal_attribution'
+
+module Legion
+  module Extensions
+    module Agentic
+      module Inference
+        module CausalAttribution
+          class Client
+            include Runners::CausalAttribution
+
+            def initialize(**)
+              @engine = Helpers::AttributionEngine.new
+            end
+
+            private
+
+            attr_reader :engine
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/inference/causal_attribution/helpers/attribution.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+require 'securerandom'
+
+module Legion
+  module Extensions
+    module Agentic
+      module Inference
+        module CausalAttribution
+          module Helpers
+            class Attribution
+              MAX_ATTRIBUTIONS = 200
+              MAX_HISTORY      = 300
+
+              LOCUS_VALUES           = %i[internal external].freeze
+              STABILITY_VALUES       = %i[stable unstable].freeze
+              CONTROLLABILITY_VALUES = %i[controllable uncontrollable].freeze
+
+              DEFAULT_CONFIDENCE  = 0.5
+              CONFIDENCE_FLOOR    = 0.0
+              CONFIDENCE_CEILING  = 1.0
+              DECAY_RATE          = 0.02
+
+              ATTRIBUTION_EMOTIONS = {
+                %i[internal stable controllable]     => :guilt,
+                %i[internal stable uncontrollable]   => :shame,
+                %i[internal unstable controllable]   => :regret,
+                %i[internal unstable uncontrollable] => :surprise,
+                %i[external stable controllable]     => :anger,
+                %i[external stable uncontrollable]   => :helplessness,
+                %i[external unstable controllable]   => :frustration,
+                %i[external unstable uncontrollable] => :relief
+              }.freeze
+
+              attr_reader :id, :event, :outcome, :domain, :locus, :stability, :controllability,
+                          :confidence, :emotional_response, :created_at
+
+              def initialize(event:, outcome:, domain:, locus:, stability:, controllability:,
+                             confidence: DEFAULT_CONFIDENCE)
+                @id                = SecureRandom.uuid
+                @event             = event
+                @outcome           = outcome
+                @domain            = domain
+                @locus             = locus
+                @stability         = stability
+                @controllability   = controllability
+                @confidence        = confidence.clamp(CONFIDENCE_FLOOR, CONFIDENCE_CEILING)
+                @emotional_response = ATTRIBUTION_EMOTIONS[pattern]
+                @created_at        = Time.now.utc
+              end
+
+              def pattern
+                [locus, stability, controllability]
+              end
+
+              def internal?
+                locus == :internal
+              end
+
+              def external?
+                locus == :external
+              end
+
+              def stable?
+                stability == :stable
+              end
+
+              def controllable?
+                controllability == :controllable
+              end
+
+              def to_h
+                {
+                  id:                 id,
+                  event:              event,
+                  outcome:            outcome,
+                  domain:             domain,
+                  locus:              locus,
+                  stability:          stability,
+                  controllability:    controllability,
+                  confidence:         confidence,
+                  emotional_response: emotional_response,
+                  created_at:         created_at
+                }
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end