active-inference 0.0.1 → 0.2.1

package/dist/transition/dirichlet.transition.js

@@ -0,0 +1,134 @@
+import { DiscreteBelief } from '../beliefs/discrete.belief';
+/**
+ * Learnable transition model using Dirichlet concentrations.
+ *
+ * Instead of a fixed B matrix, this model maintains Dirichlet pseudo-counts
+ * from which the probability matrix P(s'|s,a) is derived by normalization:
+ *
+ *   P(s'|s,a) = b[a][s][s'] / Σ_s'' b[a][s][s'']
+ *
+ * After each state transition, concentrations are updated using the
+ * outer product of prior and posterior beliefs:
+ *
+ *   b[a][s][s'] += Q_prior(s) × Q_posterior(s')
+ *
+ * @typeParam A - Union type of possible action names
+ * @typeParam S - Union type of possible state names
+ *
+ * @example
+ * ```typescript
+ * const transition = new DirichletTransition({
+ *   move: {
+ *     here: { here: 1, there: 5 },  // move from here → likely end up there
+ *     there: { here: 1, there: 5 },
+ *   },
+ *   stay: {
+ *     here: { here: 5, there: 1 },
+ *     there: { here: 1, there: 5 },
+ *   },
+ * });
+ * ```
+ */
+export class DirichletTransition {
+    /**
+     * @param concentrations - Dirichlet pseudo-counts b[a][s][s'].
+     *   Structure: action → current_state → next_state → count.
+     *   Each value must be > 0.
+     */
+    constructor(concentrations) {
+        this.concentrations = concentrations;
+        this._matrix = null;
+        // Deep copy to avoid aliasing
+        this.concentrations = {};
+        for (const a of Object.keys(concentrations)) {
+            this.concentrations[a] = {};
+            for (const s of Object.keys(concentrations[a])) {
+                this.concentrations[a][s] = { ...concentrations[a][s] };
+            }
+        }
+    }
+    get actions() {
+        return Object.keys(this.concentrations);
+    }
+    get states() {
+        const firstAction = this.actions[0];
+        return Object.keys(this.concentrations[firstAction] || {});
+    }
+    /**
+     * Normalized probability matrix derived from concentrations.
+     * Lazily computed and cached; invalidated on learn().
+     *
+     * Row-wise normalization (per action a, per current state s):
+     *   P(s'|s,a) = b[a][s][s'] / Σ_s'' b[a][s][s'']
+     */
+    get matrix() {
+        if (this._matrix === null) {
+            this._matrix = this.normalize();
+        }
+        return this._matrix;
+    }
+    getTransition(state, action) {
+        return this.matrix[action]?.[state] ?? {};
+    }
+    predict(belief, action) {
+        const newDist = {};
+        for (const state of this.states) {
+            newDist[state] = 0;
+        }
+        for (const currentState of belief.states) {
+            const transition = this.getTransition(currentState, action);
+            const currentProb = belief.probability(currentState);
+            for (const nextState of Object.keys(transition)) {
+                newDist[nextState] += transition[nextState] * currentProb;
+            }
+        }
+        return new DiscreteBelief(newDist);
+    }
+    /**
+     * Update concentrations from a state transition.
+     *
+     * Uses outer product of prior and posterior beliefs:
+     *   b[a][s][s'] += Q_prior(s) × Q_posterior(s')
+     *
+     * This encodes the agent's best estimate of the transition
+     * that occurred, weighted by uncertainty in both states.
+     *
+     * @param action - The action that was taken
+     * @param priorBelief - Belief distribution before the action
+     * @param posteriorBelief - Belief distribution after observing the outcome
+     */
+    learn(action, priorBelief, posteriorBelief) {
+        for (const s of this.states) {
+            for (const sPrime of this.states) {
+                this.concentrations[action][s][sPrime] +=
+                    (priorBelief[s] ?? 0) * (posteriorBelief[sPrime] ?? 0);
+            }
+        }
+        this._matrix = null;
+    }
+    /**
+     * Row-wise normalization of concentrations.
+     * For each (action, current_state):
+     *   P(s'|s,a) = b[a][s][s'] / Σ_s'' b[a][s][s'']
+     */
+    normalize() {
+        const matrix = {};
+        for (const a of this.actions) {
+            matrix[a] = {};
+            for (const s of this.states) {
+                matrix[a][s] = {};
+                let rowSum = 0;
+                for (const sPrime of this.states) {
+                    rowSum += this.concentrations[a][s][sPrime];
+                }
+                for (const sPrime of this.states) {
+                    matrix[a][s][sPrime] =
+                        rowSum > 0
+                            ? this.concentrations[a][s][sPrime] / rowSum
+                            : 0;
+                }
+            }
+        }
+        return matrix;
+    }
+}

