# Rosenbrock ROS2: ROS=[1]

Primer motor que no obtiene el paso resolviendo un unico sistema de etapas ampliado en Calcula. El generador C escribe el modelo de un instante; el motor Perl pide su campo diferencial, aproxima el Jacobiano y resuelve dos sistemas lineales con una misma factorizacion. RK, GLM y PGLM conservan sus caminos numericos. El proveedor original usa EVAL; el optativo v5 usa la nueva capacidad SENS1 de Calcula. No se usa SWIG.

## Seleccion y uso

Para paso fijo, en RUN_CONTROLS de un `.ds`:

```text
ROS=[1]
SIRU_PASO=[0.01]
SIRU_ADAPT=[0]
```

En RUN CONTROLS de un `.d`:

```text
ROS=[1]
STARTING STEP SIZE = 0.01
SIRU ADAPTIVE STEP = 0
```

ROS 1 identifica ROS2 (orden dos); el ID es arbitrario dentro de esta familia, no equivale a RK1 ni PGLM1. Solo esta implementado este ID. Los selectores ROS, RK, GLM y PGLM son excluyentes. ROS no requiere ni admite IMEX_EXPLICITA.

`d2datdinc --din archivo.d` respeta el selector. Tambien existe `--din-ros 1`. El artefacto ejecutable es `archivo-de-d2datdinc-ROS1.din`. Desde siru, con Calcula en PATH:

```bash
bin/siru /ruta/de/trabajo/decaimiento.ds
bin/siru /ruta/de/trabajo/decaimiento-de-d2datdinc-ROS1.din
```

La segunda orden no necesita el `.d`, `.ds`, `.dat` ni un catalogo. Copiar los ejemplos a un directorio de trabajo antes de correrlos para no dejar informes junto al corpus. La salida por defecto es `.simul`; `--salida resultado.csv` pide CSV. Se conservan las salidas existentes y no se publica una trayectoria parcial si falla la corrida.

Para paso adaptativo, en RUN_CONTROLS de un `.ds`:

```text
ROS=[1]
SIRU_ADAPT=[1]
SIRU_PASO=[0.1]
SIRU_PASO_MIN=[1e-8]
SIRU_PASO_MAX=[0.2]
SIRU_ABSOLUTO=[1e-6]
SIRU_RELATIVO=[1e-4]
```

En `.d`: `SIRU ADAPTIVE STEP = 1`, `STARTING STEP SIZE = 0.1`, `MINIMUM STEP SIZE = 1e-8`, `MAXIMUM STEP SIZE = 0.2`, `SIRU ABSOLUTE TOLERANCE = 1e-6` y `SIRU RELATIVE TOLERANCE = 1e-4`. Se reutilizan los controles existentes, sin otra numeracion ROS. Igual que en los otros motores, dar paso, limites o tolerancias activa la adaptacion salvo `SIRU_ADAPT=[0]` explicito. Para evitar depender de valores por defecto, conviene declarar la politica y limites.

## Que contiene el din

| Parte | Contenido |
| --- | --- |
| Ecuaciones | Modelo residual original: estados impuestos, derivadas y algebraicas a resolver. |
| `# corrida` | Intervalo, paso, nombre de tiempo y `metodo ROS`. |
| `# parametros` | Datos constantes de la simulacion. |
| `# estados` | Estado, nombre virtual del siguiente estado, valor inicial y `-` en fijo o nombre virtual del error en adaptativo. |
| `# adaptacion` | Solo en modo adaptativo: metodo embebido, orden del error, tolerancias y limites de paso. |
| `# ros` | Descriptor JSON comentado: v2 fijo, v3 adaptativo global o v4 con tolerancias por estado; ID, metodo, orden, politica de paso, diferenciacion, escalas, control del Jacobiano y mapa estado/derivada. Se siguen leyendo los v1 archivados. |
| `# salidas` | OUTPUTS, si existen; tambien se resuelven las algebraicas de salida desde el mismo din. |

Ejemplo de descriptor para un estado:

```json
{"version":2,"familia":"ROS","id":1,"metodo":"ros2","orden":2,"paso":"fijo_final_acortado","jacobiano":"campo_central","delta":0.0001,"derivadas":{"x":"dx"},"escalas":{"x":1},"escala_tiempo":1,"control_jacobiano":{"absoluto":0.000001,"relativo":0.001,"refinamientos":3}}
```

