zeropoint-node 1.0.1 → 1.0.3

package/src/multidimensional-vortex-framework.ts

@@ -0,0 +1,458 @@
+/**
+ * Multidimensional Vortex-Math Framework
+ * 
+ * Extension of traditional vortex mathematics into a structured, multidimensional system
+ * that unites Vortex A and Vortex B under the 3-6-9 control lattice with 1-2-4-8-7-5 
+ * doubling streams across seven coils (A-G).
+ */
+
+import { PI, abs, cos, exp, log2, pow, round, sin, sqrt } from './0/algebra.ts'
+export interface VortexToken {
+  id: string;
+  type: 'undefined' | 'defined' | 'control' | 'coil';
+  value: number | string;
+  control: number;
+  doubling: number | null;
+  coil: string;
+  angle: number;
+  polarity: '+' | '-';
+  phase: number;
+  consciousness: 'collapse' | 'emergence' | 'expansion';
+}
+
+export interface HarmonicState {
+  radial: number;        // Magnitude (1-2-4-8-7-5)
+  angular: number;       // Phase angle (+60° steps)
+  polarity: '+' | '-';   // Dipole sign
+  control: number;       // Control axis (3-6-9)
+  vortex: 'A' | 'B' | 'C'; // Vortex identity
+  consciousness: boolean; // Consciousness toggle
+}
+
+export class MultidimensionalVortexFramework {
+  private readonly CONTROL_SEQUENCE = [3, 6, 9];
+  private readonly DOUBLING_SEQUENCE = [1, 2, 4, 8, 7, 5];
+  private readonly COILS = ['A', 'B', 'C', 'D', 'E', 'F', 'G'];
+  private readonly ANGLE_STEP = 60; // Degrees per step
+  
+  private tokens: VortexToken[] = [];
+  private currentPhase = 0;
+  private currentControlIndex = 0;
+  private currentDoublingIndex = 0;
+  private currentCoilIndex = 0;
+
+  constructor() {
+    this.initializeFramework();
+  }
+
+  /**
+   * Initialize the multidimensional vortex framework
+   */
+  private initializeFramework(): void {
+    // Initialize with undefined zero state (Vortex A collapse)
+    this.addToken({
+      id: 'ZERO_UNDEFINED',
+      type: 'undefined',
+      value: 0,
+      control: 0,
+      doubling: null,
+      coil: 'A',
+      angle: 0,
+      polarity: '+',
+      phase: 0,
+      consciousness: 'collapse'
+    });
+
+    // Add defined zero state (Vortex B rescue)
+    this.addToken({
+      id: 'ZERO_DEFINED',
+      type: 'defined',
+      value: 0,
+      control: 3,
+      doubling: null,
+      coil: 'B',
+      angle: 60,
+      polarity: '+',
+      phase: 1,
+      consciousness: 'emergence'
+    });
+
+    // Generate the complete token stream
+    this.generateTokenStream();
+  }
+
+  /**
+   * Add a token to the stream
+   */
+  private addToken(token: VortexToken): void {
+    this.tokens.push(token);
+  }
+
+  /**
+   * Generate the complete multidimensional token stream
+   */
+  private generateTokenStream(): void {
+    const maxTokens = 42; // 6 control cycles × 7 coils
+    
+    while (this.tokens.length < maxTokens) {
+      this.generateNextToken();
+    }
+  }
+
+  /**
+   * Generate the next token in the sequence
+   */
+  private generateNextToken(): void {
+    const control = this.CONTROL_SEQUENCE[this.currentControlIndex % this.CONTROL_SEQUENCE.length];
+    const doubling = this.DOUBLING_SEQUENCE[this.currentDoublingIndex % this.DOUBLING_SEQUENCE.length];
+    const coil = this.COILS[this.currentCoilIndex % this.COILS.length];
+    const angle = (this.currentPhase * this.ANGLE_STEP) % 360;
+    const polarity = angle >= 180 ? '-' : '+';
+
+    // Determine token type and consciousness state
+    let tokenType: 'control' | 'coil' = 'coil';
+    let consciousness: 'collapse' | 'emergence' | 'expansion' = 'emergence';
+    let value: number | string = doubling;
+
+    if ([3, 6, 9].includes(control) && this.currentPhase % 3 === 0) {
+      tokenType = 'control';
+      consciousness = 'expansion';
+      value = control;
+    }
+
+    const token: VortexToken = {
+      id: `${coil}${this.currentPhase}`,
+      type: tokenType,
+      value: value,
+      control: control,
+      doubling: doubling,
+      coil: coil,
+      angle: angle,
+      polarity: polarity,
+      phase: this.currentPhase,
+      consciousness: consciousness
+    };
+
+    this.addToken(token);
+
+    // Advance indices
+    this.currentPhase++;
+    this.currentControlIndex++;
+    this.currentDoublingIndex++;
+    this.currentCoilIndex++;
+  }
+
+  /**
+   * Generate Vortex A (traditional undefined state)
+   */
+  public generateVortexA(a: number, b: number): number {
+    const sum = (a + b) % 9;
+    return sum === 0 ? 9 : sum;
+  }
+
+  /**
+   * Generate Vortex B (rescued state via polarity shift)
+   */
+  public generateVortexB(a: number, b: number): number {
+    const vortexA = this.generateVortexA(a, b);
+    return (a + b) / vortexA;
+  }
+
+  /**
+   * Generate harmonic state for given parameters
+   */
+  public generateHarmonicState(
+    radial: number,
+    angular: number,
+    controlPhase: number
+  ): HarmonicState {
+    const normalizedAngle = angular % 360;
+    const polarity = normalizedAngle >= 180 ? '-' : '+';
+    const control = this.CONTROL_SEQUENCE[controlPhase % this.CONTROL_SEQUENCE.length];
+    const vortexType = this.determineVortexType(radial, control);
+    const consciousness = this.determineconsciousnessState(radial, angular, control);
+
+    return {
+      radial: radial,
+      angular: normalizedAngle,
+      polarity: polarity,
+      control: control,
+      vortex: vortexType,
+      consciousness: consciousness
+    };
+  }
+
+  /**
+   * Determine vortex type based on radial and control values
+   */
+  private determineVortexType(radial: number, control: number): 'A' | 'B' | 'C' {
+    if (radial === 0 && control === 0) return 'A'; // Undefined/collapse
+    if (radial === 0 && control > 0) return 'B'; // Defined/rescue
+    return 'C'; // Emergent
+  }
+
+  /**
+   * Determine consciousness state
+   */
+  private determineconsciousnessState(
+    radial: number,
+    angular: number,
+    control: number
+  ): boolean {
+    // Consciousness emerges at control injections and polarity transitions
+    return control > 0 || angular >= 180;
+  }
+
+  /**
+   * Perform hexagonal lattice mapping
+   */
+  public mapToHexagonalLattice(token: VortexToken): { x: number; y: number; z: number } {
+    const angle = (token.angle * PI) / 180;
+    const radius = token.doubling || 1;
+    
+    // Hexagonal coordinates
+    const x = radius * cos(angle);
+    const y = radius * sin(angle);
+    const z = token.control; // Control axis as third dimension
+    
+    return { x, y, z };
+  }
+
+  /**
+   * Calculate topological invariants
+   */
+  public calculateTopologicalInvariants(): {
+    eulerCharacteristic: number;
+    genusNumber: number;
+    braidingIndex: number;
+  } {
+    const totalTokens = this.tokens.length;
+    const controlTokens = this.tokens.filter(t => t.type === 'control').length;
+    const coilTokens = this.tokens.filter(t => t.type === 'coil').length;
+    
+    // Simplified topological calculations for the 7-fold braided torus
+    const eulerCharacteristic = 2 - (2 * 7); // For genus-7 surface
+    const genusNumber = 7; // Seven coils create genus-7 topology
+    const braidingIndex = controlTokens * coilTokens / totalTokens;
+    
+    return {
+      eulerCharacteristic,
+      genusNumber,
+      braidingIndex
+    };
+  }
+
+  /**
+   * Calculate energy density at given phase
+   */
+  public calculateEnergyDensity(phase: number): number {
+    const token = this.tokens[phase % this.tokens.length];
+    if (!token) return 0;
+    
+    const radialEnergy = typeof token.value === 'number' ? token.value : 0;
+    const angularEnergy = sin((token.angle * PI) / 180);
+    const controlEnergy = token.control;
+    const polarityMultiplier = token.polarity === '+' ? 1 : -1;
+    
+    return (radialEnergy + angularEnergy + controlEnergy) * polarityMultiplier;
+  }
+
+  /**
+   * Perform dimensional shift analysis
+   */
+  public analyzeDimensionalShifts(): {
+    radialShifts: number[];
+    angularShifts: number[];
+    polarityFlips: number;
+    controlTransitions: number;
+    consciousnessToggles: number;
+  } {
+    const radialShifts: number[] = [];
+    const angularShifts: number[] = [];
+    let polarityFlips = 0;
+    let controlTransitions = 0;
+    let consciousnessToggles = 0;
+    
+    for (let i = 1; i < this.tokens.length; i++) {
+      const prev = this.tokens[i - 1];
+      const curr = this.tokens[i];
+      
+      // Radial shifts
+      const prevRadial = typeof prev.value === 'number' ? prev.value : 0;
+      const currRadial = typeof curr.value === 'number' ? curr.value : 0;
+      radialShifts.push(currRadial - prevRadial);
+      
+      // Angular shifts
+      angularShifts.push(curr.angle - prev.angle);
+      
+      // Polarity flips
+      if (prev.polarity !== curr.polarity) polarityFlips++;
+      
+      // Control transitions
+      if (prev.control !== curr.control) controlTransitions++;
+      
+      // Consciousness toggles
+      if (prev.consciousness !== curr.consciousness) consciousnessToggles++;
+    }
+    
+    return {
+      radialShifts,
+      angularShifts,
+      polarityFlips,
+      controlTransitions,
+      consciousnessToggles
+    };
+  }
+
+  /**
+   * Generate synchronized coil field patterns
+   */
+  public generateCoilFieldPatterns(): Map<string, number[]> {
+    const patterns = new Map<string, number[]>();
+    
+    this.COILS.forEach(coil => {
+      const coilTokens = this.tokens.filter(t => t.coil === coil);
+      const fieldPattern = coilTokens.map(token => {
+        const coords = this.mapToHexagonalLattice(token);
+        return sqrt(coords.x * coords.x + coords.y * coords.y + coords.z * coords.z);
+      });
+      patterns.set(coil, fieldPattern);
+    });
+    
+    return patterns;
+  }
+
+  /**
+   * Calculate information-theoretic measures
+   */
+  public calculateInformationMetrics(): {
+    entropy: number;
+    complexity: number;
+    coherence: number;
+  } {
+    const totalTokens = this.tokens.length;
+    const uniqueStates = new Set(this.tokens.map(t => `${t.type}-${t.consciousness}`)).size;
+    
+    // Shannon entropy
+    const entropy = log2(uniqueStates);
+    
+    // Complexity based on transitions
+    const transitions = this.analyzeDimensionalShifts();
+    const complexity = (
+      transitions.polarityFlips +
+      transitions.controlTransitions +
+      transitions.consciousnessToggles
+    ) / totalTokens;
+    
+    // Coherence based on pattern regularity
+    const coherence = 1 - (abs(totalTokens - 42) / 42); // Ideal is 42 tokens
+    
+    return { entropy, complexity, coherence };
+  }
+
+  /**
+   * Get all tokens in the stream
+   */
+  public getTokenStream(): VortexToken[] {
+    return [...this.tokens];
+  }
+
+  /**
+   * Get token by phase
+   */
+  public getTokenByPhase(phase: number): VortexToken | undefined {
+    return this.tokens.find(t => t.phase === phase);
+  }
+
+  /**
+   * Get tokens by coil
+   */
+  public getTokensByCoil(coil: string): VortexToken[] {
+    return this.tokens.filter(t => t.coil === coil);
+  }
+
+  /**
+   * Get control tokens
+   */
+  public getControlTokens(): VortexToken[] {
+    return this.tokens.filter(t => t.type === 'control');
+  }
+
+  /**
+   * Export framework state for analysis
+   */
+  public exportFrameworkState(): {
+    tokens: VortexToken[];
+    topological: { eulerCharacteristic: number; genusNumber: number; braidingIndex: number };
+    dimensional: { radialShifts: number[]; angularShifts: number[]; polarityFlips: number; controlTransitions: number; consciousnessToggles: number };
+    information: { entropy: number; complexity: number; coherence: number };
+    fieldPatterns: Map<string, number[]>;
+  } {
+    return {
+      tokens: this.getTokenStream(),
+      topological: this.calculateTopologicalInvariants(),
+      dimensional: this.analyzeDimensionalShifts(),
+      information: this.calculateInformationMetrics(),
+      fieldPatterns: this.generateCoilFieldPatterns()
+    };
+  }
+}
+
+/**
+ * Utility functions for vortex mathematics
+ */
+export class VortexMathUtils {
+  /**
+   * Calculate golden ratio spiral coordinates
+   */
+  static goldenSpiral(t: number): { x: number; y: number } {
+    const phi = (1 + sqrt(5)) / 2;
+    const r = pow(phi, t / PI);
+    return {
+      x: r * cos(t),
+      y: r * sin(t)
+    };
+  }
+
+  /**
+   * Map number to Rodin sequence
+   */
+  static mapToRodinSequence(n: number): number {
+    const sequence = [1, 2, 4, 8, 7, 5];
+    return sequence[n % sequence.length];
+  }
+
+  /**
+   * Calculate vortex phase relationship
+   */
+  static calculatePhaseRelationship(phase1: number, phase2: number): {
+    difference: number;
+    resonance: boolean;
+    harmonic: number;
+  } {
+    const difference = abs(phase1 - phase2) % 360;
+    const resonance = difference % 60 === 0; // Hexagonal resonance
+    const harmonic = round(difference / 60);
+    
+    return { difference, resonance, harmonic };
+  }
+
+  /**
+   * Generate consciousness field equation
+   */
+  static consciousnessFieldEquation(
+    x: number,
+    y: number,
+    z: number,
+    t: number
+  ): number {
+    const r = sqrt(x * x + y * y + z * z);
+    const phi = (1 + sqrt(5)) / 2;
+    
+    // Consciousness field as function of space and time
+    return sin(phi * r) * cos(3 * t) * exp(-r / 9);
+  }
+}
+
+// Export the framework for use
+export default MultidimensionalVortexFramework;

