Skip to content
TheChatArchiveThe Chat Archive
Metallama-3.3-70b-instruct· MetaHugging Face LMArena Human Preference 140K

Make a 3D visual simulation wave function of schirondinger equation that show the…

From a Chatbot Arena battleThe same person sent this prompt to two anonymous models at once. Compare it with Claudeclaude-sonnet-4-20250514-thinking-32k’s answer.
  1. User

    Make a 3D visual simulation wave function of schirondinger equation that show the colapse of the wave when I touch my mobile screen (peak very narrowed with color gradually turn blue to yellow at the peak), after that the wave will envolving smooth, make it 3D using tree.js put all code in wave.html for I will run on my Brouser. After touch the wave will smoothing spread again.

  2. Meta Assistant

    Creating a 3D visual simulation of a wave function that collapses upon touch and then evolves smoothly, as described, involves several steps and technologies. We'll use Three.js for the 3D rendering, and JavaScript for the logic. This example will be simplified for educational purposes.

    Below is a basic implementation of your request. This code should be saved as wave.html and can be run in a modern web browser. Note that this is a simplified version and might need adjustments for a more precise representation of the Schrödinger equation's wave function collapse.

    <!DOCTYPE html>
    <html lang="en">
    <head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, user-scalable=no, minimum-scale=1.0, maximum-scale=1.0">
    <title>Wave Function Simulation</title>
    <style>
        body { margin: 0; }
        canvas { display: block; }
    </style>
    </head>
    <body>
    <script src="https://cdnjs.cloudflare.com/ajax/libs/three.js/r128/three.min.js"></script>
    <script>
        let scene, camera, renderer, mesh;
        let isCollapsed = false;
        let collapsePosition = 0;
    
        // Initialize scene, camera, and renderer
        function init() {
            scene = new THREE.Scene();
            scene.background = new THREE.Color(0x222222);
            camera = new THREE.PerspectiveCamera(75, window.innerWidth / window.innerHeight, 0.1, 1000);
            camera.position.z = 5;
    
            renderer = new THREE.WebGLRenderer();
            renderer.setSize(window.innerWidth, window.innerHeight);
            document.body.appendChild(renderer.domElement);
    
            // Create a simple wave mesh
            const geometry = new THREE.PlaneGeometry(10, 1, 100, 10);
            const material = new THREE.MeshBasicMaterial({vertexColors: true});
            mesh = new THREE.Mesh(geometry, material);
            scene.add(mesh);
    
            // Initialize vertex colors
            const colors = [];
            for (let i = 0; i < geometry.attributes.position.count; i++) {
                colors.push(0.5, 0.5, 1); // Blue-ish
            }
            geometry.setAttribute('color', new THREE.Float32BufferAttribute(colors, 3));
    
            // Event listener for touch/click
            document.addEventListener('touchstart', collapseWave, false);
            document.addEventListener('mousedown', collapseWave, false);
    
            animate();
        }
    
        // Animate the scene
        function animate() {
            requestAnimationFrame(animate);
    
            if (isCollapsed) {
                // Simulate wave function collapse
                const geometry = mesh.geometry;
                const positions = geometry.attributes.position.array;
                const colors = geometry.attributes.color.array;
    
                for (let i = 0; i < positions.length; i += 3) {
                    const x = positions[i];
                    const distanceFromCollapse = Math.abs(x - collapsePosition);
                    positions[i + 1] = Math.sin(x * 5 + performance.now() * 0.01) * (1 - distanceFromCollapse); // Simplified wave equation
    
                    // Color gradient
                    if (distanceFromCollapse < 0.1) {
                        colors[i] = 1; // Red to Yellow
                        colors[i + 1] = 1;
                        colors[i + 2] = 0;
                    } else {
                        colors[i] = 0.5; // Blue-ish
                        colors[i + 1] = 0.5;
                        colors[i + 2] = 1;
                    }
                }
                geometry.attributes.position.needsUpdate = true;
                geometry.attributes.color.needsUpdate = true;
    
                // After a short period, start smoothing out
                if (performance.now() - collapseTime > 2000) {
                    isCollapsed = false;
                }
            } else {
                // Smooth wave before collapse
                const geometry = mesh.geometry;
                const positions = geometry.attributes.position.array;
    
                for (let i = 0; i < positions.length; i += 3) {
                    positions[i + 1] = Math.sin(positions[i] * 5 + performance.now() * 0.01); // Simplified wave equation
                }
                geometry.attributes.position.needsUpdate = true;
            }
    
            renderer.render(scene, camera);
        }
    
        let collapseTime = 0;
        function collapseWave(event) {
            event.preventDefault();
            isCollapsed = true;
            collapseTime = performance.now();
            collapsePosition = (event.clientX / window.innerWidth) * 10 - 5; // Map click position to wave position
        }
    
        init();
    </script>
    </body>
    </html>
    

    This code creates a basic 3D scene with a plane that represents a wave. When you touch or click the screen, the wave "collapses" at the point of touch, represented by a peak in the wave that gradually turns yellow. After a couple of seconds, the wave starts to smooth out again.

    Please note, this is a highly simplified representation and not a direct simulation of the Schrödinger equation. The actual mathematical modeling of wave function collapse is far more complex and involves quantum mechanics principles that cannot be directly translated into this kind of visual simulation without significant simplification.

Responses were produced in different, uncontrolled contexts (system prompts, settings, prior turns). This is not a benchmark.