En `# estados`, `x p_x 1 -` significa que p_x lo devuelve el motor temporal. **p_x no es una variable de Calcula ni tiene una ecuacion ficticia.** El lector comprueba que x y dx si esten declaradas, que las derivadas no sean datos impuestos y que no se mezclen metadatos de otros motores. Como en los otros contratos, no demuestra que un din editado manualmente describa el problema fisico que se pretendia.

En modo adaptativo la fila es `x p_x 1 e_x`: e_x es el error estimado, no otro estado siguiente ni una incognita de Calcula. El descriptor v3 conserva las escalas y el control del Jacobiano de v2, pero exige `paso: adaptativo_embebido` y `estimador: ros2_2_1_error_directo`. El lector rechaza mezclar v1/v2 con adaptacion, omitirla en v3 o cambiar el orden del estimador. No alcanza con cambiar solo el numero de version de un din archivado: regenerarlo desde la fuente.

## Operaciones nuevas

| Componente | Responsabilidad |
| --- | --- |
| `slex/din/ros.inc` | Exportar el modelo y contrato ROS; validar capacidades del modelo. |
| `Siru::ROS::campo_calcula` | Construir f(t,y) pidiendo las derivadas a una sesion persistente de Calcula. |
| `Siru::Campo` | Evaluar f, diferenciar respecto de estados y tiempo, controlar dimensiones y finitud. |
| `Siru::Lineal` | Factorizar una matriz densa mediante LU con pivoteo escalado y resolver varios segundos miembros. |
| `Siru::ServiciosNumericos` | Encapsular campo/Jacobiano, identidad del intento, cachés y LU densa con varios segundos miembros. |
| `Siru::EtapasROS` | Ejecutar una tabla triangular de incrementos con una factorización compartida. |
| `Siru::ROS::paso` | Proporcionar la tabla ROS2 al motor de etapas; conserva fórmula y error embebido. |
| `Siru::Integrador` y `Salida` | Conducir el tiempo y publicar la trayectoria al completar. |

