powerball-quantum 1.0.0

package/src/cli.ts

@@ -0,0 +1,82 @@
+#!/usr/bin/env node
+
+import { Command } from 'commander';
+import { predict, updateData, formatPick } from './index';
+
+const program = new Command();
+
+program
+  .name('powerball-quantum')
+  .description('Powerball number predictor using quantum-inspired algorithm')
+  .version('1.0.0');
+
+program
+  .command('predict')
+  .description('Generate predicted Powerball numbers')
+  .option('-c, --count <number>', 'Number of picks to generate', '5')
+  .option('-a, --analysis', 'Show signal analysis', false)
+  .action(async (options) => {
+    console.log('');
+    console.log('🎱 POWERBALL QUANTUM PREDICTOR');
+    console.log('═'.repeat(50));
+
+    try {
+      const picks = await predict({
+        count: parseInt(options.count),
+        showAnalysis: options.analysis
+      });
+
+      console.log('\n⭐ RECOMMENDED PICKS:\n');
+
+      picks.forEach((pick, i) => {
+        const score = pick.score?.toFixed(1) || '?';
+        console.log(`  #${i + 1}  ${formatPick(pick)}  (score: ${score})`);
+      });
+
+      console.log('\n' + '═'.repeat(50));
+      console.log('Good luck! 🍀\n');
+    } catch (error) {
+      console.error('Error:', error);
+      process.exit(1);
+    }
+  });
+
+program
+  .command('update')
+  .description('Update Powerball data from NY Lottery API')
+  .action(async () => {
+    console.log('');
+    console.log('📥 Updating Powerball data...');
+    console.log('═'.repeat(50));
+
+    try {
+      await updateData();
+      console.log('✅ Data updated successfully!\n');
+    } catch (error) {
+      console.error('Error updating data:', error);
+      process.exit(1);
+    }
+  });
+
+program
+  .command('quick')
+  .description('Get one quick pick')
+  .action(async () => {
+    try {
+      const picks = await predict({ count: 1 });
+      if (picks[0]) {
+        console.log('\n🎫 Your lucky numbers:');
+        console.log(`\n   ${formatPick(picks[0])}\n`);
+      }
+    } catch (error) {
+      console.error('Error:', error);
+      process.exit(1);
+    }
+  });
+
+// Default action (no command)
+if (process.argv.length === 2) {
+  program.parse(['node', 'cli', 'predict']);
+} else {
+  program.parse();
+}

package/src/data.ts

@@ -0,0 +1,83 @@
+import axios from 'axios';
+import * as fs from 'fs';
+import * as path from 'path';
+import { Draw, DATA_URL } from './types';
+
+const DATA_FILE = path.join(__dirname, '..', 'powerball_data.csv');
+
+/**
+ * Download latest Powerball data from NY Lottery API
+ */
+export async function downloadData(): Promise<string> {
+  console.log('Downloading latest Powerball data...');
+  const response = await axios.get(DATA_URL);
+  fs.writeFileSync(DATA_FILE, response.data);
+  console.log('Download complete!');
+  return DATA_FILE;
+}
+
+/**
+ * Parse CSV data into Draw objects
+ */
+export function parseCSV(csvContent: string): Draw[] {
+  const lines = csvContent.trim().split('\n');
+  const draws: Draw[] = [];
+
+  // Skip header
+  for (let i = 1; i < lines.length; i++) {
+    const line = lines[i].trim();
+    if (!line) continue;
+
+    const parts = line.split(',');
+    if (parts.length < 3) continue;
+
+    const dateStr = parts[0];
+    const numbersStr = parts[1];
+    const multiplier = parseInt(parts[2]) || 2;
+
+    const numbers = numbersStr.split(' ').map(n => parseInt(n.trim()));
+    if (numbers.length < 6) continue;
+
+    const date = new Date(dateStr);
+    // Filter for current rules (post Oct 7, 2015)
+    if (date < new Date('2015-10-07')) continue;
+
+    draws.push({
+      date,
+      whiteBalls: numbers.slice(0, 5),
+      powerball: numbers[5],
+      multiplier
+    });
+  }
+
+  return draws;
+}
+
+/**
+ * Load data from file or download if not exists
+ */
+export async function loadData(): Promise<Draw[]> {
+  let csvContent: string;
+
+  if (fs.existsSync(DATA_FILE)) {
+    csvContent = fs.readFileSync(DATA_FILE, 'utf-8');
+  } else {
+    await downloadData();
+    csvContent = fs.readFileSync(DATA_FILE, 'utf-8');
+  }
+
+  const draws = parseCSV(csvContent);
+  console.log(`Loaded ${draws.length} draws (current rules since 2015-10-07)`);
+  return draws;
+}
+
+/**
+ * Update data (force re-download)
+ */
+export async function updateData(): Promise<Draw[]> {
+  await downloadData();
+  const csvContent = fs.readFileSync(DATA_FILE, 'utf-8');
+  const draws = parseCSV(csvContent);
+  console.log(`Updated! ${draws.length} draws loaded.`);
+  return draws;
+}