package/dist/transition/gaussian.transition.d.ts

@@ -0,0 +1,49 @@
+import { GaussianBelief } from '../beliefs/gaussian.belief';
+/**
+ * Configuration for a single action's effect on continuous state.
+ *
+ * @param fn - Deterministic transition function: μ' = fn(μ)
+ * @param noise - Process noise variance added after transition
+ */
+export interface GaussianActionModel {
+    fn: (x: number) => number;
+    noise: number;
+}
+/**
+ * Maps each discrete action to its continuous state transition.
+ */
+export type GaussianTransitionConfig<A extends string = string> = Record<A, GaussianActionModel>;
+/**
+ * State transition model for continuous (Gaussian) Active Inference
+ * with discrete actions.
+ *
+ * Each action maps to a transition function and process noise.
+ * Belief propagation uses first-order approximation:
+ *   μ' = fn(μ)
+ *   σ²' = fn'(μ)² · σ² + noise
+ *
+ * where fn'(μ) is approximated via finite differences.
+ *
+ * @example
+ * ```typescript
+ * const transition = new GaussianTransition({
+ *   accelerate: { fn: x => x + 1, noise: 0.1 },
+ *   brake:      { fn: x => x * 0.5, noise: 0.05 },
+ * });
+ *
+ * const predicted = transition.predict(belief, 'accelerate');
+ * ```
+ */
+export declare class GaussianTransition<A extends string = string> {
+    private readonly config;
+    private readonly _actions;
+    constructor(config: GaussianTransitionConfig<A>);
+    get actions(): A[];
+    /**
+     * Predict belief after taking an action.
+     *
+     * Uses first-order (Extended Kalman) approximation for
+     * nonlinear transition functions.
+     */
+    predict(belief: GaussianBelief, action: A): GaussianBelief;
+}

package/dist/transition/gaussian.transition.js

@@ -0,0 +1,46 @@
+import { GaussianBelief } from '../beliefs/gaussian.belief';
+/**
+ * State transition model for continuous (Gaussian) Active Inference
+ * with discrete actions.
+ *
+ * Each action maps to a transition function and process noise.
+ * Belief propagation uses first-order approximation:
+ *   μ' = fn(μ)
+ *   σ²' = fn'(μ)² · σ² + noise
+ *
+ * where fn'(μ) is approximated via finite differences.
+ *
+ * @example
+ * ```typescript
+ * const transition = new GaussianTransition({
+ *   accelerate: { fn: x => x + 1, noise: 0.1 },
+ *   brake:      { fn: x => x * 0.5, noise: 0.05 },
+ * });
+ *
+ * const predicted = transition.predict(belief, 'accelerate');
+ * ```
+ */
+export class GaussianTransition {
+    constructor(config) {
+        this.config = config;
+        this._actions = Object.keys(config);
+    }
+    get actions() {
+        return this._actions;
+    }
+    /**
+     * Predict belief after taking an action.
+     *
+     * Uses first-order (Extended Kalman) approximation for
+     * nonlinear transition functions.
+     */
+    predict(belief, action) {
+        const model = this.config[action];
+        const newMean = model.fn(belief.mean);
+        // Numerical derivative via central finite difference
+        const h = 1e-5;
+        const derivative = (model.fn(belief.mean + h) - model.fn(belief.mean - h)) / (2 * h);
+        const newVariance = derivative * derivative * belief.variance + model.noise;
+        return new GaussianBelief(newMean, newVariance);
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "active-inference",
-    "version": "0.0.1",
+    "version": "0.2.1",
     "description": "Active Inference Framework implementation for JavaScript/TypeScript",
     "main": "dist/index.js",
     "types": "dist/index.d.ts",
@@ -11,7 +11,8 @@
         "test": "vitest run",
         "test:watch": "vitest",
         "build": "tsc",
-        "prepublishOnly": "npm run build"
+        "prepublish": "npm run build",
+        "build:examples": "npx esbuild src/index.ts --bundle --format=esm --outfile=examples/cart-pole/active-inference.bundle.js && cp examples/cart-pole/active-inference.bundle.js examples/trolley-problem/active-inference.bundle.js"
     },
     "keywords": [
         "active-inference",
@@ -26,12 +27,12 @@
     "license": "MIT",
     "repository": {
         "type": "git",
-        "url": "https://github.com/codevanger/active-inference"
+        "url": "https://github.com/Codevanger/active-inference"
     },
     "bugs": {
-        "url": "https://github.com/codevanger/active-inference/issues"
+        "url": "https://github.com/Codevanger/active-inference/issues"
     },
-    "homepage": "https://github.com/codevanger/active-inference#readme",
+    "homepage": "https://github.com/Codevanger/active-inference#readme",
     "devDependencies": {
         "prettier": "^3.8.1",
         "typescript": "^5.9.3",