Migration Guide: PyTorch to MIND

import torch

x = torch.tensor([[1.0, 2.0], [3.0, 4.0]])
w = torch.randn(2, 3)
b = torch.zeros(3)

// Shape is part of the type — verified at compile time
let x: Tensor<f32, 2, 2> = tensor([[1.0, 2.0], [3.0, 4.0]])
param w: Tensor<f32, 2, 3>
param b: Tensor<f32, 3>

# PyTorch: crashes at RUNTIME
x = torch.randn(32, 784)
w = torch.randn(256, 784)  # Wrong shape!
y = x @ w  # RuntimeError: mat1 and mat2 shapes
           # cannot be multiplied (32x784 and 256x784)

// MIND: caught at COMPILE TIME
let x: Tensor<f32, ?, 784> = input()
param w: Tensor<f32, 256, 784>       // Wrong shape!
let y = matmul(x, w)
// COMPILE ERROR: matmul inner dimensions
// do not match: 784 != 256
// hint: did you mean Tensor<f32, 784, 256>?

# Runtime autograd tape
x = torch.randn(32, 784, requires_grad=True)
y = model(x)
loss = criterion(y, target)
loss.backward()  # Builds + walks tape at runtime
optimizer.step()

// Compile-time gradient generation
@grad
fn train_step(x: Tensor<f32, ?, 784>,
              target: Tensor<f32, ?, 10>,
              lr: f32) -> Tensor<f32, 1> {
    let pred = forward(x)
    let loss = cross_entropy(pred, target)
    for param in parameters {
        param = sub(param, mul_scalar(grad(loss, param), lr))
    }
    loss
}

import torch.nn as nn

class MLP(nn.Module):
    def __init__(self):
        super().__init__()
        self.fc1 = nn.Linear(784, 256)
        self.fc2 = nn.Linear(256, 10)

    def forward(self, x):
        x = torch.relu(self.fc1(x))
        return self.fc2(x)

module mlp

param W1: Tensor<f32, 784, 256>
param b1: Tensor<f32, 256>
param W2: Tensor<f32, 256, 10>
param b2: Tensor<f32, 10>

fn forward(x: Tensor<f32, ?, 784>)
    -> Tensor<f32, ?, 10> {
    let h = relu(add(matmul(x, W1),
                     broadcast(b1, [?, 256])))
    add(matmul(h, W2), broadcast(b2, [?, 10]))
}

# Multiple export paths, each with quirks
torch.onnx.export(model, dummy_input, "model.onnx")
traced = torch.jit.trace(model, dummy_input)
traced.save("model.pt")
# TensorRT, CoreML need separate conversion

# Single source, single semantics
mindc build model.mind                 # CPU (shipped)
mindc build model.mind --target cuda   # GPU (roadmap:
                                       #  commercial runtime)
mindc build model.mind --target metal  # Metal (roadmap)
mindc build model.mind --export onnx   # ONNX (roadmap)