package/src/quantum/adaptive.ts

@@ -0,0 +1,132 @@
+/**
+ * Adaptive & self-improving quantum circuits: use feedback from VQE runs to
+ * guide circuit construction, parameter initialization, and hardware selection.
+ * Quantum methods inform classical heuristics — ansatz choice based on energy
+ * landscape geometry, warm-starting from successful predecessors.
+ */
+
+import { round, max } from '../0/algebra.ts'
+import { type Register } from './simulator.ts'
+import { type OptimizationHistory, type VQEResult } from './variational-optimizer.ts'
+import { type CompiledCircuit, type HardwareProfile } from './hardware-compilation.ts'
+
+export interface AdaptiveState {
+  readonly successfulAnsatze: Array<{ name: string; theta: number[] }>
+  readonly hardwareHistory: Array<{ profile: string; fidelity: number }>
+  readonly convergedRuns: number
+  readonly averageConvergenceSteps: number
+}
+
+/**
+ * Learn from VQE results: track which ansatze converge well, which hardware
+ * profiles achieve best fidelity. Use to seed future runs.
+ */
+export class AdaptiveOptimizer {
+  private state: AdaptiveState
+
+  constructor() {
+    this.state = {
+      successfulAnsatze: [],
+      hardwareHistory: [],
+      convergedRuns: 0,
+      averageConvergenceSteps: 0,
+    }
+  }
+
+  /**
+   * Record a successful VQE run: extract the ansatz, track convergence.
+   */
+  recordSuccess(name: string, result: VQEResult, initialTheta: number[]): void {
+    if (result.converged) {
+      this.state.successfulAnsatze.push({ name, theta: result.theta })
+      this.state.convergedRuns += 1
+      const steps = result.history.length
+      this.state.averageConvergenceSteps =
+        (this.state.averageConvergenceSteps * (this.state.convergedRuns - 1) + steps) / this.state.convergedRuns
+    }
+  }
+
+  /**
+   * Record hardware performance: track which profiles give best fidelity.
+   */
+  recordHardware(profileName: string, fidelity: number): void {
+    this.state.hardwareHistory.push({ profile: profileName, fidelity })
+  }
+
+  /**
+   * Recommend warm-start parameters from successful predecessors.
+   */
+  recommendWarmStart(): number[] | null {
+    if (this.state.successfulAnsatze.length === 0) return null
+    // Return the most recently successful ansatz (could also be a weighted average)
+    return this.state.successfulAnsatze[this.state.successfulAnsatze.length - 1]!.theta
+  }
+
+  /**
+   * Recommend best hardware profile based on history.
+   */
+  recommendHardware(): string | null {
+    if (this.state.hardwareHistory.length === 0) return null
+    let best = this.state.hardwareHistory[0]!
+    for (const h of this.state.hardwareHistory) {
+      if (h.fidelity > best.fidelity) best = h
+    }
+    return best.profile
+  }
+
+  /**
+   * Estimate convergence time for a new problem of similar size.
+   */
+  estimatedSteps(): number {
+    return round(this.state.averageConvergenceSteps) || 100
+  }
+
+  /**
+   * Export state for inter-session persistence (e.g., serialize to JSON).
+   */
+  exportState(): AdaptiveState {
+    return { ...this.state }
+  }
+
+  /**
+   * Import state from a prior run.
+   */
+  importState(s: AdaptiveState): void {
+    this.state = { ...s }
+  }
+}
+
+/**
+ * Adaptive circuit quality: predict whether a circuit will achieve target
+ * fidelity on a given hardware, based on depth and gate count.
+ */
+export function predictFidelity(compiled: CompiledCircuit, profile: HardwareProfile): number {
+  const oneQ_error = compiled.gateCount * 0.3 * profile.errorRate1Q // Rough 30% one-qubit gates
+  const twoQ_error = compiled.gateCount * 0.2 * profile.errorRate2Q // Rough 20% two-qubit gates
+  const depth_error = compiled.depth * profile.depthPenalty
+  return max(0, 1 - (oneQ_error + twoQ_error + depth_error))
+}
+
+/**
+ * Adaptive gate selection: given a target fidelity and hardware, recommend
+ * whether to add more gates for expressivity or stick with shallow circuits.
+ */
+export function recommendCircuitDepth(
+  targetFidelity: number,
+  currentFidelity: number,
+  maxDepth: number,
+  profile: HardwareProfile,
+): { recommended: number; rationale: string } {
+  if (currentFidelity >= targetFidelity) {
+    return { recommended: 0, rationale: 'Target fidelity already achieved; add no gates.' }
+  }
+
+  const fidelityGap = targetFidelity - currentFidelity
+  const depthToAdd = round(fidelityGap / profile.depthPenalty + 1 / 2) // Ceiling via round
+
+  if (depthToAdd > maxDepth) {
+    return { recommended: maxDepth, rationale: 'Gap is large; hardware constraint binding.' }
+  }
+
+  return { recommended: depthToAdd, rationale: `Gap of ${fidelityGap.toFixed(3)}; add ~${depthToAdd} layers.` }
+}