package/src/index.ts

@@ -0,0 +1,142 @@
+import { Draw, Pick, PredictOptions } from './types';
+import { loadData, updateData } from './data';
+import {
+  calculateMomentum,
+  calculateZScores,
+  calculateRecentMomentum,
+  analyzePairFrequency,
+  quantumSelect,
+  checkSumRange,
+  checkOddEvenRatio,
+  checkHighLowBalance,
+  checkDecadeBalance,
+  checkEndingDiversity,
+  checkNoTripleConsecutive,
+  isInHistory,
+  buildHistorySet
+} from './quantum';
+
+export { Draw, Pick, PredictOptions } from './types';
+export { loadData, updateData } from './data';
+
+/**
+ * Generate a single quantum-powered pick
+ */
+export function generatePick(
+  draws: Draw[],
+  historySet: Set<string>,
+  whiteMomentum: Record<number, number>,
+  redMomentum: Record<number, number>,
+  whiteZ: Record<number, number>,
+  redZ: Record<number, number>,
+  whiteRecent: Record<number, number>,
+  redRecent: Record<number, number>,
+  pairBonus: Record<number, number>
+): Pick | null {
+  const maxAttempts = 150000;
+
+  for (let attempt = 0; attempt < maxAttempts; attempt++) {
+    const whiteBalls = quantumSelect(whiteMomentum, whiteZ, whiteRecent, pairBonus, 5).sort((a, b) => a - b);
+    const powerball = quantumSelect(redMomentum, redZ, redRecent, {}, 1)[0];
+
+    // Apply all filters
+    if (isInHistory(whiteBalls, powerball, historySet)) continue;
+    if (!checkSumRange(whiteBalls)) continue;
+    if (!checkOddEvenRatio(whiteBalls)) continue;
+    if (!checkHighLowBalance(whiteBalls)) continue;
+    if (!checkDecadeBalance(whiteBalls)) continue;
+    if (!checkEndingDiversity(whiteBalls)) continue;
+    if (!checkNoTripleConsecutive(whiteBalls)) continue;
+
+    // Calculate score
+    let score = 0;
+    whiteBalls.forEach(n => {
+      score += (whiteMomentum[n] || 0) * 1.0;
+      score += Math.max(0, whiteZ[n] || 0) * 3.0;
+      score += (whiteRecent[n] || 0) * 2.0;
+      score += (pairBonus[n] || 0) * 0.5;
+    });
+    score += (redMomentum[powerball] || 0) * 2.0;
+    score += Math.max(0, redZ[powerball] || 0) * 4.0;
+
+    return { whiteBalls, powerball, score };
+  }
+
+  return null;
+}
+
+/**
+ * Main prediction function - call this to get picks!
+ *
+ * @example
+ * ```typescript
+ * import { predict } from 'powerball-quantum';
+ *
+ * const picks = await predict({ count: 5 });
+ * console.log(picks);
+ * ```
+ */
+export async function predict(options: PredictOptions = {}): Promise<Pick[]> {
+  const { count = 5, showAnalysis = false } = options;
+
+  // Load data
+  const draws = await loadData();
+  const historySet = buildHistorySet(draws);
+
+  // Calculate all signals
+  const { white: wMom, red: rMom } = calculateMomentum(draws);
+  const { white: wZ, red: rZ } = calculateZScores(draws);
+  const { white: wRecent, red: rRecent } = calculateRecentMomentum(draws, 15);
+  const pairBonus = analyzePairFrequency(draws, 50);
+
+  if (showAnalysis) {
+    console.log('\n📊 Signal Analysis:');
+    const topMom = Object.entries(wMom).sort((a, b) => b[1] - a[1]).slice(0, 10);
+    console.log('🔥 Hot Numbers:', topMom.map(([n]) => n));
+    const topZ = Object.entries(wZ).sort((a, b) => b[1] - a[1]).slice(0, 10);
+    console.log('⏰ Overdue Numbers:', topZ.filter(([, z]) => z > 1).map(([n]) => n));
+  }
+
+  // Generate picks
+  const picks: Pick[] = [];
+  const seen = new Set<string>();
+
+  for (let i = 0; i < count * 10 && picks.length < count; i++) {
+    const pick = generatePick(
+      draws, historySet,
+      wMom, rMom, wZ, rZ, wRecent, rRecent, pairBonus
+    );
+
+    if (pick) {
+      const key = pick.whiteBalls.join(',') + '-' + pick.powerball;
+      if (!seen.has(key)) {
+        seen.add(key);
+        picks.push(pick);
+      }
+    }
+  }
+
+  // Sort by score
+  picks.sort((a, b) => (b.score || 0) - (a.score || 0));
+
+  return picks;
+}
+
+/**
+ * Quick function to get a single best pick
+ */
+export async function quickPick(): Promise<Pick | null> {
+  const picks = await predict({ count: 1 });
+  return picks[0] || null;
+}
+
+/**
+ * Format pick for display
+ */
+export function formatPick(pick: Pick): string {
+  const whites = pick.whiteBalls.map(n => n.toString().padStart(2, ' ')).join(' - ');
+  return `${whites}  🔴 ${pick.powerball}`;
+}
+
+// Default export
+export default { predict, quickPick, updateData, loadData, formatPick };

