@uor-foundation/operators/dist/addition.d.ts

Layer 3: Arithmetic operators - operations as chemical reactions between numbers

import { type FieldSubstrate, type FieldPattern } from '@uor-foundation/field-substrate';
import type { ResonanceDynamics } from '@uor-foundation/resonance';
import type { PageTopology } from '@uor-foundation/topology';
/**
 * Addition as field merger - creates field superposition
 * The fields don't simply combine - they interfere and transform
 */
export declare class AdditionOperator {
    private substrate;
    private resonance;
    private topology;
    constructor(substrate: FieldSubstrate, resonance: ResonanceDynamics, topology: PageTopology);
    /**
     * Add two numbers - field merger with interference
     */
    add(a: bigint, b: bigint): ArithmeticResult;
    /**
     * Analyze how fields merge during addition
     */
    private analyzeFieldMerger;
    /**
     * Perform modular addition
     */
    addModulo(a: bigint, b: bigint, modulus: bigint): ModularArithmeticResult;
    /**
     * Chain multiple additions and track field evolution
     */
    addChain(numbers: bigint[]): ChainedOperationResult;
    /**
     * Count total field transitions in a chain
     */
    private countTransitions;
}
/**
 * Result of an arithmetic operation
 */
export interface ArithmeticResult {
    operation: string;
    operands: bigint[];
    result: bigint;
    fieldAnalysis: {
        operandPatterns: FieldPattern[];
        resultPattern: FieldPattern;
        fieldTransitions: FieldTransition[];
    };
    resonanceAnalysis: {
        operandResonances: number[];
        resultResonance: number;
        energyRedistribution: number;
    };
    topologicalAnalysis: {
        operandPages: number[];
        resultPage: number;
        crossedBoundary: boolean;
    };
}
/**
 * Field transition during operation
 */
export interface FieldTransition {
    field: number;
    beforeA: boolean;
    beforeB: boolean;
    after: boolean;
    type: 'preserved' | 'created' | 'destroyed' | 'transformed';
}
/**
 * Result of modular arithmetic
 */
export interface ModularArithmeticResult extends ArithmeticResult {
    modulus: bigint;
    modularResult: bigint;
    modularFieldPattern: FieldPattern;
    modularResonance: number;
    reductionOccurred: boolean;
}
/**
 * Result of chained operations
 */
export interface ChainedOperationResult {
    operation: string;
    operands: bigint[];
    finalResult: bigint;
    steps: ArithmeticResult[];
    fieldEvolution: {
        initial: FieldPattern;
        final: FieldPattern;
        totalTransitions: number;
    };
}
//# sourceMappingURL=addition.d.ts.map