lex-embodied-simulation 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 8c0a42550d81eb660131739e12d4413bac5aaf0a68392880c008568a231e3bfa
+  data.tar.gz: e38b1c187179a9a0de618c25fa28af58bf095cf8fd5906ed977e0066fb5eb807
+SHA512:
+  metadata.gz: 28c09ac49bc090736f6bb3696a3c555f929b1d6130ffbc9fb16a9af85d3fbb17e96f4df334810b32208347d3969f8ee5f46f2e17c53bdebff0821ab32cd53e71
+  data.tar.gz: c40107b484e1bdd2ad77620ce8b9e9edd4a46d0cda1ac5c38b33439b4537b7eecda2df36b01a85a25e5f4ee97eb00e9277e2e35991cdd1858bac3b01b99be0cf

data/lib/legion/extensions/embodied_simulation/client.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module EmbodiedSimulation
+      class Client
+        include Runners::EmbodiedSimulation
+
+        def initialize(engine: nil)
+          @engine = engine || Helpers::SimulationEngine.new
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/embodied_simulation/helpers/constants.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module EmbodiedSimulation
+      module Helpers
+        module Constants
+          MAX_SIMULATIONS = 30
+          MAX_STEPS_PER_SIM = 20
+          MAX_HISTORY = 200
+          MAX_SCENARIOS = 50
+
+          DEFAULT_FIDELITY = 0.5
+          FIDELITY_FLOOR = 0.1
+          FIDELITY_DECAY = 0.01
+          FIDELITY_BOOST = 0.05
+
+          OUTCOME_CONFIDENCE_FLOOR = 0.05
+          CALIBRATION_ALPHA = 0.1
+
+          SIMULATION_TYPES = %i[
+            action_rehearsal counterfactual empathic
+            predictive exploratory defensive
+          ].freeze
+
+          SIMULATION_STATES = %i[
+            pending running completed failed aborted
+          ].freeze
+
+          OUTCOME_VALENCES = %i[
+            positive negative neutral ambiguous
+          ].freeze
+
+          FIDELITY_LABELS = {
+            (0.8..)     => :vivid,
+            (0.6...0.8) => :clear,
+            (0.4...0.6) => :hazy,
+            (0.2...0.4) => :vague,
+            (..0.2)     => :phantom
+          }.freeze
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/embodied_simulation/helpers/simulation.rb

@@ -0,0 +1,132 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module EmbodiedSimulation
+      module Helpers
+        class Simulation
+          include Constants
+
+          attr_reader :id, :simulation_type, :domain, :initial_state, :steps,
+                      :state, :outcome_valence, :fidelity, :created_at
+
+          def initialize(id:, simulation_type:, domain:, initial_state:, fidelity: DEFAULT_FIDELITY)
+            raise ArgumentError, "invalid type: #{simulation_type}" unless SIMULATION_TYPES.include?(simulation_type)
+
+            @id              = id
+            @simulation_type = simulation_type
+            @domain          = domain
+            @initial_state   = initial_state
+            @steps           = []
+            @state           = :pending
+            @outcome_valence = nil
+            @fidelity        = fidelity.to_f.clamp(FIDELITY_FLOOR, 1.0)
+            @created_at      = Time.now.utc
+          end
+
+          def add_step(action:, expected_state:, confidence: DEFAULT_FIDELITY, somatic_signal: 0.0)
+            return nil if @steps.size >= MAX_STEPS_PER_SIM
+            return nil unless %i[pending running].include?(@state)
+
+            @state = :running if @state == :pending
+            step = SimulationStep.new(
+              index: @steps.size, action: action, expected_state: expected_state,
+              confidence: confidence, somatic_signal: somatic_signal
+            )
+            @steps << step
+            step
+          end
+
+          def complete(valence:)
+            return nil unless OUTCOME_VALENCES.include?(valence)
+            return nil unless %i[pending running].include?(@state)
+
+            @state           = :completed
+            @outcome_valence = valence
+          end
+
+          def abort_simulation
+            return nil if @state == :completed
+
+            @state = :aborted
+          end
+
+          def fail_simulation
+            return nil if @state == :completed
+
+            @state = :failed
+          end
+
+          def running?
+            @state == :running
+          end
+
+          def completed?
+            @state == :completed
+          end
+
+          def successful?
+            @state == :completed && @outcome_valence == :positive
+          end
+
+          def aggregate_somatic
+            return 0.0 if @steps.empty?
+
+            @steps.sum(&:somatic_signal) / @steps.size
+          end
+
+          def aggregate_confidence
+            return 0.0 if @steps.empty?
+
+            @steps.sum(&:confidence) / @steps.size
+          end
+
+          def negative_signals?
+            @steps.any?(&:negative_signal?)
+          end
+
+          def step_count
+            @steps.size
+          end
+
+          def counterfactual?
+            @simulation_type == :counterfactual
+          end
+
+          def rehearsal?
+            @simulation_type == :action_rehearsal
+          end
+
+          def empathic?
+            @simulation_type == :empathic
+          end
+
+          def fidelity_label
+            FIDELITY_LABELS.each { |range, lbl| return lbl if range.cover?(@fidelity) }
+            :phantom
+          end
+
+          def decay_fidelity
+            @fidelity = [@fidelity - FIDELITY_DECAY, FIDELITY_FLOOR].max
+          end
+
+          def to_h
+            {
+              id:              @id,
+              simulation_type: @simulation_type,
+              domain:          @domain,
+              state:           @state,
+              step_count:      @steps.size,
+              outcome_valence: @outcome_valence,
+              fidelity:        @fidelity.round(4),
+              fidelity_label:  fidelity_label,
+              somatic_avg:     aggregate_somatic.round(4),
+              confidence_avg:  aggregate_confidence.round(4),
+              created_at:      @created_at
+            }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/embodied_simulation/helpers/simulation_engine.rb

