Search

  • Best Arguments for Physicalism

    Show us how in terms of the Lorenz contractor. — Banno

    Do you mean attractor? I'm also not good at math, but thank bigbang I can try and apply conceptualizations with AI and produce a code for it. Are you looking for something like this? Put it into https://jsfiddle.net/ and run

    <!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <style>
        body {
            margin: 0;
            overflow: hidden;
            background-color: #f0f0f0;
        }

        canvas {
            display: block;
        }
    </style>
    <script>
        const canvas = document.createElement('canvas');
        document.body.appendChild(canvas);

        const ctx = canvas.getContext('2d');
        canvas.width = window.innerWidth;
        canvas.height = window.innerHeight;

        const lorenzSystem = (x, y, z, sigma, rho, beta, dt) => {
            const deviation = (Math.random() - 0.5) * 0.1; // 10% random deviation
            const dx = (sigma * (y - x) + deviation) * dt;
            const dy = (x * (rho - z) - y + deviation) * dt;
            const dz = (x * y - beta * z + deviation) * dt;

            return {
                x: x + dx,
                y: y + dy,
                z: z + dz
            };
        };

        const drawDot = (x, y, size, color) => {
            ctx.beginPath();
            ctx.arc(x, y, size, 0, Math.PI * 2);
            ctx.fillStyle = color;
            ctx.fill();
        };

        const animate = () => {
            const sigma = 10;
            const rho = 28;
            const beta = 8 / 3;
            const dt = 0.01;

            let x = 1;
            let y = 1;
            let z = 1;

            const emergentTerm = () => Math.sin(Date.now() * 0.001) * 0.5;

            const renderFrame = () => {
                const { x: newX, y: newY, z: newZ } = lorenzSystem(x, y, z, sigma, rho, beta, dt);

                const lorenzX = newX * 10 + canvas.width / 2;
                const lorenzY = newY * 10 + canvas.height / 2;

                // Check for random deviation and split the trajectory
                if (Math.random() < 0.1) {
                    const emergentX = lorenzX + Math.cos(emergentTerm()) * 50;
                    const emergentY = lorenzY + Math.sin(emergentTerm()) * 50;

                    drawDot(lorenzX, lorenzY, 1, '#3498db'); // Blue dot (Lorenz system)
                    drawDot(emergentX, emergentY, 2, '#e74c3c'); // Red dot (Emergent part)
                } else {
                    drawDot(lorenzX, lorenzY, 1, '#3498db'); // Blue dot (Lorenz system)
                }

                x = newX;
                y = newY;
                z = newZ;

                requestAnimationFrame(renderFrame);
            };

            renderFrame();
        };

        window.addEventListener('resize', () => {
            canvas.width = window.innerWidth;
            canvas.height = window.innerHeight;
        });

        animate();
    </script>
</head>
<body>
</body>
</html>

    The gist of it is the Lorenz system having deviations that occur at a rate of 10% probability and when that happen a split produce another shape.

    Basically, a simple guiding principle for deviations that follow the system but produce another level of complexity. If it produces a deviated shape at a certain probability, maybe that's what you're after?

    But I'm not sure what you aim for with the Lorenz system in relation to emergence? So I'm just guessing.

    But it's fun playing with the math :sweat:
    Christoffer,  
Home » Search

Welcome to The Philosophy Forum!

Get involved in philosophical discussions about knowledge, truth, language, consciousness, science, politics, religion, logic and mathematics, art, history, and lots more. No ads, no clutter, and very little agreement — just fascinating conversations.

Sign In Create Account

Categories