El Jacobiano es `J_ij=df_i/dy_j`, con vectores columna. Cada perturbacion de un estado vuelve a resolver las variables algebraicas: no se mantienen artificialmente constantes ni se usa el Jacobiano del residuo de Newton. La derivada temporal se obtiene manteniendo fijos los estados. La formula y referencia de coeficientes estan en [PLAN_ROS.md](PLAN_ROS.md#formula-elegida).

Se divide por la separacion efectivamente representada entre los puntos perturbados y se exige que ambos puntos difieran del punto central. Cada consulta parte de las semillas del modelo, sin transferir soluciones entre perturbaciones; eso evita introducir dependencia deliberada del orden de las consultas, pero no garantiza continuidad de rama si hay soluciones multiples.

## Servicios y etapas extensibles (2026-10-06)

Se reutilizan `Campo`, `CampoSensibilidad` y `Lineal`; no se agregan comandos a Calcula ni nuevos IDs ROS. El servicio declara campo, Jacobiano del campo, derivada temporal y resolución lineal densa con varios segundos miembros. No anuncia residuos/Jacobiano residual públicos, DAE general, matrices dispersas ni productos Jacobiano-vector.

| Operación del servicio | Contrato |
| --- | --- |
| `nuevo`, `reconfigurar` | Proveedor e identidad de modelo/topología/parámetros; reconfigurar invalida las cachés. Si el proveedor cambia internamente, el llamador debe reconfigurarlo explícitamente. |
| `preparar(t,y,h)` | La clave incluye proveedor, contexto, tiempo, estados y paso con 17 cifras; cambiar cualquiera invalida Jacobiano y factores. |
| `derivadas` | Retorna copias de campo, Jacobiano reducido y derivada temporal; reutiliza solo dentro del mismo contexto y política autónoma. |
| `factorizar`, `resolver`, `resolver_varios` | LU con pivoteo escalado existente; identidad exacta de matriz y varios segundos miembros. |
| `descartar` | Invalida estado preparado y cachés, sin borrar costos. El motor de etapas lo llama si falla un cálculo. |

ROS crea el servicio por intento: no se habilita reutilización aproximada de Jacobianos entre pasos. El informe mantiene los costos de Calcula y agrega `numericos` (evaluaciones de campo/Jacobiano, factorizaciones, segundos miembros y reusos). Estos contadores cuentan operaciones del servicio, no sustituyen las consultas internas EVAL/SENS del proveedor.

El contrato interno de `EtapasROS` usa incrementos, no derivadas:

```text
(I - gamma*h*J) k_i = gamma*h*f(t + alpha_i*h, y + sum_j a_ij*k_j)
                    + h*h*d_i*f_t + sum_j c_ij*k_j
y_nuevo = y + sum_i m_i*k_i
error   = sum_i e_i*k_i
```

Las filas `a` y `c` son estrictamente triangulares inferiores. Se validan dimensiones y finitud; eso no demuestra el orden de una tabla. ROS2 aporta sus mismos coeficientes, con `gamma=1+1/sqrt(2)`, `a_21=1/gamma`, `c_21=-2`, `alpha=[0,1]`, `d=[gamma²,-gamma²]`, `m=[3/(2*gamma),1/(2*gamma)]` y `e=[1/(2*gamma),1/(2*gamma)]`. Una prueba interna de tres etapas, con la última de peso cero, comprueba que el mecanismo no está fijado a dos; no se presenta como un método nuevo ni como verificación de ROS3.

Pruebas: `servicios_numericos.t` verifica copias, invalidación por cada componente del contexto (incluido un cambio de un ulp), factorización, varios segundos miembros y etapas. Las suites ROS existentes verifican recurrencia, orden, tiempos no autónomos, escalas, adaptación y SENS1 sin cambiar referencias.

## Escalas y comprobacion del Jacobiano (v2)

Los nuevos din llevan por defecto comprobacion de consistencia, tanto v2 fijo como v3 adaptativo. Los v1 conservan las diferencias centrales originales, sin comprobacion y con escala minima 1. Regenerar un din puede detectar y rechazar inconsistencias que antes pasaban inadvertidas.

Controles opcionales en RUN_CONTROLS de un `.ds`:

```text
ROS=[1]
ROS_ESCALAS=[X,1e-6,Z,1e6]
ROS_ESCALA_TIEMPO=[1]
ROS_DELTA=[1e-4]
ROS_CONTROL_JACOBIANO=[1e-6,1e-3,3]
```

En `.d` se escriben con espacios: `ROS ESCALAS = [X,1e-6,Z,1e6]`, `ROS ESCALA TIEMPO = [1]`, `ROS DELTA = [1e-4]` y `ROS CONTROL JACOBIANO = [1e-6,1e-3,3]`.

| Control | Significado y validacion |
| --- | --- |
| ROS_ESCALAS | Pares nombre de estado, escala positiva finita, en las mismas unidades del estado. No importan orden ni mayusculas. Estados omitidos toman 1; desconocidos, duplicados y listas vacias/incompletas se rechazan. En circuitos se usan los estados efectivos: por ejemplo QC3, no VC3. |
| ROS_ESCALA_TIEMPO | Escala positiva finita en las unidades del tiempo; por defecto 1. |
| ROS_DELTA | Factor relativo de perturbacion, estrictamente entre 0 y 1; por defecto 1e-4. No es el paso temporal. |
| ROS_CONTROL_JACOBIANO | Tolerancia absoluta, relativa y cantidad maxima de refinamientos adicionales. Por defecto [1e-6,1e-3,3]. Absoluta no negativa, relativa entre 0 inclusive y 1 exclusive, al menos una positiva; refinamientos entero entre 0 y 10. Con 0 igualmente se compara una vez. |

Las perturbaciones iniciales son `d_j=delta*max(abs(y_j),s_j)` y `d_t=delta*max(abs(t),s_t)`. La escala no reemplaza al estado ni cambia las ecuaciones, semillas o tolerancias internas de Calcula; tampoco reescala la matriz LU. Conviene elegir magnitudes caracteristicas del problema, no tolerancias de error.

Para comparar magnitudes de distintas unidades se usan las entradas adimensionales `A_ij=s_t*s_j*J_ij/s_i` y `b_i=s_t^2*f_t_i/s_i`, con las escalas declaradas. Se calculan diferencias centrales con d y d/2. Cada entrada debe cumplir `abs(A_nueva-A_anterior) <= absoluto + relativo*max(abs(A_nueva),abs(A_anterior))`; la misma prueba se aplica a b. Se acepta la aproximacion de d/2, sin extrapolar. Si no cumple, se reutiliza esa aproximacion como anterior y se reduce otra vez la perturbacion, hasta el limite. Se rechazan magnitudes intermedias no representables y fallos del campo; no se cambia automaticamente a diferencias unilaterales.

Es una comprobacion acotada de consistencia, **no una cota certificada de error**: diferencias coincidentes pueden estar equivocadas por ruido correlacionado, cancelacion o falta de suavidad. Tampoco mide el error de integracion ni modifica el paso temporal. Ante fallo, revisar unidades, dominio, delta y precision del campo; aflojar tolerancias no corrige el modelo. La [documentacion de diferenciacion de GSL](https://www.gnu.org/software/gsl/doc/html/diff.html) explica el compromiso entre truncamiento y redondeo; nuestro control es mas simple y no implementa su busqueda de perturbacion optima.

## Estimador y control temporal (v3)

ROS2 usa el par embebido 2(1) de [KPP](https://kpp.readthedocs.io/en/stable/num_methods/rosenbrock-methods.html#ros-2). Con las mismas etapas k1 y k2, el vector de error es `err=(k1+k2)/(2*gamma)`. Su termino principal es de orden h^2: `orden_error=2`, no 3. Se acepta siempre la solucion principal de orden dos, no la embebida de orden uno. No se hacen mas consultas a Calcula para estimar el error ni se resta un par de estados grandes casi iguales: el conductor recibe el vector err directamente.

| Operacion | Regla |
| --- | --- |
| Escala temporal de error por componente | `atol_i + rtol_i*max(abs(y_anterior),abs(y_nuevo))`. Absoluta positiva y relativa no negativa; globales en v3 o por estado en v4. No son las escalas ni tolerancias del Jacobiano. |
| Error normalizado | Maximo sobre los estados de `abs(err_i)/escala_i`. |
| Aceptacion | Error normalizado <= 1. Solo entonces avanzan tiempo y estado, se ejecuta paso_aceptado y se escribe una fila. |
| Paso propuesto | `h*min(5,max(0.2,0.9*error^(-1/2)))`; con error cero, factor 5. Se aplican limites minimo/maximo. |
| Rechazo | Reintenta con paso menor desde el mismo tiempo y estado aceptados. No publica el intento fallido ni lo incorpora a una historia de soluciones. |
| Limites | 20 intentos por paso por defecto; `intentos_max` puede declararse en la seccion adaptacion del din. Tambien rige max_pasos del conductor. Al agotarse, falla sin publicar trayectoria parcial. |
| Final | Se acorta el ultimo paso para llegar a hasta. Puede ser menor que paso_min; si su error no es tolerable, falla en vez de avanzar mas alla del final. |
| Fallos no temporales | Un error del campo, dominio, Jacobiano, LU, protocolo o timeout aborta: no se esconde con reintentos de menor h, ni siquiera si contiene SOLVER FAILURE. |

`SIRU_ORDEN_ERROR`, si se declara con adaptacion ROS2, debe ser 2; no se admite cambiarlo para hacer el controlador mas permisivo. La configuracion comun aporta atol=1e-6, rtol=1e-4 y paso_min=1e-12 por defecto; con adaptacion y sin maximo explicito usa el maximo comun de 0.02*STOP TIME cuando ese tiempo es positivo. El paso inicial se acota a los limites antes del primer intento.

Los reintentos recalculan campo, Jacobiano y factorizacion; solo las dos etapas de un mismo intento comparten LU. La cota es un criterio local estimado, no una garantia de error global. ROS_ESCALAS solo controla diferenciacion; para estados con distintas unidades se pueden declarar tolerancias temporales individuales. Persisten las limitaciones de suavidad y precision de Calcula.

El conductor compartido incorpora dos opciones optativas: `error_embebido_directo` y `fallo_paso_fatal`, que activa ROS. Los otros motores conservan por defecto su comparacion de estados embebidos y su politica de rescate. No se agregan semillas entre perturbaciones ni historia de pasos rechazados.

## Tolerancias por estado (v4)

Con adaptacion activa, `ROS_TOLERANCIAS=[X,1e-11,1e-4,Z,10,1e-4]` en `.ds` declara grupos de nombre de estado, tolerancia absoluta y relativa. En `.d`: `ROS TOLERANCIAS = [X,1e-11,1e-4,Z,10,1e-4]`. No depende del orden de los estados ni de mayusculas. En circuitos se usan los estados efectivos (por ejemplo QC3, no VC3).

- Los estados omitidos heredan SIRU_ABSOLUTO y SIRU_RELATIVO. La absoluta tiene las unidades del estado; la relativa es adimensional. Los dos valores deben ser finitos, con absoluta positiva y relativa no negativa.
- Se rechazan estados desconocidos, duplicados, listas vacias/incompletas y su uso en modo fijo. Declarar ROS_TOLERANCIAS no activa por si solo la adaptacion: indicar SIRU_ADAPT=[1].
- El generador resuelve las tolerancias de todos los estados y las guarda en `# ros`, bajo `tolerancias`, como mapa `{"x":{"absoluto":1e-11,"relativo":1e-4},"z":{"absoluto":10,"relativo":1e-4}}`. Usa version 4; no se necesita el archivo fuente para correr. El lector exige cobertura exacta y valida cada valor.
- Sin este control se siguen generando v2/v3, sin cambios numericos. v4 conserva el estimador y las escalas de v3. `--paso-factor F` multiplica tambien las tolerancias individuales por F^2, igual que las globales para este estimador.

## Sensibilidades del residuo (v5)

Seleccion optativa en RUN_CONTROLS de un .ds:

~~~text
ROS=[1]
ROS_JACOBIANO=[SENSIBILIDADES]
ROS_ESCALAS_RESIDUO=[Z,1]
~~~

En .d los controles se llaman ROS JACOBIANO y ROS ESCALAS RESIDUO. Sin ROS_JACOBIANO, o con [CAMPO_CENTRAL], se conserva el proveedor anterior y sus contratos. ROS_ESCALAS_RESIDUO solo se admite con [SENSIBILIDADES]: son pares variable,escala positiva finita, incluidos datos e incognitas algebraicas; nombres desconocidos, duplicados o lista vacia/incompleta se rechazan.

| Aspecto | Contrato v5 |
| --- | --- |
| Descriptor | jacobiano=sensibilidad_residuo; escalas_residuo cubre exactamente todas las variables declaradas. No precisa .dat ni catalogo externo. |
| Paso | Fijo o adaptativo segun la politica paso; no se infiere del numero de version. Conserva ROS2 y su estimador. |
| Tolerancias | Admite las globales o ROS_TOLERANCIAS; paso-factor conserva el ajuste de las individuales. |
| Escalas | Por defecto 1 para cada variable, ROS_ESCALAS para los estados, escala_tiempo para tiempo y escala_estado/escala_tiempo para las derivadas. ROS_ESCALAS_RESIDUO puede sobrescribir cualquiera; el generador guarda los valores efectivos. |
| Capacidad | Se consulta CAPS una vez por sesion y se exige SENS1. Un Calcula anterior se rechaza claramente; no hay respaldo silencioso. |
| Operaciones por intento | Una SENS devuelve f, J y f_t en el punto inicial; un EVAL calcula la segunda etapa. OUTPUTS mantiene sus consultas aparte. |

Calcula resuelve R(t,y,z)=0 una vez y obtiene las sensibilidades resolviendo R_z S=-R_q, con q=(y,t) o solo y en el caso autonomo. Se extraen las filas de las derivadas del estado; no se entrega R_z directamente como J. Las perturbaciones evaluan residuos manteniendo las otras variables fijas, sin volver a resolver z. El evaluador se restaura al terminar, tambien si falla.

ROS_DELTA y ROS_CONTROL_JACOBIANO se transportan a CONTROL de SENS1. En este proveedor la consistencia se mide sobre las derivadas de residuos escaladas por variable y normalizadas por fila, no con el criterio adimensional del campo_central. Calcula verifica el residuo central escalado <=1e-8 y la relacion singular minimo/maximo >1e-10 de R_z escalada. Usa SVD para ese diagnostico y una LU propia para todos los segundos miembros: no reutiliza la LU interna de Newton ni el Jacobiano entre intentos.

Limites iniciales de SENS1: 1..256 ecuaciones y salidas y 1..64 datos diferenciados (estados mas tiempo si corresponde). Las perturbaciones deben respetar dominios y restricciones tambien fuera de R=0. Un NaN colgante se rechaza. Los fallos SENSITIVITY abortan la corrida sin publicacion parcial ni reduccion del paso para esconderlos.

Es diferenciacion numerica de residuos, no automatica ni analitica. Coincidencia entre perturbaciones y buen condicionamiento de la matriz aproximada no certifican suavidad, unicidad ni exactitud. Menos resoluciones completas no garantiza menos tiempo: se agregan evaluaciones de residuos y SVD/LU densas. Contrato, errores y detalles en [protocolo de Calcula](../../../calcula/calcula-6.0/PROTOCOLO-MAQUINA.md).

## Estadisticas de la corrida

El informe `.informe` agrega una linea `estadisticas ROS: { ... }`, con JSON de claves ordenadas. La API acepta `estadisticas => \%hash` en `ROS->correr_din` o `ROS->integrar`; el hash se reinicia al entrar. No cambia el CSV ni requiere mas consultas.

| Campo | Significado |
| --- | --- |
| motor | ROS. |
| intentos | Pasos numericos intentados, incluidos los rechazados y el que aborte por fallo. |
| aceptados | Avances aceptados; no incluye la fila inicial. |
| rechazados_error | Intentos cuyo error temporal normalizado excede 1, incluido el rechazo terminal por limite. |
| fallos_evaluacion | Intentos abortados al calcular campo, Jacobiano o etapas; no son rechazos por error temporal. |
| consultas_campo | Peticiones EVAL enviadas para campo/Jacobiano/etapas, incluida una peticion que falle. No cuenta iteraciones de Newton ni evaluaciones escalares de residuos. |
| consultas_sensibilidad | Peticiones SENS enviadas (incluida la que falle); no se suman a consultas_campo. La consulta CAPS no se cuenta como evaluacion numerica. |
| consultas_salidas | EVAL adicionales de OUTPUTS; una peticion agrupa todas las variables necesarias de una fila, incluida la inicial. Es cero si las salidas ya son datos conocidos. |
| t_aceptado | Ultimo tiempo aceptado por el conductor; no implica que se haya publicado la trayectoria. |
| paso_min_aceptado, paso_max_aceptado | Extremos de los pasos aceptados; ausentes si no hubo ninguno. |
| completa | 1 solo despues de publicar la trayectoria; 0 al fallar. |

Una corrida fallida puede dejar estadisticas parciales en el informe, pero no una trayectoria parcial. Antes de iniciar el conductor algunos contadores pueden estar ausentes. No inferir `completa` de la existencia del informe. La API directa `integrar` cuenta el campo; si el llamador agrega su propio callback de salidas, le corresponde instrumentar esas consultas.

## Alcance y limitaciones

| Aspecto | Estado actual |
| --- | --- |
| Modelo | Campo reducido localmente unico y suave; pueden existir algebraicas resolubles. No DAE general ni indice alto. |
| Paso | Fijo v1/v2 o adaptativo embebido v3/v4; v5 permite ambas politicas. Ultimo paso acortado. |
| Topologia | Solo din simple: sin llaves, lazos de capacitores ni cortes de bobinas. |
| Controles | Sin DT/TICK, paradas adicionales, convoluciones, inicializacion algebraica, DC, sensibilidad, Monte Carlo, peor caso, RERUN ni CONTINUE. Se rechazan, no se ignoran. |
| Diferenciacion | Numerica: campo_central resuelve el modelo a ambos lados; SENS1 evalua residuos con las otras variables fijas. No detectan automaticamente toda falta de suavidad. |
| Escalas | Configurables por estado y tiempo en v2. Los valores por defecto siguen requiriendo revision segun las unidades del modelo. |
| Precision | v2 compara diferencias a dos perturbaciones con refinamiento limitado; no certifica el error real del Jacobiano. Reducir delta no garantiza mejor precision. |
| Lineal | LU densa en Perl, para sistemas pequenos; pivotes nulos/demasiado pequenos y valores no finitos producen error. No estima el numero de condicion ni usa estructura dispersa. |
| Fallo | Solo se reduce el paso por error temporal estimado. Otros fallos abortan sin publicar resultados parciales. |

Con n estados, v1 requiere 2*n+2 evaluaciones del modelo autonomo o 2*n+4 si hay variable temporal. v2/v3/v4 requieren al menos 4*n+2 o 4*n+6 respectivamente; cada refinamiento adicional agrega dos evaluaciones por direccion que no haya pasado la comprobacion. Con r refinamientos permitidos, el maximo es `(4+2*r)*n+2` autonomo y `(4+2*r)*(n+1)+2` no autonomo. v5 usa una SENS y un EVAL por intento. OUTPUTS agrega sus consultas. Cada EVAL y SENS puede necesitar una resolucion no lineal en Calcula: que las etapas ROS sean lineales no convierte en lineal al modelo residual.

## Pruebas y continuidad

Verificacion del 2026-10-04, incluido el quinto hito (sensibilidades): 412 pruebas especificas ROS en 7 archivos; suite completa de siru, 981 pruebas en 29 archivos; generador C, 68 pruebas. Todas correctas sobre el arbol disponible al verificar, incluidos los cambios concurrentes. Calcula paso su regresion de 1747 puntos por cada uno de cuatro modelos y 34 comprobaciones especificas de SENS1. libdin y d2datdinc compilados en serie, sin limpiar ni reemplazar el trabajo de la otra sesion.

`tests/ros_nucleo.t` verifica algebra lineal, orientacion del Jacobiano, derivada temporal, recurrencia escalar, rigidez, singularidad y orden no lineal. `tests/ros.t` verifica el pipeline real, orden autonomo/no autonomo, dependencia algebraica, ultimo paso, selectores y metadatos invalidos, OUTPUTS, salida atomica y equivalencia fuente/din. El circuito de seis elementos se contrasta con una implementacion matricial independiente.

Los casos persistentes estan en [siru/corpus/ROS](../corpus/corpus/ROS/README.md). El caso escalas.ds agrega estados de magnitudes 1e-6 y 1e6. `tests/ros_escalas.t` prueba cambio de unidades, perturbaciones de dominio pequeno, refinamiento, ruido alternante, redondeo y validacion de contratos. `tests/ros.t` tambien comprueba la configuracion desde .d/.ds/.dat, la recurrencia del corpus escalado y compatibilidad con din v1.

`tests/ros_adaptativo_nucleo.t` comprueba el estimador contra formulas independientes, su orden h^2, error directo con estados grandes, rechazo sin mutacion, tolerancias, rigidez, ultimo paso y fallos fatales. `tests/ros_adaptativo.t` comprueba .d/.ds/.dat y din aislado, criterio de error de cada paso aceptado contra una recurrencia independiente, contratos invalidos y salida atomica. Corpus: adaptativo.ds y rigido-adaptativo.ds.

`tests/ros_tolerancias.t` verifica v4 desde .d/.ds y din aislado, respaldo global, cambio de unidades (estados 1e-6 y 1e6), paso-factor, rechazos de contratos invalidos, informe de CLI, consultas de OUTPUTS y reinicio de estadisticas. El nucleo adaptativo comprueba tambien contadores ante errores fatales. Corpus: tolerancias.ds.

tests/ros_sensibilidades.t verifica J y f_t analiticos con algebraicas, trayectoria contra campo_central, costo en consultas, .d/.ds/.dat/din, modos fijo/adaptativo, tolerancias individuales, contrato y capacidad incompatibles. Corpus: sensibilidades.ds.

Siguen pendientes algebra dispersa, reutilizacion controlada entre intentos y otros Rosenbrock. Las politicas numericas de RK/GLM/PGLM no cambian. ROS sigue limitado a din simple y campo suave, sin soporte nuevo de mdin, eventos ni discontinuidades. SENS1 no habilita el analisis SCEPTRE de sensibilidad de parametros: es una operacion local para construir el Jacobiano del integrador.