@@ -0,0 +1,176 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module EmbodiedSimulation
+      module Helpers
+        class SimulationEngine
+          include Constants
+
+          attr_reader :simulations, :history, :calibration
+
+          def initialize
+            @simulations = {}
+            @counter     = 0
+            @history     = []
+            @calibration = 0.5
+          end
+
+          def create_simulation(simulation_type:, domain:, initial_state:, fidelity: DEFAULT_FIDELITY)
+            return nil unless SIMULATION_TYPES.include?(simulation_type)
+            return nil if @simulations.size >= MAX_SIMULATIONS
+
+            @counter += 1
+            sim_id = :"sim_#{@counter}"
+            sim = Simulation.new(
+              id: sim_id, simulation_type: simulation_type,
+              domain: domain, initial_state: initial_state, fidelity: fidelity
+            )
+            @simulations[sim_id] = sim
+            sim
+          end
+
+          def add_step(sim_id:, action:, expected_state:, confidence: DEFAULT_FIDELITY, somatic_signal: 0.0)
+            sim = @simulations[sim_id]
+            return nil unless sim
+
+            sim.add_step(action: action, expected_state: expected_state,
+                         confidence: confidence, somatic_signal: somatic_signal)
+          end
+
+          def complete_simulation(sim_id:, valence:)
+            sim = @simulations[sim_id]
+            return nil unless sim
+
+            result = sim.complete(valence: valence)
+            record_completion(sim) if result
+            result
+          end
+
+          def abort_simulation(sim_id:)
+            sim = @simulations[sim_id]
+            return nil unless sim
+
+            sim.abort_simulation
+          end
+
+          def rehearse(domain:, action_sequence:, initial_state: {})
+            sim = create_simulation(
+              simulation_type: :action_rehearsal, domain: domain,
+              initial_state: initial_state
+            )
+            return nil unless sim
+
+            run_sequence(sim, action_sequence)
+            sim
+          end
+
+          def counterfactual(domain:, actual_outcome:, alternative_actions:, initial_state: {})
+            sim = create_simulation(
+              simulation_type: :counterfactual, domain: domain,
+              initial_state: initial_state.merge(actual_outcome: actual_outcome)
+            )
+            return nil unless sim
+
+            run_sequence(sim, alternative_actions)
+            sim
+          end
+
+          def evaluate_simulation(sim_id:)
+            sim = @simulations[sim_id]
+            return nil unless sim
+
+            build_evaluation(sim)
+          end
+
+          def compare_simulations(*sim_ids)
+            sims = sim_ids.filter_map { |id| @simulations[id] }
+            return [] if sims.empty?
+
+            sims.sort_by { |s| -(s.aggregate_somatic + s.aggregate_confidence) }.map(&:to_h)
+          end
+
+          def simulations_for(domain:)
+            @simulations.values.select { |s| s.domain == domain }.map(&:to_h)
+          end
+
+          def active_simulations
+            @simulations.values.select(&:running?).map(&:to_h)
+          end
+
+          def completed_simulations
+            @simulations.values.select(&:completed?).map(&:to_h)
+          end
+
+          def calibrate(sim_id:, actual_valence:)
+            sim = @simulations[sim_id]
+            return nil unless sim&.completed?
+
+            match = sim.outcome_valence == actual_valence ? 1.0 : 0.0
+            @calibration += CALIBRATION_ALPHA * (match - @calibration)
+            @calibration = @calibration.clamp(0.0, 1.0)
+            sim.fidelity_label
+          end
+
+          def decay_all
+            @simulations.each_value(&:decay_fidelity)
+            @simulations.reject! { |_, s| s.fidelity <= FIDELITY_FLOOR && s.completed? }
+          end
+
+          def to_h
+            {
+              simulation_count: @simulations.size,
+              active_count:     @simulations.values.count(&:running?),
+              completed_count:  @simulations.values.count(&:completed?),
+              calibration:      @calibration.round(4),
+              history_size:     @history.size
+            }
+          end
+
+          private
+
+          def run_sequence(sim, actions)
+            actions.each_with_index do |act, _i|
+              sim.add_step(
+                action:         act[:action] || act,
+                expected_state: act[:expected_state] || {},
+                confidence:     act[:confidence] || DEFAULT_FIDELITY,
+                somatic_signal: act[:somatic_signal] || 0.0
+              )
+            end
+          end
+
+          def record_completion(sim)
+            @history << {
+              id:      sim.id, type: sim.simulation_type, domain: sim.domain,
+              valence: sim.outcome_valence, steps: sim.step_count, at: Time.now.utc
+            }
+            @history.shift while @history.size > MAX_HISTORY
+          end
+
+          def build_evaluation(sim)
+            {
+              id:             sim.id,
+              state:          sim.state,
+              recommendation: recommend(sim),
+              somatic_avg:    sim.aggregate_somatic.round(4),
+              confidence_avg: sim.aggregate_confidence.round(4),
+              has_warnings:   sim.negative_signals?,
+              fidelity:       sim.fidelity.round(4),
+              step_count:     sim.step_count
+            }
+          end
+
+          def recommend(sim)
+            return :insufficient_data if sim.steps.empty?
+            return :abort if sim.aggregate_somatic < -0.5
+            return :proceed_with_caution if sim.negative_signals?
+            return :proceed if sim.aggregate_somatic >= 0.0 && sim.aggregate_confidence >= 0.5
+
+            :reconsider
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/embodied_simulation/helpers/simulation_step.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module EmbodiedSimulation
+      module Helpers
+        class SimulationStep
+          include Constants
+
+          attr_reader :index, :action, :expected_state, :confidence, :somatic_signal
+
+          def initialize(index:, action:, expected_state:, confidence: DEFAULT_FIDELITY, somatic_signal: 0.0)
+            @index          = index
+            @action         = action
+            @expected_state = expected_state
+            @confidence     = confidence.to_f.clamp(0.0, 1.0)
+            @somatic_signal = somatic_signal.to_f.clamp(-1.0, 1.0)
+          end
+
+          def positive_signal?
+            @somatic_signal > 0.2
+          end
+
+          def negative_signal?
+            @somatic_signal < -0.2
+          end
+
+          def high_confidence?
+            @confidence >= 0.7
+          end
+
+          def to_h
+            {
+              index:          @index,
+              action:         @action,
+              expected_state: @expected_state,
+              confidence:     @confidence.round(4),
+              somatic_signal: @somatic_signal.round(4)
+            }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/embodied_simulation/runners/embodied_simulation.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module EmbodiedSimulation
+      module Runners
+        module EmbodiedSimulation
+          include Helpers::Constants
+
+          include Legion::Extensions::Helpers::Lex if defined?(Legion::Extensions::Helpers::Lex)
+
+          def create_simulation(simulation_type:, domain:, initial_state: {}, fidelity: DEFAULT_FIDELITY, **)
+            sim = engine.create_simulation(
+              simulation_type: simulation_type, domain: domain,
+              initial_state: initial_state, fidelity: fidelity
+            )
+            return { success: false, reason: :limit_or_invalid_type } unless sim
+
+            { success: true, simulation_id: sim.id, simulation_type: sim.simulation_type, domain: sim.domain }
+          end
+
+          def add_simulation_step(sim_id:, action:, expected_state: {}, confidence: DEFAULT_FIDELITY,
+                                  somatic_signal: 0.0, **)
+            step = engine.add_step(
+              sim_id: sim_id, action: action, expected_state: expected_state,
+              confidence: confidence, somatic_signal: somatic_signal
+            )
+            return { success: false, reason: :not_found_or_full } unless step
+
+            { success: true, step_index: step.index, action: step.action }
+          end
+
+          def complete_simulation(sim_id:, valence:, **)
+            result = engine.complete_simulation(sim_id: sim_id, valence: valence)
+            return { success: false, reason: :not_found_or_invalid } unless result
+
+            { success: true, simulation_id: sim_id, valence: valence }
+          end
+
+          def rehearse_action(domain:, action_sequence:, initial_state: {}, **)
+            sim = engine.rehearse(domain: domain, action_sequence: action_sequence, initial_state: initial_state)
+            return { success: false, reason: :limit_reached } unless sim
+
+            { success: true, simulation_id: sim.id, step_count: sim.step_count,
+              somatic_avg: sim.aggregate_somatic.round(4) }
+          end
+
+          def run_counterfactual(domain:, actual_outcome:, alternative_actions:, initial_state: {}, **)
+            sim = engine.counterfactual(
+              domain: domain, actual_outcome: actual_outcome,
+              alternative_actions: alternative_actions, initial_state: initial_state
+            )
+            return { success: false, reason: :limit_reached } unless sim
+
+            { success: true, simulation_id: sim.id, step_count: sim.step_count }
+          end
+
+          def evaluate_simulation(sim_id:, **)
+            result = engine.evaluate_simulation(sim_id: sim_id)
+            return { success: false, reason: :not_found } unless result
+
+            { success: true }.merge(result)
+          end
+
+          def compare_simulations(sim_ids:, **)
+            ranked = engine.compare_simulations(*sim_ids)
+            { success: true, ranked: ranked, count: ranked.size }
+          end
+
+          def calibrate_simulation(sim_id:, actual_valence:, **)
+            label = engine.calibrate(sim_id: sim_id, actual_valence: actual_valence)
+            return { success: false, reason: :not_found_or_incomplete } unless label
+
+            { success: true, calibration: engine.calibration.round(4), fidelity_label: label }
+          end
+
+          def update_embodied_simulation(**)
+            engine.decay_all
+            { success: true }.merge(engine.to_h)
+          end
+
+          def embodied_simulation_stats(**)
+            { success: true }.merge(engine.to_h)
+          end
+
+          private
+
+          def engine
+            @engine ||= Helpers::SimulationEngine.new
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/embodied_simulation/version.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module EmbodiedSimulation
+      VERSION = '0.1.0'
+    end
+  end
+end

