/**
 * Nexus Prime — Quantum-Inspired Agent Entanglement Engine
 *
 * Replaces explicit IPC/Git-based coordination with a shared quantum-state
 * vector that enables "telepathic" correlated agent decisions.
 *
 * Agents share a state in a high-dimensional Hilbert space. When an agent
 * "measures" (executes an action), the shared state collapses, and entangled
 * agents automatically make correlated decisions without explicit messaging.
 *
 * Phase: 9A (Quantum-Inspired Agent Entanglement)
 */
import { type StateVector } from './hilbert-space.js';
export interface EntangledState {
    id: string;
    dimension: number;
    numAgents: number;
    amplitudes: StateVector;
    agentIds: string[];
    collapsed: Map<string, number>;
    created: number;
    lastMeasurement: number;
}
export interface MeasurementResult {
    agentId: string;
    strategyIndex: number;
    probability: number;
    correlations: Map<string, number[]>;
}
export interface CorrelationEntry {
    agentA: string;
    agentB: string;
    correlation: number;
}
export declare class EntanglementEngine {
    private states;
    /**
     * Create a new entangled state for N agents.
     *
     * Produces a GHZ-like maximally entangled state where all agents
     * are perfectly correlated — measuring one immediately constrains others.
     *
     * @param agentIds  Array of agent identifiers
     * @param strategyDim Number of possible strategies per agent (default: 4)
     * @returns The EntangledState ID
     */
    entangle(agentIds: string[], strategyDim?: number): EntangledState;
    /**
     * Agent "measures" — collapses its subspace, returns chosen strategy.
     *
     * Born rule sampling selects a strategy weighted by |amplitude|².
     * After measurement, the joint state is updated so entangled agents
     * make correlated decisions on their subsequent measurements.
     */
    measure(stateId: string, agentId: string): MeasurementResult;
    /**
     * Inject bias: push an agent toward a preferred strategy without collapsing.
     *
     * This is like "nudging" — the agent becomes more likely to choose
     * the preferred strategy, while still maintaining entanglement with others.
     */
    bias(stateId: string, agentId: string, strategyIdx: number, strength: number): void;
    /**
     * Get the correlation matrix between all agent pairs.
     * High correlation means agents tend to choose the same strategies.
     */
    getCorrelationMatrix(stateId: string): CorrelationEntry[];
    /**
     * Get all active entangled states.
     */
    getStates(): EntangledState[];
    /**
     * Destroy an entangled state after use.
     */
    destroy(stateId: string): void;
    /**
     * Compute marginal probabilities for a specific agent by tracing out
     * all other agents from the joint probability distribution.
     */
    private getMarginalProbabilities;
    /**
     * Collapse the joint state after measurement.
     * Projects onto the subspace where the measured agent has `outcome`.
     * Zeroes out all amplitudes where that agent has a different strategy.
     */
    private collapseOnMeasurement;
    /**
     * After one agent measures, compute the shifted probability distributions
     * for all other agents (showing how entanglement constrains them).
     */
    private getCorrelationsAfterMeasurement;
    /**
     * Pearson correlation between two agents' strategies in the joint distribution.
     * Returns value in [-1, 1].
     */
    private pairCorrelation;
}
export declare const entanglementEngine: EntanglementEngine;
