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

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

import type { FieldSubstrate } from '@uor-foundation/field-substrate';
import type { ResonanceDynamics } from '@uor-foundation/resonance';
import type { PageTopology } from '@uor-foundation/topology';
import { AdditionOperator } from './addition';
import { MultiplicationOperator, type FactorizationResult } from './multiplication';
import { DenormalizationEngine } from './denormalization';
export * from './carry';
export * from './denormalization';
export * from './addition';
export * from './multiplication';
/**
 * Main arithmetic operators interface - operations as chemical reactions
 * This implements Layer 3 of the Mathematical Universe
 */
export declare class ArithmeticOperators {
    private substrate;
    private resonance;
    private topology;
    private addition;
    private multiplication;
    private denormalization;
    constructor(substrate: FieldSubstrate, resonance: ResonanceDynamics, topology: PageTopology);
    /**
     * Addition as field merger
     */
    add(a: bigint, b: bigint): ReturnType<AdditionOperator['add']>;
    /**
     * Addition with modular reduction
     */
    addModulo(a: bigint, b: bigint, modulus: bigint): ReturnType<AdditionOperator['addModulo']>;
    /**
     * Chain addition operations
     */
    addChain(numbers: bigint[]): ReturnType<AdditionOperator['addChain']>;
    /**
     * Multiplication as field entanglement
     */
    multiply(a: bigint, b: bigint): ReturnType<MultiplicationOperator['multiply']>;
    /**
     * Multiplication with modular reduction
     */
    multiplyModulo(a: bigint, b: bigint, modulus: bigint): ReturnType<MultiplicationOperator['multiplyModulo']>;
    /**
     * Chain multiplication operations
     */
    multiplyChain(numbers: bigint[]): ReturnType<MultiplicationOperator['multiplyChain']>;
    /**
     * Exponentiation through recursive compilation
     */
    power(base: bigint, exponent: bigint): ReturnType<MultiplicationOperator['power']>;
    /**
     * Factorization as molecular decomposition
     */
    factorize(n: bigint): FactorizationResult;
    /**
     * Subtraction (addition with negation)
     */
    subtract(a: bigint, b: bigint): ReturnType<AdditionOperator['add']>;
    /**
     * Division as inverse compilation
     */
    divide(a: bigint, b: bigint): DivisionResult;
    /**
     * Modulo operation
     */
    modulo(a: bigint, b: bigint): bigint;
    /**
     * Greatest Common Divisor - finding common field sources
     */
    gcd(a: bigint, b: bigint): GCDResult;
    /**
     * Least Common Multiple - finding first resonance harmony
     */
    lcm(a: bigint, b: bigint): LCMResult;
    /**
     * Track denormalization artifacts
     */
    trackArtifacts(a: bigint, b: bigint): ReturnType<DenormalizationEngine['trackMultiplication']>;
    /**
     * Predict artifacts without computing
     */
    predictArtifacts(a: bigint, b: bigint): ReturnType<DenormalizationEngine['predictArtifacts']>;
    /**
     * Find common field sources for GCD
     */
    private findCommonFieldSources;
}
/**
 * Result of division operation
 */
export interface DivisionResult {
    operation: string;
    dividend: bigint;
    divisor: bigint;
    quotient: bigint;
    remainder: bigint;
    exact: boolean;
    decompilationArtifacts: DenormalizationArtifact[];
    fieldReconstruction: {
        quotientPattern: FieldPattern;
        remainderPattern: FieldPattern;
        reconstructsOriginal: boolean;
    };
}
/**
 * GCD computation result
 */
export interface GCDResult {
    a: bigint;
    b: bigint;
    gcd: bigint;
    steps: GCDStep[];
    commonFieldSources: number[];
}
/**
 * Step in GCD algorithm
 */
export interface GCDStep {
    x: bigint;
    y: bigint;
    quotient: bigint;
    remainder: bigint;
    xPattern: FieldPattern;
    yPattern: FieldPattern;
}
/**
 * LCM computation result
 */
export interface LCMResult {
    a: bigint;
    b: bigint;
    lcm: bigint;
    gcdUsed: bigint;
    resonanceHarmony: number;
}
export type { FieldPattern } from '@uor-foundation/field-substrate';
export type { DenormalizationArtifact } from './carry';
import type { FieldPattern } from '@uor-foundation/field-substrate';
import type { DenormalizationArtifact } from './carry';
/**
 * Create arithmetic operators instance
 * @param substrate - Field substrate interface
 * @param resonance - Resonance dynamics interface
 * @param topology - Page topology interface
 * @returns Arithmetic operators implementation
 */
export declare function createArithmeticOperators(substrate: FieldSubstrate, resonance: ResonanceDynamics, topology: PageTopology): ArithmeticOperators;
//# sourceMappingURL=index.d.ts.map