Вот переписанная функция на Lua с учетом особенностей языка:

function rman(src, len)
    -- Создаем матрицу как таблицу таблиц
    local m = {}
    for k = 1, len do
        -- Используем 1-индексацию, храним исходный индекс как k-1 (0-based)
        m[k] = { 
            src[k] or 0,  -- nz() аналог: заменяем nil/NaN на 0
            k - 1         -- сохраняем 0-based индекс
        }
    end

    -- Сортировка по первому элементу (значению) по убыванию
    table.sort(m, function(a, b) 
        return a[1] > b[1] 
    end)

    -- Вычисление суммы квадратов разностей
    local sum = 0.0
    for k = 1, len do
        local original_index = m[k][2]  -- исходный 0-based индекс
        local current_index = k - 1     -- текущий 0-based индекс
        sum = sum + math.pow(original_index - current_index, 2)
    end

    return sum
end


Ключевые отличия и пояснения:Индексация:Lua использует 1-based индексацию, 
поэтому циклы идут от 1 до len Исходные индексы (0-based) сохраняются как k - 1Матрица:
Реализована как таблица таблиц m = {}Каждая строка: { значение, исходный_индекс }
Обработка NaN/nil:Аналог nz() - src[k] or 0 заменяет nil/NaN на 0
Для строгой проверки NaN можно добавить: type(src[k]) == "number" and src[k] == src[k]
Сортировка:Используется table.sort() с кастомным компаратором 
Сортировка по первому элементу (значению) по убываниюВычисление суммы:
В цикле сравниваются исходный индекс и текущая позицияРазница возводится в квадрат через math.pow()
Пример использования:lua

local data = {10, 30, 20, 50, 40}
local result = rman(data, #data)
print(result)  -- Выведет: 10.0

Особенности реализации:Функция принимает таблицу src и длину len 
Возвращает число (сумму квадратов разностей)Корректно обрабатывает:
Отрицательные числа Нулевые значенияДубликаты в исходных данныхНеопределенные значения (nil/NaN)
Для работы с очень большими массивами (>100K элементов) рекомендуется оптимизировать сортировку, 
но для типичных случаев (например, технический анализ) текущая реализация эффективна.

--[[
    rman(src, len)

    src – таблица чисел (или «series»), длина которой должна быть >= len.
    len – количество элементов, которые будем обрабатывать.

    Возвращает: сумма квадратов разницы между позицией элемента после сортировки
    по убыванию его значения и исходной позицией в массиве.
--]]
function rman(src, len)
    -- 1) Собираем «матрицу» как таблицу вложенных таблиц:
    --      {value = <значение>, idx = <исходный индекс>}
    local m = {}
    for k = 1, len do
        local val = src[k] or 0          -- заменяем nil/NaN на 0 (nz в Pine)
        local idx = k - 1                -- Pine использует индексы от 0,
                                         -- поэтому смещаем на 1
        m[#m + 1] = {value = val, idx = idx}
    end

    -- 2) Сортируем по убыванию значения (первый столбец)
    table.sort(m, function(a, b)
        return a.value > b.value         -- descending order
    end)

    -- 3) Вычисляем сумму квадратов разницы позиций
    local sum = 0.0
    for i = 1, len do
        local diff = m[i].idx - (i - 1)   -- опять смещение индексов на 0
        sum = sum + diff * diff          -- math.pow(diff,2) можно заменить умножением
    end

    return sum
end

Ключевые отличия от Pine‑Script

-- пример входных данных
local src = {5.2, nil, 3.7, 4.1, 0.9}
local len = #src          -- считаем все элементы

print(rman(src, len))     -- выведет сумму квадратов разниц

_rman(src, len,)=>    
    var m = matrix.new<float>(len, 2, 0.)
    for k = 0 to len- 1
        matrix.set(m, k, 0, nz(src[k]))
        matrix.set(m, k, 1, k)
    matrix.sort(m, 0, order.descending)
    sum = 0.0
    for k = 0 to len- 1
        sum += math.pow(matrix.get(m, k, 1) - k, 2)
    sum