@uor-foundation/operators/dist/multiplication.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';
import { type DenormalizationArtifact } from './carry';
import type { ArithmeticResult, ModularArithmeticResult, ChainedOperationResult } from './addition';
/**
 * Multiplication as field entanglement - creates complex field interference
 * Fields can vanish or emerge during multiplication
 */
export declare class MultiplicationOperator {
    private substrate;
    private resonance;
    private topology;
    private carryOperator;
    private denormalization;
    constructor(substrate: FieldSubstrate, resonance: ResonanceDynamics, topology: PageTopology);
    /**
     * Multiply two numbers - field entanglement with interference
     */
    multiply(a: bigint, b: bigint): MultiplicationResult;
    /**
     * Analyze field entanglement during multiplication
     */
    private analyzeFieldEntanglement;
    /**
     * Perform modular multiplication
     */
    multiplyModulo(a: bigint, b: bigint, modulus: bigint): ModularMultiplicationResult;
    /**
     * Compute power using repeated multiplication
     */
    power(base: bigint, exponent: bigint): PowerResult;
    /**
     * Factorize a number - molecular decomposition to primes
     */
    factorize(n: bigint): FactorizationResult;
    /**
     * Analyze how fields are reconstructed during factorization
     */
    private analyzeFieldReconstruction;
    /**
     * Chain multiple multiplications and track field evolution
     */
    multiplyChain(numbers: bigint[]): ChainedMultiplicationResult;
    /**
     * Count complex field transitions in a multiplication chain
     */
    private countComplexTransitions;
}
/**
 * Extended arithmetic result for multiplication
 */
export interface MultiplicationResult extends ArithmeticResult {
    carryOperator: FieldPattern;
    artifacts: DenormalizationArtifact[];
    entanglementComplexity: number;
}
/**
 * Field entanglement transition
 */
export interface FieldEntanglementTransition {
    field: number;
    beforeA: boolean;
    beforeB: boolean;
    after: boolean;
    type: 'simple' | 'vanishing' | 'emergent' | 'interference';
    carry: boolean;
}
/**
 * Entanglement analysis result
 */
export interface EntanglementAnalysis {
    transitions: FieldEntanglementTransition[];
    complexity: number;
}
/**
 * Modular multiplication result
 */
export interface ModularMultiplicationResult extends MultiplicationResult, ModularArithmeticResult {
}
/**
 * Power operation result
 */
export interface PowerResult {
    operation: string;
    base: bigint;
    exponent: bigint;
    result: bigint;
    steps: MultiplicationResult[];
    fieldCascade: FieldPattern[];
}
/**
 * Factorization result
 */
export interface FactorizationResult {
    operation: string;
    number: bigint;
    factors: bigint[];
    isPrime: boolean;
    decompositionSteps: DecompositionStep[];
    fieldEvolution?: {
        initial: FieldPattern;
        initialResonance: number;
        finalFactorPatterns: FieldPattern[];
    };
}
/**
 * Decomposition step during factorization
 */
export interface DecompositionStep {
    divisor: bigint;
    quotient: bigint;
    remainderBefore: bigint;
    fieldReconstruction: FieldReconstruction;
}
/**
 * Field reconstruction analysis
 */
export interface FieldReconstruction {
    originalFields: FieldPattern;
    divisorFields: FieldPattern;
    quotientFields: FieldPattern;
    reconstructedArtifacts: DenormalizationArtifact[];
    fieldsRestored: number[];
    fieldsRemoved: number[];
}
/**
 * Chained multiplication result
 */
export interface ChainedMultiplicationResult extends ChainedOperationResult {
    totalArtifacts: number;
    totalComplexity: number;
}
//# sourceMappingURL=multiplication.d.ts.map