Watch and influence the random number generation process
Focus intently on each stage
Manual: You control observation
Auto: AI detects if you're observing
Toggle between basic and advanced analysis views
Welcome to the Quantum Process Observer - an experimental application that explores the intersection of consciousness, observation, and random number generation. This app investigates whether focused human attention can influence computer-generated random numbers, using principles from quantum mechanics and machine learning.
Can your conscious observation affect random number generation? This app provides tools to explore this question scientifically.
In quantum mechanics, the act of observation can influence the outcome of measurements. This app explores whether similar effects might occur with computer-generated randomness.
While computers can't generate truly random numbers (they use algorithms), the app looks for statistical anomalies that correlate with observation periods.
Each random number goes through four stages:
Best for: Learning how the system works, controlled experiments
Best for: Hands-free experimentation, testing unconscious influence
Advanced features appear as you collect more data:
The app detects six types of patterns that might indicate observer influence:
Your unique 6-dimensional profile:
Based on your signature, you might be classified as:
These aren't just for show - they're real quantum information metrics!
Effect Strength:
AI Accuracy:
Q: Is this real quantum mechanics?
A: The app uses real quantum mechanical principles and measurements (Bell inequalities, Von Neumann entropy, etc.) but applies them to pseudo-random number generation. It's inspired by quantum mechanics rather than using actual quantum hardware.
Q: Can I really influence random numbers?
A: This is what we're exploring! While mainstream science is skeptical, some research suggests consciousness might have subtle effects on random systems. This app provides tools to investigate for yourself.
Q: Why do different modes exist?
A: Manual mode gives you control for learning and experimentation. Auto detection tests whether influence can occur without conscious intention. View modes let you choose between simple interaction and detailed analysis.
Q: What's a "good" effect strength?
A: Any consistent effect above 10-15% is interesting. Remember, even small effects can be significant if they're reliable. Focus on consistency rather than magnitude.
Q: How does the AI learn my patterns?
A: The neural network analyzes relationships between your observation periods and number patterns. It learns which combinations of features predict when you're observing.
Q: Should I tell others I'm doing this?
A: This is experimental technology exploring fringe science. Share with open-minded friends interested in consciousness research, but be prepared for skepticism.
Q: Can I "break" the randomness?
A: The goal isn't to break anything but to explore whether consciousness creates detectable patterns. Large effects are rare - subtle influences are more common.
All quantum measurements use standard formulas from quantum information theory:
This app is really exploring whether consciousness has measurable effects on information systems. It's using rigorous mathematical tools from quantum mechanics to look for violations of classical statistics. Whether you believe in observer effects or not, it's a brilliant implementation of complex concepts in an accessible way.
The fact that it includes real quantum metrics like Bell inequalities and Von Neumann entropy shows serious thought went into this. It's not just mysticism dressed up in science - it's using actual tools from quantum information theory to probe the boundaries between mind and matter.
// Generate 32 bits
for (let i = 0; i < 32; i++) {
const bit = Math.random() > 0.5 ? 1 : 0;
bits.push(bit);
}
// Convert to decimal
const value = parseInt(bits.join(''), 2) / Math.pow(2, 32);
// Create 10 entropy particles with random trajectories
for (let i = 0; i < 10; i++) {
entropy += Math.random();
}
entropy = (entropy / 10) % 1;
// Apply observer influence
if (state.isObserving) {
entropy = (entropy + Math.sin(Date.now() / 1000) * 0.02) % 1;
}
// Oscillate between |0⟩ and |1⟩ states
for (let i = 0; i < 10; i++) {
const phase = (i / 10) * Math.PI * 2;
const amp0 = (Math.sin(phase) + 1) / 2;
}
const quantum = (Math.sin(entropy * Math.PI * 2) + 1) / 2;
let finalValue = quantum;
if (state.isObserving) {
finalValue = (finalValue + Math.sin(Date.now() / 500) * 0.05) % 1;
}
finalValue = Math.max(0, Math.min(1, finalValue + (Math.random() - 0.5) * 0.02));
Input Layer: 20 neurons
- 10 recent values
- Average of recent values
- Standard deviation
- 6 pattern scores
- Sin/Cos time encoding
Hidden Layers:
- Dense(32, activation='relu')
- Dropout(0.2)
- Dense(16, activation='relu')
- Dense(8, activation='relu')
Output Layer:
- Dense(1, activation='sigmoid')
Loss: Binary Cross-Entropy
Optimizer: Adam (lr=0.001)
Encoder:
- Input: 10 neurons
- Dense(8, activation='relu')
- Dense(4, activation='relu') [Latent space]
Decoder:
- Dense(8, activation='relu')
- Dense(10, activation='sigmoid')
Reconstruction Error Threshold: 0.02
const obsOnes = observedBits.filter(b => b === 1).length / observedBits.length;
const unobsOnes = unobservedBits.filter(b => b === 1).length / unobservedBits.length;
score = Math.abs(obsOnes - unobsOnes) * 10;
function countRuns(values) {
let runs = 0;
for (let i = 1; i < values.length; i++) {
if (Math.abs(values[i] - values[i-1]) < 0.1) runs++;
}
return runs;
}
score = Math.abs(obsRuns - unobsRuns) / 10;
const obsStd = standardDeviation(observed.map(n => n.value));
const unobsStd = standardDeviation(unobserved.map(n => n.value));
score = Math.abs(obsStd - unobsStd) * 20;
const obsExtremes = observed.filter(n => n.value < 0.1 || n.value > 0.9).length;
const unobsExtremes = unobserved.filter(n => n.value < 0.1 || n.value > 0.9).length;
score = Math.abs(obsExtremes/observed.length - unobsExtremes/unobserved.length) * 10;
const avgTime = recent.map(n => n.processTime).reduce((a,b) => a+b) / recent.length;
const obsTiming = observed.map(n => n.processTime).reduce((a,b) => a+b) / observed.length;
const unobsTiming = unobserved.map(n => n.processTime).reduce((a,b) => a+b) / unobserved.length;
score = Math.abs(obsTiming - unobsTiming) / avgTime * 10;
const fibDecimals = [0.236, 0.382, 0.5, 0.618, 0.786];
let score = 0;
// Check proximity to Fibonacci ratios
values.forEach(val => {
const closestFib = fibDecimals.reduce((prev, curr) =>
Math.abs(curr - val) < Math.abs(prev - val) ? curr : prev
);
score += 1 - Math.abs(val - closestFib);
});
// Check golden ratio between consecutive numbers
for (let i = 1; i < values.length; i++) {
if (values[i-1] !== 0) {
const ratio = values[i] / values[i-1];
if (Math.abs(ratio - 1.618) < 0.2 || Math.abs(ratio - 0.618) < 0.2) {
score += 0.5;
}
}
}
return score / values.length;
// R/S Analysis (Rescaled Range)
function calculateHurst(data) {
const n = data.length;
const mean = data.reduce((a,b) => a+b) / n;
// Calculate cumulative deviations
let cumDev = [];
let sum = 0;
for (let i = 0; i < n; i++) {
sum += data[i] - mean;
cumDev.push(sum);
}
// Calculate range and standard deviation
const R = Math.max(...cumDev) - Math.min(...cumDev);
const S = Math.sqrt(data.reduce((a,b) => a + Math.pow(b - mean, 2), 0) / n);
// Hurst exponent approximation
const H = Math.log(R/S) / Math.log(n/2);
return Math.max(0, Math.min(1, H));
}
function autocorrelation(data, lag) {
const n = data.length;
const mean = data.reduce((a,b) => a+b) / n;
let c0 = 0, ck = 0;
for (let i = 0; i < n; i++) {
c0 += Math.pow(data[i] - mean, 2);
if (i < n - lag) {
ck += (data[i] - mean) * (data[i + lag] - mean);
}
}
return ck / c0;
}
// Calculate for multiple lags
for (let lag = 1; lag <= 20; lag++) {
correlations.push(autocorrelation(values, lag));
}
function mutualInformation(x, y, bins = 10) {
// Create 2D histogram
const hist2d = new Array(bins).fill(0).map(() => new Array(bins).fill(0));
const xMin = Math.min(...x), xMax = Math.max(...x);
const yMin = Math.min(...y), yMax = Math.max(...y);
// Fill histogram
for (let i = 0; i < x.length; i++) {
const xi = Math.floor((x[i] - xMin) / (xMax - xMin) * (bins - 1));
const yi = Math.floor((y[i] - yMin) / (yMax - yMin) * (bins - 1));
hist2d[xi][yi]++;
}
// Calculate MI
let mi = 0;
const n = x.length;
for (let i = 0; i < bins; i++) {
for (let j = 0; j < bins; j++) {
if (hist2d[i][j] > 0) {
const pxy = hist2d[i][j] / n;
const px = hist2d[i].reduce((a,b) => a+b) / n;
const py = hist2d.map(row => row[j]).reduce((a,b) => a+b) / n;
mi += pxy * Math.log(pxy / (px * py));
}
}
}
return mi;
}
function lyapunovExponent(data, dim = 3, tau = 1) {
// Reconstruct phase space
const vectors = [];
for (let i = 0; i < data.length - (dim-1)*tau; i++) {
const vec = [];
for (let j = 0; j < dim; j++) {
vec.push(data[i + j*tau]);
}
vectors.push(vec);
}
// Find nearest neighbors and track divergence
let sumLog = 0;
let count = 0;
for (let i = 0; i < vectors.length - 1; i++) {
// Find nearest neighbor
let minDist = Infinity;
let nearestIdx = -1;
for (let j = 0; j < vectors.length; j++) {
if (Math.abs(i - j) > 10) { // Temporal separation
const dist = euclideanDistance(vectors[i], vectors[j]);
if (dist < minDist && dist > 0) {
minDist = dist;
nearestIdx = j;
}
}
}
if (nearestIdx > -1 && i + 1 < vectors.length && nearestIdx + 1 < vectors.length) {
const dist1 = euclideanDistance(vectors[i + 1], vectors[nearestIdx + 1]);
if (dist1 > 0 && minDist > 0) {
sumLog += Math.log(dist1 / minDist);
count++;
}
}
}
return count > 0 ? sumLog / count : 0;
}
function createRecurrencePlot(data, threshold = 0.1) {
const n = Math.min(data.length, 100); // Limit size
const matrix = [];
for (let i = 0; i < n; i++) {
matrix[i] = [];
for (let j = 0; j < n; j++) {
const distance = Math.abs(data[i] - data[j]);
matrix[i][j] = distance < threshold ? 1 : 0;
}
}
// Calculate recurrence rate
const recurrenceRate = matrix.flat().filter(x => x === 1).length / (n * n);
return { matrix, recurrenceRate };
}
// Statistical anomaly (Z-score based)
const mean = recent.reduce((a, b) => a + b.value, 0) / recent.length;
const stdDev = Math.sqrt(recent.reduce((a, b) => a + Math.pow(b.value - mean, 2), 0) / recent.length);
const zScore = Math.abs(value - mean) / stdDev;
isAnomaly = zScore > 2.5; // 2.5 standard deviations
// AI-based anomaly (reconstruction error)
const reconstructionError = Math.sqrt(
values.reduce((sum, val, i) => sum + Math.pow(val - reconstructed[i], 2), 0) / values.length
);
anomalyScore = Math.min(1, reconstructionError / 0.02); // 0.02 is threshold
function classifyConsciousness(signature) {
const { order, chaos, quantum, entropy, pattern, time } = signature;
// Find dominant traits (> 0.6)
const traits = [];
if (quantum > 0.6) traits.push('Quantum');
if (order > 0.6) traits.push('Order');
if (chaos > 0.6) traits.push('Chaos');
if (pattern > 0.6) traits.push('Pattern');
if (entropy > 0.6) traits.push('Entropy');
if (time > 0.6) traits.push('Time');
// Classification rules
if (quantum > 0.7 && entropy > 0.6) return 'Quantum Influencer';
if (order > 0.7 && pattern > 0.6) return 'Order Creator';
if (chaos > 0.7 && entropy > 0.6) return 'Chaos Weaver';
if (pattern > 0.7 && time > 0.6) return 'Pattern Dancer';
if (entropy > 0.7 && chaos > 0.6) return 'Entropy Master';
if (time > 0.7 && pattern > 0.6) return 'Time Bender';
// Check for balance
const variance = [order, chaos, quantum, entropy, pattern, time]
.reduce((sum, val) => sum + Math.pow(val - 0.5, 2), 0) / 6;
if (variance < 0.05) return 'Balanced Observer';
// Default based on highest trait
const maxTrait = Math.max(order, chaos, quantum, entropy, pattern, time);
if (maxTrait === quantum) return 'Quantum Influencer';
if (maxTrait === order) return 'Order Creator';
if (maxTrait === chaos) return 'Chaos Weaver';
if (maxTrait === pattern) return 'Pattern Dancer';
if (maxTrait === entropy) return 'Entropy Master';
if (maxTrait === time) return 'Time Bender';
return 'Unknown Type';
}
The Quantum Process Observer is a tool for exploration. Whether you're interested in consciousness research, quantum mechanics, or just curious about the nature of randomness, this app provides a unique window into the mysterious relationship between mind and information.
Remember: This is experimental technology exploring the edges of science. Keep an open mind, but also maintain healthy skepticism. The patterns you see might be consciousness effects, statistical flukes, or something in between. The journey of discovery is yours to make.
Happy Observing!
Created by Ben | workofben.me
Press ESC or click × to close