genesis-ai-cli 7.4.5

package/dist/src/world-model/predictor.d.ts

@@ -0,0 +1,161 @@
+/**
+ * Genesis 6.0 - World Model Predictor
+ *
+ * Unified predictor and simulator for the world model.
+ *
+ * Capabilities:
+ * - Single-step prediction: Predict next state given current state and action
+ * - Multi-step simulation: Generate trajectories over time horizon
+ * - Uncertainty estimation: Quantify epistemic uncertainty in predictions
+ * - Physics reasoning: Common sense physical reasoning
+ *
+ * This module merges the original World Model (v5.2) and World Simulator (v6.0)
+ * into a unified predictive system.
+ *
+ * Key concepts:
+ * - Transition model: P(s' | s, a) - probability of next state
+ * - Trajectory: Sequence of (state, action) pairs
+ * - Branching: Multiple possible futures with probabilities
+ *
+ * References:
+ * - World Models (Ha & Schmidhuber, 2018)
+ * - Dreamer (Hafner et al., 2020)
+ * - MuZero (Schrittwieser et al., 2020)
+ *
+ * Usage:
+ * ```typescript
+ * import { createWorldModelPredictor } from './world-model/predictor.js';
+ *
+ * const predictor = createWorldModelPredictor();
+ *
+ * // Single-step prediction
+ * const nextState = predictor.predict(currentState, action);
+ *
+ * // Multi-step simulation
+ * const trajectory = predictor.simulate(state, actions, 100);
+ *
+ * // Physics reasoning
+ * const answer = predictor.reason({ type: 'collision', ... });
+ * ```
+ */
+import { LatentState, Action, ActionType, PredictedState, Trajectory, WorldModelConfig, PhysicsQuery, PhysicsAnswer, WorldEntity, EntityRelation } from './types.js';
+export interface TransitionModel {
+    transition(state: LatentState, action: Action): number[];
+    uncertainty(state: LatentState, action: Action): number;
+}
+export type PredictorEventType = 'prediction_made' | 'simulation_started' | 'simulation_step' | 'simulation_complete' | 'uncertainty_high' | 'physics_query';
+export type PredictorEventHandler = (event: {
+    type: PredictorEventType;
+    data?: unknown;
+}) => void;
+export declare class WorldModelPredictor {
+    private config;
+    private encoder;
+    private transitionWeights;
+    private eventHandlers;
+    private predictionCount;
+    private simulationCount;
+    private totalPredictionTime;
+    private entities;
+    private relations;
+    constructor(config?: Partial<WorldModelConfig>);
+    private initializeTransitionModels;
+    private actionTypeOffset;
+    /**
+     * Predict next state given current state and action
+     */
+    predict(currentState: LatentState, action: Action): PredictedState;
+    /**
+     * Apply transition model to state
+     */
+    private applyTransition;
+    /**
+     * Encode action to vector
+     */
+    private encodeAction;
+    /**
+     * Generate alternative state (for branching)
+     */
+    private generateAlternative;
+    /**
+     * Generate deterministic noise based on index
+     */
+    private generateNoise;
+    /**
+     * Simulate multiple steps into the future
+     */
+    simulate(initialState: LatentState, actions: Action[], horizon?: number): Trajectory;
+    /**
+     * Generate multiple trajectories (Monte Carlo)
+     */
+    simulateMultiple(initialState: LatentState, actions: Action[], numTrajectories: number, horizon?: number): Trajectory[];
+    /**
+     * Calculate uncertainty of prediction
+     */
+    private calculateUncertainty;
+    private getActionUncertainty;
+    /**
+     * Get uncertainty for a prediction (external interface)
+     */
+    uncertainty(prediction: PredictedState): number;
+    /**
+     * Answer physics/common sense queries
+     */
+    reason(query: PhysicsQuery): PhysicsAnswer;
+    /**
+     * Check collision between objects
+     */
+    private checkCollision;
+    private reasonCollision;
+    /**
+     * Check stability of configuration
+     */
+    private checkStability;
+    /**
+     * Check containment (A inside B)
+     */
+    private checkContainment;
+    /**
+     * Check reachability (can A reach B)
+     */
+    private checkReachability;
+    /**
+     * Check causation (will A cause B)
+     */
+    private checkCausation;
+    /**
+     * Compute trajectory of object
+     */
+    private computeTrajectory;
+    /**
+     * Train agent in simulated environment
+     * Returns reward signal based on trajectory quality
+     */
+    trainAgent(agent: string, policy: (state: LatentState) => Action, episodes: number, maxSteps: number): {
+        avgReward: number;
+        bestTrajectory: Trajectory | null;
+    };
+    /**
+     * Generate random initial state for training
+     */
+    private generateRandomState;
+    private normalize;
+    private calculateEntropy;
+    private simpleHash;
+    addEntity(entity: WorldEntity): void;
+    removeEntity(entityId: string): boolean;
+    getEntity(entityId: string): WorldEntity | undefined;
+    addRelation(relation: EntityRelation): void;
+    on(handler: PredictorEventHandler): () => void;
+    private emit;
+    stats(): {
+        predictionCount: number;
+        simulationCount: number;
+        avgPredictionTime: number;
+        entityCount: number;
+        relationCount: number;
+    };
+    getConfig(): WorldModelConfig;
+}
+export declare function createWorldModelPredictor(config?: Partial<WorldModelConfig>): WorldModelPredictor;
+export declare function createAction(type: ActionType, parameters: Record<string, unknown>, agent: string): Action;