metadata

@@ -0,0 +1,68 @@
+--- !ruby/object:Gem::Specification
+name: lex-embodied-simulation
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Esity
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: legion-gaia
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Embodied simulation engine for LegionIO — mental rehearsal, action simulation,
+  and counterfactual reasoning
+email:
+- matthewdiverson@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/legion/extensions/embodied_simulation/client.rb
+- lib/legion/extensions/embodied_simulation/helpers/constants.rb
+- lib/legion/extensions/embodied_simulation/helpers/simulation.rb
+- lib/legion/extensions/embodied_simulation/helpers/simulation_engine.rb
+- lib/legion/extensions/embodied_simulation/helpers/simulation_step.rb
+- lib/legion/extensions/embodied_simulation/runners/embodied_simulation.rb
+- lib/legion/extensions/embodied_simulation/version.rb
+homepage: https://github.com/LegionIO/lex-embodied-simulation
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/LegionIO/lex-embodied-simulation
+  source_code_uri: https://github.com/LegionIO/lex-embodied-simulation
+  documentation_uri: https://github.com/LegionIO/lex-embodied-simulation/blob/master/README.md
+  changelog_uri: https://github.com/LegionIO/lex-embodied-simulation/blob/master/CHANGELOG.md
+  bug_tracker_uri: https://github.com/LegionIO/lex-embodied-simulation/issues
+  rubygems_mfa_required: 'true'
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.4'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.9
+specification_version: 4
+summary: Barsalou's grounded cognition for LegionIO
+test_files: []