package/src/quantum.ts

@@ -0,0 +1,277 @@
+import { Draw, Pick, Scores, WHITE_BALL_RANGE, RED_BALL_RANGE } from './types';
+
+/**
+ * Calculate exponential decay momentum scores
+ */
+export function calculateMomentum(draws: Draw[], decayAlpha = 0.03): { white: Scores; red: Scores } {
+  const whiteScores: Scores = {};
+  const redScores: Scores = {};
+
+  // Initialize scores
+  for (let n = WHITE_BALL_RANGE.min; n <= WHITE_BALL_RANGE.max; n++) {
+    whiteScores[n] = 0.1;
+  }
+  for (let n = RED_BALL_RANGE.min; n <= RED_BALL_RANGE.max; n++) {
+    redScores[n] = 0.1;
+  }
+
+  // Sort by date ascending
+  const sorted = [...draws].sort((a, b) => a.date.getTime() - b.date.getTime());
+  const total = sorted.length;
+
+  sorted.forEach((draw, idx) => {
+    const t = total - 1 - idx; // t=0 for most recent
+    const weight = Math.exp(-decayAlpha * t);
+
+    draw.whiteBalls.forEach(w => {
+      if (whiteScores[w] !== undefined) {
+        whiteScores[w] += weight;
+      }
+    });
+
+    if (redScores[draw.powerball] !== undefined) {
+      redScores[draw.powerball] += weight;
+    }
+  });
+
+  return { white: whiteScores, red: redScores };
+}
+
+/**
+ * Calculate Z-scores for gap analysis (mean reversion)
+ */
+export function calculateZScores(draws: Draw[]): { white: Scores; red: Scores } {
+  const whiteGaps: { [key: number]: number[] } = {};
+  const redGaps: { [key: number]: number[] } = {};
+  const lastSeenWhite: { [key: number]: number } = {};
+  const lastSeenRed: { [key: number]: number } = {};
+
+  // Initialize
+  for (let n = WHITE_BALL_RANGE.min; n <= WHITE_BALL_RANGE.max; n++) {
+    whiteGaps[n] = [];
+    lastSeenWhite[n] = -1;
+  }
+  for (let n = RED_BALL_RANGE.min; n <= RED_BALL_RANGE.max; n++) {
+    redGaps[n] = [];
+    lastSeenRed[n] = -1;
+  }
+
+  const sorted = [...draws].sort((a, b) => a.date.getTime() - b.date.getTime());
+
+  sorted.forEach((draw, idx) => {
+    // White balls
+    draw.whiteBalls.forEach(w => {
+      if (lastSeenWhite[w] !== -1) {
+        whiteGaps[w].push(idx - lastSeenWhite[w]);
+      }
+      lastSeenWhite[w] = idx;
+    });
+
+    // Red ball
+    if (lastSeenRed[draw.powerball] !== -1) {
+      redGaps[draw.powerball].push(idx - lastSeenRed[draw.powerball]);
+    }
+    lastSeenRed[draw.powerball] = idx;
+  });
+
+  const total = sorted.length;
+  const whiteZ: Scores = {};
+  const redZ: Scores = {};
+
+  // Calculate Z-scores
+  for (let n = WHITE_BALL_RANGE.min; n <= WHITE_BALL_RANGE.max; n++) {
+    const currentGap = total - 1 - lastSeenWhite[n];
+    const gaps = whiteGaps[n];
+
+    if (gaps.length === 0) {
+      whiteZ[n] = 0;
+      continue;
+    }
+
+    const mean = gaps.reduce((a, b) => a + b, 0) / gaps.length;
+    const variance = gaps.reduce((sum, g) => sum + Math.pow(g - mean, 2), 0) / gaps.length;
+    const stdev = Math.sqrt(variance) || 1;
+
+    whiteZ[n] = (currentGap - mean) / stdev;
+  }
+
+  for (let n = RED_BALL_RANGE.min; n <= RED_BALL_RANGE.max; n++) {
+    const currentGap = total - 1 - lastSeenRed[n];
+    const gaps = redGaps[n];
+
+    if (gaps.length === 0) {
+      redZ[n] = 0;
+      continue;
+    }
+
+    const mean = gaps.reduce((a, b) => a + b, 0) / gaps.length;
+    const variance = gaps.reduce((sum, g) => sum + Math.pow(g - mean, 2), 0) / gaps.length;
+    const stdev = Math.sqrt(variance) || 1;
+
+    redZ[n] = (currentGap - mean) / stdev;
+  }
+
+  return { white: whiteZ, red: redZ };
+}
+
+/**
+ * Calculate recent momentum (last N draws)
+ */
+export function calculateRecentMomentum(draws: Draw[], nRecent = 15, decay = 0.15): { white: Scores; red: Scores } {
+  const whiteScores: Scores = {};
+  const redScores: Scores = {};
+
+  for (let n = WHITE_BALL_RANGE.min; n <= WHITE_BALL_RANGE.max; n++) {
+    whiteScores[n] = 0.1;
+  }
+  for (let n = RED_BALL_RANGE.min; n <= RED_BALL_RANGE.max; n++) {
+    redScores[n] = 0.1;
+  }
+
+  const sorted = [...draws].sort((a, b) => b.date.getTime() - a.date.getTime()).slice(0, nRecent);
+
+  sorted.forEach((draw, idx) => {
+    const weight = Math.exp(-decay * idx) * 2;
+
+    draw.whiteBalls.forEach(w => {
+      if (whiteScores[w] !== undefined) {
+        whiteScores[w] += weight;
+      }
+    });
+
+    if (redScores[draw.powerball] !== undefined) {
+      redScores[draw.powerball] += weight;
+    }
+  });
+
+  return { white: whiteScores, red: redScores };
+}
+
+/**
+ * Analyze pair frequency
+ */
+export function analyzePairFrequency(draws: Draw[], topN = 50): Scores {
+  const pairCounts: Map<string, number> = new Map();
+
+  draws.forEach(draw => {
+    const whites = [...draw.whiteBalls].sort((a, b) => a - b);
+    for (let i = 0; i < whites.length; i++) {
+      for (let j = i + 1; j < whites.length; j++) {
+        const key = `${whites[i]}-${whites[j]}`;
+        pairCounts.set(key, (pairCounts.get(key) || 0) + 1);
+      }
+    }
+  });
+
+  const pairBonus: Scores = {};
+  const sorted = [...pairCounts.entries()]
+    .sort((a, b) => b[1] - a[1])
+    .slice(0, topN);
+
+  sorted.forEach(([pair, count]) => {
+    const [a, b] = pair.split('-').map(Number);
+    pairBonus[a] = (pairBonus[a] || 0) + count * 0.1;
+    pairBonus[b] = (pairBonus[b] || 0) + count * 0.1;
+  });
+
+  return pairBonus;
+}
+
+/**
+ * Weighted random selection
+ */
+export function weightedSample(candidates: number[], weights: number[], k: number): number[] {
+  const selected = new Set<number>();
+  const totalWeight = weights.reduce((a, b) => a + b, 0);
+
+  while (selected.size < k) {
+    let r = Math.random() * totalWeight;
+    for (let i = 0; i < candidates.length; i++) {
+      r -= weights[i];
+      if (r <= 0) {
+        selected.add(candidates[i]);
+        break;
+      }
+    }
+  }
+
+  return [...selected];
+}
+
+/**
+ * Quantum selector combining all signals
+ */
+export function quantumSelect(
+  momentum: Scores,
+  zScores: Scores,
+  recentMomentum: Scores,
+  pairBonus: Scores,
+  nPicks: number
+): number[] {
+  const candidates = Object.keys(momentum).map(Number);
+  const weights = candidates.map(n => {
+    const base = momentum[n] || 0;
+    const zBoost = Math.max(0, zScores[n] || 0) * 5;
+    const recentBoost = (recentMomentum[n] || 0) * 1.5;
+    const pairB = (pairBonus[n] || 0) * 0.5;
+    return Math.max(0.1, base + zBoost + recentBoost + pairB);
+  });
+
+  return weightedSample(candidates, weights, nPicks);
+}
+
+// --- FILTERS ---
+
+export function checkSumRange(whiteBalls: number[], min = 130, max = 220): boolean {
+  const sum = whiteBalls.reduce((a, b) => a + b, 0);
+  return sum >= min && sum <= max;
+}
+
+export function checkOddEvenRatio(whiteBalls: number[]): boolean {
+  const odds = whiteBalls.filter(x => x % 2 !== 0).length;
+  const evens = 5 - odds;
+  return (odds === 3 && evens === 2) || (odds === 2 && evens === 3);
+}
+
+export function checkHighLowBalance(whiteBalls: number[], threshold = 35): boolean {
+  const lows = whiteBalls.filter(x => x < threshold).length;
+  const highs = 5 - lows;
+  return (lows === 3 && highs === 2) || (lows === 2 && highs === 3);
+}
+
+export function checkDecadeBalance(whiteBalls: number[]): boolean {
+  const decades = new Set(whiteBalls.map(n => Math.floor(n / 10)));
+  return decades.size >= 3;
+}
+
+export function checkEndingDiversity(whiteBalls: number[]): boolean {
+  const endings = new Set(whiteBalls.map(n => n % 10));
+  return endings.size >= 4;
+}
+
+export function checkNoTripleConsecutive(whiteBalls: number[]): boolean {
+  const sorted = [...whiteBalls].sort((a, b) => a - b);
+  const diffs = [];
+  for (let i = 0; i < sorted.length - 1; i++) {
+    diffs.push(sorted[i + 1] - sorted[i]);
+  }
+  const consecutiveOnes = diffs.filter(d => d === 1).length;
+  return consecutiveOnes < 2;
+}
+
+/**
+ * Check if combination exists in history
+ */
+export function isInHistory(whiteBalls: number[], powerball: number, history: Set<string>): boolean {
+  const key = [...whiteBalls].sort((a, b) => a - b).join(',') + '-' + powerball;
+  return history.has(key);
+}
+
+export function buildHistorySet(draws: Draw[]): Set<string> {
+  const history = new Set<string>();
+  draws.forEach(draw => {
+    const key = [...draw.whiteBalls].sort((a, b) => a - b).join(',') + '-' + draw.powerball;
+    history.add(key);
+  });
+  return history;
+}

package/src/types.ts

@@ -0,0 +1,25 @@
+export interface Draw {
+  date: Date;
+  whiteBalls: number[];
+  powerball: number;
+  multiplier: number;
+}
+
+export interface Pick {
+  whiteBalls: number[];
+  powerball: number;
+  score?: number;
+}
+
+export interface Scores {
+  [key: number]: number;
+}
+
+export interface PredictOptions {
+  count?: number;
+  showAnalysis?: boolean;
+}
+
+export const WHITE_BALL_RANGE = { min: 1, max: 69 };
+export const RED_BALL_RANGE = { min: 1, max: 26 };
+export const DATA_URL = "https://data.ny.gov/api/views/d6yy-54nr/rows.csv?accessType=DOWNLOAD";

package/tsconfig.json

@@ -0,0 +1,17 @@
+{
+  "compilerOptions": {
+    "target": "ES2020",
+    "module": "commonjs",
+    "lib": ["ES2020"],
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "declaration": true,
+    "resolveJsonModule": true
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist"]
+}