@uor-foundation/operators
Version:
Layer 3: Arithmetic operators - operations as chemical reactions between numbers
272 lines • 10.4 kB
JavaScript
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.MultiplicationOperator = void 0;
const field_substrate_1 = require("@uor-foundation/field-substrate");
const carry_1 = require("./carry");
const denormalization_1 = require("./denormalization");
/**
* Multiplication as field entanglement - creates complex field interference
* Fields can vanish or emerge during multiplication
*/
class MultiplicationOperator {
constructor(substrate, resonance, topology) {
this.substrate = substrate;
this.resonance = resonance;
this.topology = topology;
this.carryOperator = new carry_1.CarryOperator(substrate);
this.denormalization = new denormalization_1.DenormalizationEngine(substrate, resonance);
}
/**
* Multiply two numbers - field entanglement with interference
*/
multiply(a, b) {
const product = a * b;
// Get field patterns
const patternA = this.substrate.getFieldPattern(a);
const patternB = this.substrate.getFieldPattern(b);
const patternProduct = this.substrate.getFieldPattern(product);
// Calculate carry operator
const carryPattern = this.carryOperator.compute(a, b);
// Analyze denormalization artifacts
const artifacts = this.carryOperator.analyzeArtifacts(a, b);
// Calculate resonances
const resonanceA = this.resonance.calculateResonance(a);
const resonanceB = this.resonance.calculateResonance(b);
const resonanceProduct = this.resonance.calculateResonance(product);
// Get page information
const locationA = this.topology.locateNumber(a);
const locationB = this.topology.locateNumber(b);
const locationProduct = this.topology.locateNumber(product);
// Analyze field entanglement
const entanglement = this.analyzeFieldEntanglement(patternA, patternB, patternProduct, carryPattern);
return {
operation: 'multiplication',
operands: [a, b],
result: product,
fieldAnalysis: {
operandPatterns: [patternA, patternB],
resultPattern: patternProduct,
fieldTransitions: entanglement.transitions,
},
resonanceAnalysis: {
operandResonances: [resonanceA, resonanceB],
resultResonance: resonanceProduct,
energyRedistribution: resonanceProduct - resonanceA * resonanceB,
},
topologicalAnalysis: {
operandPages: [locationA.page, locationB.page],
resultPage: locationProduct.page,
crossedBoundary: locationA.page !== locationProduct.page || locationB.page !== locationProduct.page,
},
carryOperator: carryPattern,
artifacts,
entanglementComplexity: entanglement.complexity,
};
}
/**
* Analyze field entanglement during multiplication
*/
analyzeFieldEntanglement(patternA, patternB, patternProduct, carryPattern) {
const transitions = [];
let complexity = 0;
for (let i = 0; i < field_substrate_1.FIELD_COUNT; i++) {
const activeInA = patternA[i];
const activeInB = patternB[i];
const activeInProduct = patternProduct[i];
const hasCarry = carryPattern[i];
// Determine entanglement type
let entanglementType;
if (!hasCarry) {
entanglementType = 'simple';
}
else if ((activeInA || activeInB) && !activeInProduct) {
entanglementType = 'vanishing';
complexity += 2;
}
else if (!activeInA && !activeInB && activeInProduct) {
entanglementType = 'emergent';
complexity += 3;
}
else {
entanglementType = 'interference';
complexity += 1;
}
transitions.push({
field: i,
beforeA: activeInA,
beforeB: activeInB,
after: activeInProduct,
type: entanglementType,
carry: hasCarry,
});
}
return { transitions, complexity };
}
/**
* Perform modular multiplication
*/
multiplyModulo(a, b, modulus) {
const standardResult = this.multiply(a, b);
const modularProduct = (a * b) % modulus;
// Analyze the modular reduction
const patternModular = this.substrate.getFieldPattern(modularProduct);
const resonanceModular = this.resonance.calculateResonance(modularProduct);
return {
...standardResult,
modulus,
modularResult: modularProduct,
modularFieldPattern: patternModular,
modularResonance: resonanceModular,
reductionOccurred: standardResult.result !== modularProduct,
};
}
/**
* Compute power using repeated multiplication
*/
power(base, exponent) {
if (exponent < 0n) {
throw new Error('Negative exponents not supported');
}
if (exponent === 0n) {
return {
operation: 'power',
base,
exponent,
result: 1n,
steps: [],
fieldCascade: [],
};
}
const steps = [];
const fieldCascade = [this.substrate.getFieldPattern(base)];
let result = base;
let exp = exponent - 1n;
while (exp > 0n) {
const multiplicationResult = this.multiply(result, base);
steps.push(multiplicationResult);
result = multiplicationResult.result;
fieldCascade.push(multiplicationResult.fieldAnalysis.resultPattern);
exp--;
}
return {
operation: 'power',
base,
exponent,
result,
steps,
fieldCascade,
};
}
/**
* Factorize a number - molecular decomposition to primes
*/
factorize(n) {
if (n <= 1n) {
return {
operation: 'factorization',
number: n,
factors: [],
isPrime: false,
decompositionSteps: [],
};
}
const factors = [];
const decompositionSteps = [];
let remainder = n;
let divisor = 2n;
// Track initial state
const initialPattern = this.substrate.getFieldPattern(n);
const initialResonance = this.resonance.calculateResonance(n);
while (remainder > 1n && divisor * divisor <= remainder) {
if (remainder % divisor === 0n) {
factors.push(divisor);
// Track decomposition step
const quotient = remainder / divisor;
decompositionSteps.push({
divisor,
quotient,
remainderBefore: remainder,
fieldReconstruction: this.analyzeFieldReconstruction(remainder, divisor, quotient),
});
remainder = quotient;
}
else {
divisor++;
}
}
if (remainder > 1n) {
factors.push(remainder);
}
return {
operation: 'factorization',
number: n,
factors,
isPrime: factors.length === 1 && factors[0] === n,
decompositionSteps,
fieldEvolution: {
initial: initialPattern,
initialResonance,
finalFactorPatterns: factors.map((f) => this.substrate.getFieldPattern(f)),
},
};
}
/**
* Analyze how fields are reconstructed during factorization
*/
analyzeFieldReconstruction(original, divisor, quotient) {
// Verify the multiplication would recreate the original
const reconstructed = this.multiply(divisor, quotient);
const artifacts = reconstructed.artifacts;
return {
originalFields: this.substrate.getFieldPattern(original),
divisorFields: this.substrate.getFieldPattern(divisor),
quotientFields: this.substrate.getFieldPattern(quotient),
reconstructedArtifacts: artifacts,
fieldsRestored: artifacts.filter((a) => a.type === 'vanishing').map((a) => a.field),
fieldsRemoved: artifacts.filter((a) => a.type === 'emergent').map((a) => a.field),
};
}
/**
* Chain multiple multiplications and track field evolution
*/
multiplyChain(numbers) {
if (numbers.length === 0) {
throw new Error('Cannot perform chain multiplication on empty array');
}
const steps = [];
let accumulator = numbers[0];
for (let i = 1; i < numbers.length; i++) {
const result = this.multiply(accumulator, numbers[i]);
steps.push(result);
accumulator = result.result;
}
// Analyze overall field evolution and artifact accumulation
const initialPattern = this.substrate.getFieldPattern(numbers[0]);
const finalPattern = this.substrate.getFieldPattern(accumulator);
const totalArtifacts = steps.reduce((sum, step) => sum + step.artifacts.length, 0);
return {
operation: 'multiplication-chain',
operands: numbers,
finalResult: accumulator,
steps,
fieldEvolution: {
initial: initialPattern,
final: finalPattern,
totalTransitions: this.countComplexTransitions(steps),
},
totalArtifacts,
totalComplexity: steps.reduce((sum, step) => sum + step.entanglementComplexity, 0),
};
}
/**
* Count complex field transitions in a multiplication chain
*/
countComplexTransitions(steps) {
return steps.reduce((total, step) => {
return (total +
step.fieldAnalysis.fieldTransitions.filter((t) => 'carry' in t && t.type !== 'simple').length);
}, 0);
}
}
exports.MultiplicationOperator = MultiplicationOperator;
//# sourceMappingURL=multiplication.js.map