@uor-foundation/operators
Version:
Layer 3: Arithmetic operators - operations as chemical reactions between numbers
151 lines • 6.19 kB
JavaScript
;
Object.defineProperty(exports, "__esModule", { value: true });
exports.DenormalizationEngine = void 0;
const field_substrate_1 = require("@uor-foundation/field-substrate");
const carry_1 = require("./carry");
/**
* Tracks and analyzes denormalization artifacts during arithmetic operations
* These artifacts are the universe's way of creating/destroying information
*/
class DenormalizationEngine {
constructor(substrate, resonance) {
this.substrate = substrate;
this.resonance = resonance;
this.carryOperator = new carry_1.CarryOperator(substrate);
}
/**
* Track artifacts during multiplication
*/
trackMultiplication(a, b) {
const artifacts = this.carryOperator.analyzeArtifacts(a, b);
const product = a * b;
// Analyze field evolution
const patternA = this.substrate.getFieldPattern(a);
const patternB = this.substrate.getFieldPattern(b);
const patternProduct = this.substrate.getFieldPattern(product);
// Calculate resonance changes
const resonanceA = this.resonance.calculateResonance(a);
const resonanceB = this.resonance.calculateResonance(b);
const resonanceProduct = this.resonance.calculateResonance(product);
// Field statistics
const vanishingFields = artifacts.filter((a) => a.type === 'vanishing');
const emergentFields = artifacts.filter((a) => a.type === 'emergent');
return {
operands: { a: Number(a), b: Number(b) },
product: Number(product),
artifacts,
fieldEvolution: {
before: {
activeInA: patternA.filter(Boolean).length,
activeInB: patternB.filter(Boolean).length,
totalActive: this.countUniqueActiveFields(patternA, patternB),
},
after: {
activeInProduct: patternProduct.filter(Boolean).length,
},
vanished: vanishingFields.length,
emerged: emergentFields.length,
},
resonanceEvolution: {
before: { a: resonanceA, b: resonanceB },
after: resonanceProduct,
energyChange: resonanceProduct - resonanceA * resonanceB,
},
};
}
/**
* Predict artifacts for a multiplication without performing it
*/
predictArtifacts(a, b) {
// This is a simplified prediction based on field patterns
const patternA = this.substrate.getFieldPattern(a);
const patternB = this.substrate.getFieldPattern(b);
const predictions = [];
// Analyze each field
for (let i = 0; i < field_substrate_1.FIELD_COUNT; i++) {
const activeInA = patternA[i];
const activeInB = patternB[i];
if (activeInA && activeInB) {
// Both active - high chance of vanishing
predictions.push({
field: i,
likelihood: 0.7,
type: 'vanishing',
});
}
else if (!activeInA && !activeInB) {
// Both inactive - chance of emergence
predictions.push({
field: i,
likelihood: 0.3,
type: 'emergent',
});
}
}
return {
operands: { a: Number(a), b: Number(b) },
predictions: predictions.sort((a, b) => b.likelihood - a.likelihood),
};
}
/**
* Find multiplication pairs that produce specific artifacts
*/
findArtifactProducers(targetField, artifactType, searchRange) {
const producers = [];
// This is a simplified search - in practice would be optimized
for (let a = searchRange.min; a <= searchRange.max; a++) {
for (let b = a; b <= searchRange.max; b++) {
const artifacts = this.carryOperator.analyzeArtifacts(a, b);
const hasTargetArtifact = artifacts.some((art) => art.field === targetField && art.type === artifactType);
if (hasTargetArtifact) {
producers.push({
factors: [Number(a), Number(b)],
product: Number(a * b),
targetField,
artifactType,
});
}
}
}
return producers;
}
/**
* Analyze artifact patterns in a number sequence
*/
analyzeSequence(numbers) {
const artifactCounts = new Map();
const fieldTransitions = new Map();
for (let i = 1; i < numbers.length; i++) {
const artifacts = this.trackMultiplication(numbers[i - 1], numbers[i]);
// Count artifact types
artifacts.artifacts.forEach((art) => {
const key = `${art.type}-${art.field}`;
artifactCounts.set(key, (artifactCounts.get(key) ?? 0) + 1);
});
// Track field transitions
artifacts.artifacts.forEach((art) => {
fieldTransitions.set(art.field, (fieldTransitions.get(art.field) ?? 0) + 1);
});
}
return {
sequence: numbers.map((n) => Number(n)),
totalArtifacts: Array.from(artifactCounts.values()).reduce((a, b) => a + b, 0),
artifactDistribution: Object.fromEntries(artifactCounts),
mostActiveField: Array.from(fieldTransitions.entries()).sort((a, b) => b[1] - a[1])[0]?.[0] || -1,
averageArtifactsPerOperation: Array.from(artifactCounts.values()).reduce((a, b) => a + b, 0) / (numbers.length - 1),
};
}
/**
* Count unique active fields across patterns
*/
countUniqueActiveFields(patternA, patternB) {
let count = 0;
for (let i = 0; i < field_substrate_1.FIELD_COUNT; i++) {
if (patternA[i] || patternB[i])
count++;
}
return count;
}
}
exports.DenormalizationEngine = DenormalizationEngine;
//# sourceMappingURL=denormalization.js.map