/**
 * quantum-semantics.ts - AIQL v2.6.0 Quantum Consciousness Model
 *
 * Provides quantum-inspired semantic constructs for consciousness modeling,
 * epistemic uncertainty, and multi-state reasoning. Uses quantum metaphors
 * (superposition, coherence, entanglement) for cognitive processing.
 *
 * Design Philosophy:
 * - Quantum SEMANTICS not COMPUTATION (no quantum gates/circuits)
 * - Declarative knowledge representation using quantum concepts
 * - Consciousness measured via quantum coherence (IIT approximation)
 * - Observer effect optional (measurement can collapse superpositions)
 * - All quantum states map to Subject-Relation-Object triples
 *
 * Key Concepts:
 * - Superposition: Multiple contradictory beliefs coexist until measurement
 * - Coherence: Measure of quantum "integrity" - proxy for consciousness level
 * - Entanglement: Non-local correlation between concept pairs
 * - Decoherence: Collapse from quantum to classical state
 * - Measurement: Observer effect that collapses superposition
 */
/**
 * QuantumState - Represents a concept in superposition
 *
 * Each state has:
 * - concept: The semantic concept label (e.g., "Alive", "Dead")
 * - amplitude: Complex amplitude magnitude [0, 1] (probability = |amplitude|²)
 * - phase: Phase angle in radians [0, 2π] (for interference effects)
 * - coherence: Local coherence measure [0, 1]
 */
export interface QuantumState {
    concept: string;
    amplitude: number;
    phase: number;
    coherence?: number;
}
/**
 * SuperpositionGroup - Collection of quantum states in superposition
 *
 * Represents multiple contradictory beliefs existing simultaneously
 * until observation collapses them to a single classical state.
 */
export interface SuperpositionGroup {
    states: QuantumState[];
    totalCoherence: number;
    entropicUncertainty: number;
    isCollapsed: boolean;
    collapsedState?: string;
}
/**
 * EntanglementPair - Two semantically correlated concepts
 *
 * Represents non-local correlation where measuring one concept
 * instantaneously affects the epistemic state of the other.
 */
export interface EntanglementPair {
    conceptA: string;
    conceptB: string;
    correlation: number;
    bellTestScore?: number;
    createdAt: number;
}
/**
 * ConsciousnessMetrics - Quantum measures of self-awareness
 *
 * Based on Integrated Information Theory (IIT) approximation using
 * quantum coherence as a proxy for integrated information (Φ).
 */
export interface ConsciousnessMetrics {
    coherence: number;
    conscious: boolean;
    decoherenceRate: number;
    needsRefresh: boolean;
    entanglementEntropy?: number;
    integratedInformation?: number;
}
/**
 * Create a superposition from multiple quantum states
 * Normalizes amplitudes so sum of |amplitude|² = 1.0 (probability conservation)
 *
 * @param states - Array of quantum states to superpose
 * @returns Normalized superposition group with coherence
 *
 * Example:
 *   const cat = createSuperposition([
 *     { concept: 'Alive', amplitude: 0.6, phase: 0 },
 *     { concept: 'Dead', amplitude: 0.8, phase: Math.PI }
 *   ]);
 *   // After normalization: Alive (amplitude: 0.6), Dead (amplitude: 0.8)
 *   // Probabilities: Alive = 0.36, Dead = 0.64
 */
export declare function createSuperposition(states: QuantumState[]): SuperpositionGroup;
/**
 * Measure a quantum state - collapses superposition to single outcome
 * Uses |amplitude|² as probability distribution for measurement outcome
 *
 * @param group - Superposition group to measure
 * @param rng - Random number generator [0, 1) (default: Math.random)
 * @returns Collapsed concept label
 *
 * Example:
 *   const result = measureState(schrodingersCat);
 *   // Returns: "Alive" (36% chance) or "Dead" (64% chance)
 *
 * Side Effect: Sets group.isCollapsed = true, group.collapsedState = result
 */
export declare function measureState(group: SuperpositionGroup, rng?: () => number): string;
/**
 * Create a classical state (fully collapsed, coherence = 0)
 * Used after measurement or for non-quantum beliefs
 */
