active-inference 0.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Igor Rybakov
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,96 @@
+# Active Inference
+
+TypeScript implementation of the Active Inference framework based on Karl Friston's Free Energy Principle.
+
+## What is Active Inference?
+
+Active Inference is a theory of how biological agents perceive and act in the world. Agents maintain beliefs about hidden states and select actions to minimize **Expected Free Energy** — a quantity that balances:
+
+- **Risk**: avoiding unpreferred outcomes
+- **Ambiguity**: seeking informative observations
+
+This library provides building blocks for creating agents that learn from observations and plan actions using these principles.
+
+## Installation
+
+```bash
+npm install active-inference
+```
+
+## Quick Start
+
+```typescript
+import {
+    createAgent,
+    DiscreteBelief,
+    DiscreteTransition,
+    DiscreteObservation,
+} from 'active-inference';
+
+const agent = createAgent({
+    belief: new DiscreteBelief({ left: 0.5, right: 0.5 }),
+    transitionModel: new DiscreteTransition({
+        go_left: {
+            left: { left: 1.0, right: 0.0 },
+            right: { left: 0.8, right: 0.2 },
+        },
+        go_right: {
+            left: { left: 0.2, right: 0.8 },
+            right: { left: 0.0, right: 1.0 },
+        },
+    }),
+    observationModel: new DiscreteObservation({
+        see_reward: { left: 0.9, right: 0.1 },
+        see_nothing: { left: 0.1, right: 0.9 },
+    }),
+    preferences: { see_reward: 0, see_nothing: -5 },
+});
+
+const action = agent.step('see_reward');
+```
+
+## API
+
+### createAgent(config)
+
+| Parameter | Description |
+|-----------|-------------|
+| `belief` | Initial belief over hidden states |
+| `transitionModel` | P(s'\|s, a) — how actions change states |
+| `observationModel` | P(o\|s) — how states generate observations |
+| `preferences` | Log probabilities of preferred observations |
+| `planningHorizon` | Steps to look ahead (default: 1) |
+| `precision` | Action selection temperature (default: 1) |
+| `seed` | Random seed for reproducibility |
+
+### Agent
+
+| Method | Description |
+|--------|-------------|
+| `step(obs)` | Observe and act |
+| `observe(obs)` | Update beliefs from observation |
+| `act()` | Select action minimizing EFE |
+| `state` | Most likely hidden state |
+| `uncertainty` | Belief entropy (confidence) |
+| `freeEnergy` | Variational Free Energy |
+| `exportBelief()` | Get full belief distribution |
+
+## Contributing
+
+```bash
+git clone https://github.com/codevanger/active-inference
+cd active-inference
+npm install
+npm test
+```
+
+PRs welcome
+
+## References
+
+- [Friston, K. (2010). The free-energy principle: a unified brain theory?](https://www.fil.ion.ucl.ac.uk/~karl/The%20free-energy%20principle%20A%20unified%20brain%20theory.pdf)
+- [Active Inference: A Process Theory](https://direct.mit.edu/neco/article/29/1/1/8207/Active-Inference-A-Process-Theory)
+
+## License
+
+MIT

package/dist/beliefs/discrete.belief.d.ts

@@ -0,0 +1,99 @@
+import { Belief, Distribution } from '../models/belief.model';
+/**
+ * Discrete probability distribution over a finite set of states.
+ *
+ * This is the standard implementation for discrete state spaces,
+ * representing beliefs as a categorical distribution stored as
+ * a simple key-value object.
+ *
+ * The distribution should sum to 1.0, though this is not strictly
+ * enforced (it will be normalized during Bayesian updates).
+ *
+ * @typeParam S - Union type of possible state names
+ *
+ * @example
+ * ```typescript
+ * // Create a belief about weather
+ * const belief = new DiscreteBelief({
+ *   sunny: 0.7,
+ *   rainy: 0.3
+ * });
+ *
+ * console.log(belief.argmax());           // 'sunny'
+ * console.log(belief.probability('sunny')); // 0.7
+ * console.log(belief.entropy());           // ~0.61 nats
+ *
+ * // Update with observation
+ * const likelihood = { sunny: 0.1, rainy: 0.9 }; // saw clouds
+ * const posterior = belief.update(likelihood);
+ * console.log(posterior.argmax()); // 'rainy'
+ * ```
+ */
+export declare class DiscreteBelief<S extends string = string> extends Belief<S> {
+    distribution: Distribution<S>;
+    /**
+     * Create a discrete belief from a probability distribution.
+     *
+     * @param distribution - Object mapping state names to probabilities.
+     *                       Values should be non-negative and ideally sum to 1.
+     *
+     * @example
+     * ```typescript
+     * // Uniform prior over 3 states
+     * const uniform = new DiscreteBelief({
+     *   a: 1/3,
+     *   b: 1/3,
+     *   c: 1/3
+     * });
+     *
+     * // Certain belief
+     * const certain = new DiscreteBelief({
+     *   known: 1.0,
+     *   unknown: 0.0
+     * });
+     * ```
+     */
+    constructor(distribution: Distribution<S>);
+    /**
+     * Get all states in this belief's state space.
+     * Order is determined by object key order (insertion order in ES6+).
+     *
+     * @returns Array of state names
+     */
+    get states(): S[];
+    /**
+     * Get the probability assigned to a specific state.
+     *
+     * @param state - The state to query
+     * @returns Probability between 0 and 1, or 0 if state not found
+     */
+    probability(state: S): number;
+    /**
+     * Perform Bayesian belief update given observation likelihood.
+     *
+     * Computes: posterior(s) ∝ likelihood(s) × prior(s)
+     *
+     * The result is automatically normalized to sum to 1.
+     * If all likelihoods are 0, returns unchanged distribution.
+     *
+     * @param likelihood - P(observation | state) for each state
+     * @returns New DiscreteBelief representing the posterior
+     *
+     * @example
+     * ```typescript
+     * const prior = new DiscreteBelief({ a: 0.5, b: 0.5 });
+     * const likelihood = { a: 0.9, b: 0.1 }; // evidence favors 'a'
+     * const posterior = prior.update(likelihood);
+     * // posterior ≈ { a: 0.9, b: 0.1 }
+     * ```
+     */
+    update(likelihood: Distribution<S>): DiscreteBelief<S>;
+    /**
+     * Create an independent deep copy of this belief.
+     *
+     * Modifications to the copy will not affect the original.
+     *
+     * @returns New DiscreteBelief with same distribution
+     */
+    copy(): DiscreteBelief<S>;
+}

package/dist/beliefs/discrete.belief.js

@@ -0,0 +1,121 @@
+import { Belief } from '../models/belief.model';
+/**
+ * Discrete probability distribution over a finite set of states.
+ *
+ * This is the standard implementation for discrete state spaces,
+ * representing beliefs as a categorical distribution stored as
+ * a simple key-value object.
+ *
+ * The distribution should sum to 1.0, though this is not strictly
+ * enforced (it will be normalized during Bayesian updates).
+ *
+ * @typeParam S - Union type of possible state names
+ *
+ * @example
+ * ```typescript
+ * // Create a belief about weather
+ * const belief = new DiscreteBelief({
+ *   sunny: 0.7,
+ *   rainy: 0.3
+ * });
+ *
+ * console.log(belief.argmax());           // 'sunny'
+ * console.log(belief.probability('sunny')); // 0.7
+ * console.log(belief.entropy());           // ~0.61 nats
+ *
+ * // Update with observation
+ * const likelihood = { sunny: 0.1, rainy: 0.9 }; // saw clouds
+ * const posterior = belief.update(likelihood);
+ * console.log(posterior.argmax()); // 'rainy'
+ * ```
+ */
+export class DiscreteBelief extends Belief {
+    /**
+     * Create a discrete belief from a probability distribution.
+     *
+     * @param distribution - Object mapping state names to probabilities.
+     *                       Values should be non-negative and ideally sum to 1.
+     *
+     * @example
+     * ```typescript
+     * // Uniform prior over 3 states
+     * const uniform = new DiscreteBelief({
+     *   a: 1/3,
+     *   b: 1/3,
+     *   c: 1/3
+     * });
+     *
+     * // Certain belief
+     * const certain = new DiscreteBelief({
+     *   known: 1.0,
+     *   unknown: 0.0
+     * });
+     * ```
+     */
+    constructor(distribution) {
+        super();
+        this.distribution = distribution;
+    }
+    /**
+     * Get all states in this belief's state space.
+     * Order is determined by object key order (insertion order in ES6+).
+     *
+     * @returns Array of state names
+     */
+    get states() {
+        return Object.keys(this.distribution);
+    }
+    /**
+     * Get the probability assigned to a specific state.
+     *
+     * @param state - The state to query
+     * @returns Probability between 0 and 1, or 0 if state not found
+     */
+    probability(state) {
+        return this.distribution[state] ?? 0;
+    }
+    /**
+     * Perform Bayesian belief update given observation likelihood.
+     *
+     * Computes: posterior(s) ∝ likelihood(s) × prior(s)
+     *
+     * The result is automatically normalized to sum to 1.
+     * If all likelihoods are 0, returns unchanged distribution.
+     *
+     * @param likelihood - P(observation | state) for each state
+     * @returns New DiscreteBelief representing the posterior
+     *
+     * @example
+     * ```typescript
+     * const prior = new DiscreteBelief({ a: 0.5, b: 0.5 });
+     * const likelihood = { a: 0.9, b: 0.1 }; // evidence favors 'a'
+     * const posterior = prior.update(likelihood);
+     * // posterior ≈ { a: 0.9, b: 0.1 }
+     * ```
+     */
+    update(likelihood) {
+        const newDist = {};
+        let sum = 0;
+        for (const state of this.states) {
+            newDist[state] =
+                this.distribution[state] * (likelihood[state] ?? 0);
+            sum += newDist[state];
+        }
+        if (sum > 0) {
+            for (const state of this.states) {
+                newDist[state] /= sum;
+            }
+        }
+        return new DiscreteBelief(newDist);
+    }
+    /**
+     * Create an independent deep copy of this belief.
+     *
+     * Modifications to the copy will not affect the original.
+     *
+     * @returns New DiscreteBelief with same distribution
+     */
+    copy() {
+        return new DiscreteBelief({ ...this.distribution });
+    }
+}

package/dist/factory.d.ts

@@ -0,0 +1,168 @@
+import { Belief, Preferences } from './models/belief.model';
+import { ITransitionModel } from './models/transition.model';
+import { IObservationModel } from './models/observation.model';
+import { Agent, Habits } from './models/agent.model';
+/**
+ * Configuration object for creating an Active Inference agent.
+ *
+ * This interface defines all the components needed to instantiate an agent
+ * with its generative model and behavioral parameters.
+ *
+ * ## Required Components
+ *
+ * The generative model consists of:
+ * - **belief**: Initial prior over hidden states (D matrix)
+ * - **transitionModel**: State dynamics P(s'|s,a) (B matrix)
+ * - **observationModel**: Observation likelihood P(o|s) (A matrix)
+ * - **preferences**: Preferred observations as log probabilities (C vector)
+ *
+ * ## Optional Parameters
+ *
+ * Behavioral parameters that tune agent behavior:
+ * - **seed**: For reproducible random behavior
+ * - **planningHorizon**: How far ahead to plan (default: 1)
+ * - **precision**: Action selection temperature (default: 1)
+ * - **habits**: Prior action preferences (E matrix)
+ *
+ * @typeParam A - Union type of possible action names
+ * @typeParam O - Union type of possible observation names
+ * @typeParam S - Union type of possible state names
+ *
+ * @example
+ * ```typescript
+ * const config: AgentConfig<'left' | 'right', 'see_goal' | 'see_wall', 'at_goal' | 'at_start'> = {
+ *   belief: new DiscreteBelief({ at_goal: 0.1, at_start: 0.9 }),
+ *   transitionModel: myTransitions,
+ *   observationModel: myObservations,
+ *   preferences: { see_goal: 0, see_wall: -2 },
+ *   planningHorizon: 3,
+ *   precision: 4
+ * };
+ * ```
+ */
+export interface AgentConfig<A extends string = string, O extends string = string, S extends string = string> {
+    /**
+     * Initial belief distribution over hidden states.
+     *
+     * This is the agent's prior - what it believes about the world
+     * before receiving any observations. Can be uncertain (spread
+     * across states) or confident (concentrated on one state).
+     */
+    belief: Belief<S>;
+    /**
+     * State transition model defining P(s'|s, a).
+     *
+     * Encodes how the agent believes actions affect world state.
+     * Used during planning to simulate future states.
+     */
+    transitionModel: ITransitionModel<A, S>;
+    /**
+     * Observation model defining P(o|s).
+     *
+     * Encodes how hidden states generate observations.
+     * Used for Bayesian belief updates and computing ambiguity.
+     */
+    observationModel: IObservationModel<O, S>;
+    /**
+     * Preferred observations expressed as log probabilities.
+     *
+     * Higher values = more preferred. Typically:
+     * - 0 for neutral/desired observations
+     * - Negative for undesired observations (e.g., -5 for pain)
+     *
+     * These preferences define the agent's "goals" - what observations
+     * it will act to make more likely.
+     */
+    preferences: Preferences<O>;
+    /**
+     * Random seed for reproducible behavior.
+     *
+     * When set, the agent's stochastic action selection will be
+     * deterministic given the same sequence of observations.
+     * Useful for testing and debugging.
+     */
+    seed?: number;
+    /**
+     * Planning horizon - number of time steps to look ahead.
+     *
+     * - 1 = greedy/reactive (only considers immediate outcomes)
+     * - 2+ = planning (considers future consequences)
+     *
+     * Higher values enable better long-term decisions but increase
+     * computation exponentially (actions^horizon policies to evaluate).
+     *
+     * @default 1
+     */
+    planningHorizon?: number;
+    /**
+     * Precision parameter (β) for action selection.
+     *
+     * Controls the "temperature" of the softmax over Expected Free Energy:
+     * - β = 0: Uniform random action selection
+     * - β → ∞: Deterministic selection of best action
+     * - β = 1: Standard softmax (balanced exploration/exploitation)
+     *
+     * @default 1
+     */
+    precision?: number;
+    /**
+     * Habitual action preferences (E matrix in Active Inference).
+     *
+     * Biases action selection independently of Expected Free Energy.
+     * Higher values make actions more likely to be selected regardless
+     * of their predicted outcomes.
+     *
+     * Useful for modeling:
+     * - Learned motor habits
+     * - Default behaviors
+     * - Action priors from experience
+     */
+    habits?: Partial<Habits<A>>;
+}
+/**
+ * Factory function to create an Active Inference agent.
+ *
+ * This is the recommended way to instantiate agents, as it provides
+ * a clean interface with sensible defaults for optional parameters.
+ *
+ * ## Type Inference
+ *
+ * TypeScript will automatically infer the type parameters from your
+ * configuration objects, providing full type safety for actions,
+ * observations, and states throughout your code.
+ *
+ * @typeParam A - Union type of possible action names (inferred from transitionModel)
+ * @typeParam O - Union type of possible observation names (inferred from observationModel)
+ * @typeParam S - Union type of possible state names (inferred from belief)
+ *
+ * @param config - Agent configuration object
+ * @returns Configured Active Inference agent ready for use
+ *
+ * @example
+ * ```typescript
+ * // Create a simple agent
+ * const agent = createAgent({
+ *   belief: new DiscreteBelief({ safe: 0.5, danger: 0.5 }),
+ *   transitionModel: new DiscreteTransition({
+ *     stay: { safe: { safe: 1, danger: 0 }, danger: { safe: 0, danger: 1 } },
+ *     flee: { safe: { safe: 0.9, danger: 0.1 }, danger: { safe: 0.7, danger: 0.3 } }
+ *   }),
+ *   observationModel: new DiscreteObservation({
+ *     calm: { safe: 0.9, danger: 0.1 },
+ *     alarm: { safe: 0.1, danger: 0.9 }
+ *   }),
+ *   preferences: { calm: 0, alarm: -5 },
+ *   planningHorizon: 2,
+ *   precision: 4,
+ *   seed: 42  // For reproducibility
+ * });
+ *
+ * // Use the agent
+ * const action = agent.step('alarm');  // Types are inferred!
+ * // action is typed as 'stay' | 'flee'
+ * ```
+ *
+ * @see {@link Agent} - The agent class this creates
+ * @see {@link AgentConfig} - Configuration interface
+ */
+export declare function createAgent<A extends string = string, O extends string = string, S extends string = string>(config: AgentConfig<A, O, S>): Agent<A, O, S>;

package/dist/factory.js

@@ -0,0 +1,52 @@
+import { Agent } from './models/agent.model';
+import { Random } from './helpers/math.helpers';
+/**
+ * Factory function to create an Active Inference agent.
+ *
+ * This is the recommended way to instantiate agents, as it provides
+ * a clean interface with sensible defaults for optional parameters.
+ *
+ * ## Type Inference
+ *
+ * TypeScript will automatically infer the type parameters from your
+ * configuration objects, providing full type safety for actions,
+ * observations, and states throughout your code.
+ *
+ * @typeParam A - Union type of possible action names (inferred from transitionModel)
+ * @typeParam O - Union type of possible observation names (inferred from observationModel)
+ * @typeParam S - Union type of possible state names (inferred from belief)
+ *
+ * @param config - Agent configuration object
+ * @returns Configured Active Inference agent ready for use
+ *
+ * @example
+ * ```typescript
+ * // Create a simple agent
+ * const agent = createAgent({
+ *   belief: new DiscreteBelief({ safe: 0.5, danger: 0.5 }),
+ *   transitionModel: new DiscreteTransition({
+ *     stay: { safe: { safe: 1, danger: 0 }, danger: { safe: 0, danger: 1 } },
+ *     flee: { safe: { safe: 0.9, danger: 0.1 }, danger: { safe: 0.7, danger: 0.3 } }
+ *   }),
+ *   observationModel: new DiscreteObservation({
+ *     calm: { safe: 0.9, danger: 0.1 },
+ *     alarm: { safe: 0.1, danger: 0.9 }
+ *   }),
+ *   preferences: { calm: 0, alarm: -5 },
+ *   planningHorizon: 2,
+ *   precision: 4,
+ *   seed: 42  // For reproducibility
+ * });
+ *
+ * // Use the agent
+ * const action = agent.step('alarm');  // Types are inferred!
+ * // action is typed as 'stay' | 'flee'
+ * ```
+ *
+ * @see {@link Agent} - The agent class this creates
+ * @see {@link AgentConfig} - Configuration interface
+ */
+export function createAgent(config) {
+    const random = config.seed !== undefined ? new Random(config.seed) : new Random();
+    return new Agent(config.belief, config.transitionModel, config.observationModel, config.preferences, random, config.planningHorizon ?? 1, config.precision ?? 1, config.habits ?? {});
+}

package/dist/helpers/math.helpers.d.ts

@@ -0,0 +1,143 @@
+/**
+ * Seeded pseudo-random number generator using the Mulberry32 algorithm.
+ *
+ * Provides reproducible random sequences when initialized with the same seed.
+ * This is essential for testing and debugging Active Inference agents,
+ * as it allows deterministic replay of stochastic action selection.
+ *
+ * Mulberry32 is a fast, high-quality 32-bit PRNG with a period of 2^32.
+ *
+ * @example
+ * ```typescript
+ * const rng = new Random(42);
+ * console.log(rng.next()); // 0.8817... (always same for seed 42)
+ * console.log(rng.next()); // 0.3951...
+ *
+ * // Reset to get same sequence again
+ * rng.reset(42);
+ * console.log(rng.next()); // 0.8817... (same as before)
+ * ```
+ */
+export declare class Random {
+    private state;
+    /**
+     * Create a new random number generator.
+     *
+     * @param seed - Initial seed value. Defaults to current timestamp
+     *               for non-reproducible behavior.
+     */
+    constructor(seed?: number);
+    /**
+     * Generate the next random number in [0, 1).
+     *
+     * Works like Math.random() but with deterministic sequence
+     * based on the seed.
+     *
+     * @returns Random number between 0 (inclusive) and 1 (exclusive)
+     */
+    next(): number;
+    /**
+     * Generate a random number from standard normal distribution N(0, 1).
+     *
+     * Uses the Box-Muller transform to convert uniform random numbers
+     * into normally distributed values.
+     *
+     * @returns Random number from standard normal distribution
+     *
+     * @example
+     * ```typescript
+     * const rng = new Random(42);
+     * const samples = Array.from({ length: 1000 }, () => rng.gaussian());
+     * // samples will have mean ≈ 0 and std ≈ 1
+     * ```
+     */
+    gaussian(): number;
+    /**
+     * Reset the generator to a new seed.
+     *
+     * Useful for replaying random sequences from a known state.
+     *
+     * @param seed - New seed value
+     */
+    reset(seed: number): void;
+}
+/**
+ * Linear algebra utilities for Active Inference computations.
+ *
+ * Provides common operations needed for probability manipulation,
+ * including softmax/softmin for converting values to probabilities.
+ */
+export declare class LinearAlgebra {
+    /**
+     * Softmin function - converts values to probabilities inversely.
+     *
+     * Lower values get higher probabilities. Used in Active Inference
+     * to convert Expected Free Energy (where lower is better) into
+     * action probabilities.
+     *
+     * Formula: P(i) = exp(-β × x_i) / Σ exp(-β × x_j)
+     *
+     * @param arr - Array of values to convert
+     * @param beta - Precision/temperature parameter (default: 1).
+     *               Higher β = more deterministic (concentrates on minimum).
+     *               β = 0 gives uniform distribution.
+     * @returns Normalized probability distribution
+     *
+     * @example
+     * ```typescript
+     * const efe = [2.5, 1.0, 3.0];  // Policy EFEs (lower is better)
+     * const probs = LinearAlgebra.softmin(efe, 4);
+     * // probs ≈ [0.05, 0.93, 0.02] - strongly prefers policy with EFE=1.0
+     * ```
+     */
+    static softmin(arr: Array<number>, beta?: number): Array<number>;
+    /**
+     * Softmax function - converts values to probabilities.
+     *
+     * Higher values get higher probabilities. Standard operation for
+     * converting logits or preferences into a probability distribution.
+     *
+     * Formula: P(i) = exp(β × x_i) / Σ exp(β × x_j)
+     *
+     * Uses numerical stability trick of subtracting max before exp.
+     *
+     * @param arr - Array of values to convert
+     * @param beta - Precision/temperature parameter (default: 1).
+     *               Higher β = more deterministic (concentrates on maximum).
+     *               β = 0 gives uniform distribution.
+     * @returns Normalized probability distribution
+     *
+     * @example
+     * ```typescript
+     * const logits = [1.0, 2.0, 0.5];
+     * const probs = LinearAlgebra.softmax(logits);
+     * // probs ≈ [0.24, 0.67, 0.09]
+     * ```
+     */
+    static softmax(arr: Array<number>, beta?: number): Array<number>;
+    /**
+     * Normalize an array to sum to 1.
+     *
+     * @param arr - Array of non-negative values
+     * @returns Normalized array summing to 1
+     *
+     * @example
+     * ```typescript
+     * LinearAlgebra.normalize([2, 3, 5]); // [0.2, 0.3, 0.5]
+     * ```
+     */
+    static normalize(arr: number[]): number[];
+    /**
+     * Compute dot product of two arrays.
+     *
+     * @param a - First array
+     * @param b - Second array (must be same length as a)
+     * @returns Sum of element-wise products
+     *
+     * @example
+     * ```typescript
+     * LinearAlgebra.dotProduct([1, 2, 3], [4, 5, 6]); // 32
+     * ```
+     */
+    static dotProduct(a: number[], b: number[]): number;
+}