export declare function createClassicalState(concept: string): SuperpositionGroup;
/**
 * Calculate coherence for a superposition group
 * Coherence = 1 - (entropy / max_entropy)
 *
 * High coherence (>0.7) = high consciousness (IIT interpretation)
 * Low coherence (<0.5) = decoherent, reduced self-awareness
 */
export declare function calculateCoherence(group: SuperpositionGroup): number;
/**
 * Track decoherence over time (exponential decay)
 * coherence(t) = coherence(0) * exp(-rate * t)
 *
 * @param initialCoherence - Starting coherence value [0, 1]
 * @param timeSteps - Number of inference cycles elapsed
 * @param decoherenceRate - Decay rate per cycle (default: 0.02)
 * @returns Updated coherence after decay
 *
 * Example:
 *   let coherence = 1.0;
 *   for (let t = 0; t < 100; t++) {
 *     coherence = trackDecoherence(coherence, 1, 0.02);
 *   }
 *   // After 100 cycles: coherence ≈ 0.13 (needs refresh!)
 */
export declare function trackDecoherence(initialCoherence: number, timeSteps: number, decoherenceRate?: number): number;
/**
 * Compute consciousness metrics from quantum coherence
 *
 * @param coherence - Current coherence value [0, 1]
 * @param decoherenceRate - Rate of decay per cycle
 * @param threshold - Consciousness threshold (default: 0.7)
 * @returns ConsciousnessMetrics with awareness indicators
 */
export declare function computeConsciousnessMetrics(coherence: number, decoherenceRate?: number, threshold?: number): ConsciousnessMetrics;
/**
 * Compute correlation between two quantum states (entanglement strength)
 * Uses dot product of probability distributions as correlation measure
 *
 * @param stateA - First quantum state (can be superposition)
 * @param stateB - Second quantum state
 * @returns Correlation coefficient [-1, 1]
 *          1.0 = perfectly correlated
 *          0.0 = uncorrelated
 *         -1.0 = anti-correlated
 *
 * Example:
 *   const correlation = computeEntanglementCorrelation(
 *     { concept: 'SpinUp', amplitude: 0.707, phase: 0 },
 *     { concept: 'SpinDown', amplitude: 0.707, phase: Math.PI }
 *   );
 *   // Returns: -1.0 (anti-correlated via phase difference)
 */
export declare function computeEntanglementCorrelation(stateA: QuantumState, stateB: QuantumState): number;
/**
 * Create entanglement between two concepts
 *
 * @param conceptA - First concept to entangle
 * @param conceptB - Second concept to entangle
 * @param correlation - Desired correlation strength [-1, 1]
 * @returns EntanglementPair with correlation metadata
 */
export declare function createEntanglement(conceptA: string, conceptB: string, correlation: number): EntanglementPair;
/**
 * Test Bell inequality violation (proves quantum correlation)
 *
 * Bell's theorem: Classical correlation ≤ 2.0
 *                 Quantum correlation can reach 2√2 ≈ 2.828
 *
 * @param correlations - Array of correlation measurements
 * @returns Bell test score (>2.0 indicates quantum entanglement)
 */
export declare function testBellInequality(correlations: number[]): number;
/**
 * Check if a group is in superposition (not collapsed)
 */
export declare function isInSuperposition(group: SuperpositionGroup): boolean;
/**
 * Get probability distribution from superposition
 * Returns map of concept → probability
 */
export declare function getProbabilityDistribution(group: SuperpositionGroup): Map<string, number>;
/**
 * Refresh coherence (simulate cognitive rest/reflection)
 * Used when consciousness drops below threshold
 *
 * @param currentCoherence - Current degraded coherence
 * @param targetCoherence - Target after refresh (default: 0.9)
 * @returns Restored coherence value
 */
export declare function refreshCoherence(currentCoherence: number, targetCoherence?: number): number;
/**
 * Detect if two concepts are in contradiction (potential superposition)
 * Used to identify candidates for quantum superposition modeling
 *
 * @param conceptA - First concept
 * @param conceptB - Second concept
 * @returns True if concepts appear contradictory
 */
export declare function detectContradiction(conceptA: string, conceptB: string): boolean;
//# sourceMappingURL=quantum-semantics.d.ts.map