rusttorch 0.4.0

Build, train, and run neural networks in Rust with LibTorch
Documentation
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
1001
1002
1003
1004
1005
1006
1007
1008
1009
1010
1011
1012
1013
1014
1015
1016
1017
1018
1019
1020
1021
1022
1023
1024
1025
1026
1027
1028
1029
1030
1031
1032
1033
1034
1035
1036
1037
1038
1039
1040
1041
1042
1043
1044
1045
1046
1047
1048
1049
1050
1051
1052
1053
1054
1055
1056
1057
1058
1059
1060
1061
1062
1063
1064
1065
1066
1067
1068
1069
1070
1071
1072
1073
1074
1075
1076
1077
1078
1079
1080
1081
1082
1083
1084
1085
1086
1087
1088
1089
1090
1091
1092
1093
1094
1095
1096
1097
1098
1099
1100
1101
1102
1103
1104
1105
1106
1107
1108
1109
1110
1111
1112
1113
1114
1115
1116
1117
1118
1119
1120
1121
1122
1123
1124
1125
1126
1127
1128
1129
1130
1131
1132
1133
1134
1135
1136
1137
1138
1139
1140
1141
1142
1143
1144
1145
1146
1147
1148
1149
1150
1151
1152
1153
1154
1155
1156
1157
1158
1159
1160
1161
1162
1163
1164
1165
1166
1167
1168
1169
1170
1171
1172
1173
1174
1175
1176
1177
1178
1179
1180
1181
1182
1183
1184
1185
1186
1187
1188
1189
1190
1191
1192
1193
1194
1195
1196
1197
1198
1199
1200
1201
1202
1203
1204
1205
1206
1207
1208
1209
1210
1211
1212
1213
1214
1215
1216
1217
1218
1219
1220
1221
1222
1223
1224
1225
1226
1227
1228
1229
1230
1231
1232
1233
1234
1235
1236
1237
1238
1239
1240
1241
1242
1243
1244
1245
1246
1247
1248
1249
1250
1251
1252
1253
1254
1255
1256
1257
1258
1259
1260
1261
1262
1263
1264
1265
1266
1267
1268
1269
1270
1271
1272
1273
1274
1275
1276
1277
1278
1279
1280
1281
1282
1283
1284
1285
1286
1287
1288
1289
1290
1291
1292
1293
1294
1295
1296
1297
1298
1299
1300
1301
1302
1303
1304
1305
1306
1307
1308
1309
1310
1311
1312
1313
1314
1315
1316
1317
1318
1319
1320
1321
1322
1323
1324
1325
1326
1327
1328
1329
1330
1331
1332
1333
1334
1335
1336
1337
1338
1339
1340
1341
1342
1343
1344
1345
1346
1347
1348
1349
1350
1351
1352
1353
1354
1355
1356
1357
1358
1359
1360
1361
1362
1363
1364
1365
1366
1367
1368
1369
1370
1371
1372
1373
1374
1375
1376
1377
1378
1379
1380
1381
1382
1383
1384
1385
1386
1387
1388
1389
1390
1391
1392
1393
1394
1395
1396
1397
1398
1399
1400
1401
1402
1403
1404
1405
1406
1407
1408
1409
1410
1411
1412
1413
1414
1415
1416
1417
1418
1419
1420
1421
1422
1423
1424
1425
1426
1427
1428
1429
1430
1431
1432
1433
1434
1435
1436
1437
1438
1439
1440
1441
1442
1443
1444
1445
1446
1447
1448
1449
1450
1451
1452
1453
1454
1455
1456
1457
1458
1459
1460
1461
1462
1463
1464
1465
1466
1467
1468
1469
1470
1471
1472
1473
1474
1475
1476
1477
1478
1479
1480
1481
1482
1483
1484
1485
1486
1487
1488
1489
1490
1491
1492
1493
1494
1495
1496
1497
1498
1499
1500
1501
1502
1503
1504
1505
1506
1507
1508
1509
1510
1511
1512
1513
1514
1515
1516
1517
1518
1519
1520
1521
1522
1523
1524
1525
1526
1527
1528
1529
1530
1531
1532
1533
1534
1535
1536
1537
1538
1539
1540
1541
1542
1543
1544
1545
1546
1547
1548
1549
1550
1551
1552
1553
1554
1555
1556
1557
1558
1559
1560
1561
1562
1563
1564
1565
1566
<!-- Generated by scripts/check-compatibility.py. Do not edit directly. -->
# API coverage

This page is generated from [`compat/pytorch_api.toml`](../compat/pytorch_api.toml) against PyTorch `v2.13.0` at commit `cf30153`, through `tch` `0.26.0`.
Each entry is independently scoped. Supported applies only to its written scope; row counts are not a compatibility score.

## Supported

### `autograd.surrogate`

- **PyTorch:** `torch.Tensor.detach`
- **RustTorch:** `rusttorch::autograd::with_surrogate_gradient`
- **Implementation:** RustTorch frontend backed by LibTorch
- **Pinned inventory:** 0 identities ([exact mapping](../compat/pytorch_inventory_map.toml)); disposition only, not a support claim.
- **Scope:** Algebraic custom-gradient composition for same-shape/dtype/device dense real tensors: exact detached forward value plus surrogate minus detached surrogate. The surrogate must be finite; its autograd graph supplies derivatives.
- **Pinned source:** [`torch/_tensor.py`](https://github.com/pytorch/pytorch/blob/cf30153/torch/_tensor.py)
- **Evidence:** [`tests/autograd.rs::surrogate_derivatives_preserve_forward_values_and_validate_boundaries`](../tests/autograd.rs)
- **Notes:** This is a Rust composition recipe over ordinary tensor operations, not Python autograd.Function registration, saved-tensor hooks, or native custom backward callbacks.

### `core.device`

- **PyTorch:** `torch.device`, `torch.cuda.is_available`, `torch.backends.mps.is_available`
- **RustTorch:** `rusttorch_core::Device`, `rusttorch_core::DeviceSpec`, `rusttorch_core::DeviceCapabilities`, `rusttorch_core::available_devices`, `rusttorch_core::resolve_device`, `rusttorch::Device`, `rusttorch::DeviceSpec`, `rusttorch::DeviceCapabilities`, `rusttorch::available_devices`, `rusttorch::resolve_device`
- **Implementation:** RustTorch frontend backed by LibTorch
- **Pinned inventory:** 3 identities ([exact mapping](../compat/pytorch_inventory_map.toml)); disposition only, not a support claim.
- **Scope:** CPU resolution, runtime-reported CUDA and MPS capability mapping, explicit unavailable-device errors, and CUDA-then-MPS-then-CPU automatic selection.
- **Pinned source:** [`torch/__init__.py`](https://github.com/pytorch/pytorch/blob/cf30153/torch/__init__.py)
- **Evidence:** [`tests/device.rs::cpu_resolves_explicitly`](../tests/device.rs), [`tests/device.rs::reported_capabilities_match_resolved_devices`](../tests/device.rs), [`tests/device.rs::unavailable_or_out_of_range_cuda_is_an_error`](../tests/device.rs), [`tests/device.rs::explicit_mps_is_resolved_or_rejected_without_fallback`](../tests/device.rs)
- **Notes:** rusttorch-core owns the direct surface and the rusttorch facade preserves it. Accelerator branches are conditional on the linked runtime; this row does not claim a CUDA or MPS pass on every host.

### `data.batched_fetch`

- **PyTorch:** `torch.utils.data.Dataset.__getitems__`, `torch.utils.data._utils.fetch._MapDatasetFetcher`
- **RustTorch:** `rusttorch_data::Dataset::get_batch`, `rusttorch_data::Dataset::get_batch_with_context`, `rusttorch::data::Dataset::get_batch`, `rusttorch::data::Dataset::get_batch_with_context`
- **Implementation:** Implemented by RustTorch
- **Pinned inventory:** 0 identities ([exact mapping](../compat/pytorch_inventory_map.toml)); disposition only, not a support claim.
- **Scope:** Source-compatible batched map-dataset fetch with an ordered per-index default, one Dataset::get\_batch call per DataLoader index batch, and an overridable context-aware hook for cooperative worker cancellation and deadlines; incorrect result cardinality is rejected before collation.
- **Pinned source:** [`torch/utils/data/_utils/fetch.py`](https://github.com/pytorch/pytorch/blob/cf30153/torch/utils/data/_utils/fetch.py)
- **Evidence:** [`crates/rusttorch-data/tests/datasets.rs::loader_uses_one_batched_fetch_per_index_batch`](../crates/rusttorch-data/tests/datasets.rs), [`crates/rusttorch-data/tests/datasets.rs::loader_preserves_errors_from_a_short_dropped_tail`](../crates/rusttorch-data/tests/datasets.rs), [`crates/rusttorch-data/tests/datasets.rs::loader_rejects_wrong_batched_fetch_cardinality_before_collation`](../crates/rusttorch-data/tests/datasets.rs), [`crates/rusttorch-data/tests/loader_builder.rs::wrong_batch_cardinality_is_typed_and_precedes_collation`](../crates/rusttorch-data/tests/loader_builder.rs), [`crates/rusttorch-data/tests/worker_lifecycle.rs::early_drop_wakes_context_aware_fetch_and_joins`](../crates/rusttorch-data/tests/worker_lifecycle.rs), [`crates/rusttorch-data/tests/worker_lifecycle.rs::timeout_is_per_next_yielded_once_and_cancels_late_results`](../crates/rusttorch-data/tests/worker_lifecycle.rs)
- **Notes:** Rust map indices are usize and do not reproduce Python negative indexing. The preserved borrowed loader path treats wrong cardinality as a trait-contract violation, while the owned loader returns LoaderError::InvalidBatchCardinality; ordinary dataset and collation failures remain recoverable.

### `data.batches`

- **PyTorch:** `torch.utils.data.IterableDataset`, `torch.utils.data.DataLoader`, `torch.utils.data.dataset.IterableDataset`
- **RustTorch:** `rusttorch_data::batches`, `rusttorch_data::batches_with_collate`, `rusttorch::data::batches`, `rusttorch::data::batches_with_collate`
- **Implementation:** Implemented by RustTorch
- **Pinned inventory:** 2 identities ([exact mapping](../compat/pytorch_inventory_map.toml)); disposition only, not a support claim.
- **Scope:** Single-threaded batching of ordinary fallible Rust iterators, with explicit nonzero batch size, drop-last behavior, identity Vec collation or fallible custom collation, and one-error-then-exhaust semantics.
- **Pinned source:** [`torch/utils/data/_utils/fetch.py`](https://github.com/pytorch/pytorch/blob/cf30153/torch/utils/data/_utils/fetch.py)
- **Evidence:** [`tests/data.rs::stream_batches_keep_a_short_tail`](../tests/data.rs), [`tests/data.rs::stream_batches_drop_a_short_tail`](../tests/data.rs), [`tests/data.rs::stream_batches_reject_zero_batch_size_with_a_structured_error`](../tests/data.rs), [`tests/data.rs::stream_batches_apply_fallible_collation`](../tests/data.rs), [`tests/data.rs::stream_batches_report_a_partial_drop_last_failure_once_then_exhaust`](../tests/data.rs), [`tests/data.rs::stream_batches_report_a_collation_failure_once_then_exhaust`](../tests/data.rs)
- **Notes:** rusttorch-data owns the direct surface and rusttorch::data preserves it. An ordinary Rust iterator is the streaming surface; RustTorch does not require an IterableDataset wrapper or claim Python multiprocessing behavior.

### `data.chain_dataset`

- **PyTorch:** `torch.utils.data.ChainDataset`, `torch.utils.data.dataset.ChainDataset`
- **RustTorch:** `rusttorch_data::chain_datasets`, `rusttorch::data::chain_datasets`
- **Implementation:** Implemented by RustTorch
- **Pinned inventory:** 2 identities ([exact mapping](../compat/pytorch_inventory_map.toml)); disposition only, not a support claim.
- **Scope:** Lazy sequential chaining for datasets or other Rust iterables through the standard IntoIterator flatten adapter, without custom buffering.
- **Pinned source:** [`torch/utils/data/dataset.py`](https://github.com/pytorch/pytorch/blob/cf30153/torch/utils/data/dataset.py)
- **Evidence:** [`crates/rusttorch-data/tests/datasets.rs::chain_datasets_is_the_standard_flattened_iterator`](../crates/rusttorch-data/tests/datasets.rs)
- **Notes:** RustTorch uses the standard typed iterator item in place of Python's dynamically typed dataset protocol.

### `data.concat_dataset`

- **PyTorch:** `torch.utils.data.ConcatDataset`, `torch.utils.data.dataset.ConcatDataset`
- **RustTorch:** `rusttorch_data::ConcatDataset`, `rusttorch::data::ConcatDataset`
- **Implementation:** Implemented by RustTorch
- **Pinned inventory:** 2 identities ([exact mapping](../compat/pytorch_inventory_map.toml)); disposition only, not a support claim.
- **Scope:** Nonempty concatenation of same-typed map datasets with checked cumulative sizes and binary-search global index routing.
- **Pinned source:** [`torch/utils/data/dataset.py`](https://github.com/pytorch/pytorch/blob/cf30153/torch/utils/data/dataset.py)
- **Evidence:** [`crates/rusttorch-data/tests/datasets.rs::concat_dataset_uses_global_indices_and_rejects_empty_input`](../crates/rusttorch-data/tests/datasets.rs)
- **Notes:** Indices are usize, so Python negative-index translation is intentionally absent; all children share one Rust sample and error type.

### `data.dataset`

- **PyTorch:** `torch.utils.data.Dataset`, `torch.utils.data.dataset.Dataset`
- **RustTorch:** `rusttorch_data::Dataset`, `rusttorch_data::DatasetSamples`, `rusttorch::data::Dataset`, `rusttorch::data::DatasetSamples`
- **Implementation:** Implemented by RustTorch
- **Pinned inventory:** 2 identities ([exact mapping](../compat/pytorch_inventory_map.toml)); disposition only, not a support claim.
- **Scope:** Finite map-style datasets with owned samples, fallible indexed access, length and empty queries, and a lazy borrowing iterator over samples in index order.
- **Pinned source:** [`torch/utils/data/dataset.py`](https://github.com/pytorch/pytorch/blob/cf30153/torch/utils/data/dataset.py)
- **Evidence:** [`tests/data.rs::dataset_default_is_empty_follows_len`](../tests/data.rs), [`tests/data.rs::dataset_samples_borrow_and_fetch_lazily_in_order`](../tests/data.rs)
- **Notes:** rusttorch-data owns the direct surface and rusttorch::data preserves it. DatasetSamples performs no dataset clone or precollection; format-specific decoding belongs in optional packages.

### `data.loader`

- **PyTorch:** `torch.utils.data.DataLoader`, `torch.utils.data.dataloader.DataLoader`
- **RustTorch:** `rusttorch_data::DataLoader`, `rusttorch_data::DataLoaderBuilder`, `rusttorch_data::OwnedDataLoader`, `rusttorch_data::LoaderIter`, `rusttorch_data::WorkerLoaderIter`, `rusttorch_data::SerialExecution`, `rusttorch_data::WorkerExecution`, `rusttorch_data::AutoBatch`, `rusttorch_data::ExplicitBatches`, `rusttorch_data::NoBatch`, `rusttorch_data::LoaderError`, `rusttorch_data::PipelineError`, `rusttorch::data::DataLoader`, `rusttorch::data::DataLoaderBuilder`, `rusttorch::data::OwnedDataLoader`, `rusttorch::data::LoaderIter`, `rusttorch::data::WorkerLoaderIter`, `rusttorch::data::SerialExecution`, `rusttorch::data::WorkerExecution`, `rusttorch::data::AutoBatch`, `rusttorch::data::ExplicitBatches`, `rusttorch::data::NoBatch`, `rusttorch::data::LoaderError`, `rusttorch::data::PipelineError`
- **Implementation:** Implemented by RustTorch
- **Pinned inventory:** 2 identities ([exact mapping](../compat/pytorch_inventory_map.toml)); disposition only, not a support claim.
- **Scope:** Preserved borrowed single-pass loading plus owned, fresh epoch-aware serial or bounded map-worker iteration with default or explicit typed collation, optional no-batch conversion, sampler or batch-source plans, optional exact length, checked batch cardinality, typed five-stage one-error-then-exhaust failures, deterministic transforms, ordered or completion-order delivery, cooperative per-next timeout, optional loader-owned persistent worker pools, and order-independent PyTorch argument exclusions.
- **Pinned source:** [`torch/utils/data/dataloader.py`](https://github.com/pytorch/pytorch/blob/cf30153/torch/utils/data/dataloader.py)
- **Evidence:** [`tests/data.rs::loader_keeps_a_short_tail`](../tests/data.rs), [`tests/data.rs::loader_drops_a_short_tail`](../tests/data.rs), [`tests/data.rs::loader_rejects_zero_batch_size_with_a_structured_error`](../tests/data.rs), [`tests/data.rs::loader_applies_fallible_collation`](../tests/data.rs), [`tests/data.rs::loader_moves_non_clone_samples_into_batches`](../tests/data.rs), [`tests/data.rs::loader_discards_a_partial_batch_on_dataset_failure_then_exhausts`](../tests/data.rs), [`tests/data.rs::loader_yields_a_collation_failure_once_then_exhausts`](../tests/data.rs), [`tests/data.rs::facade_exposes_the_owned_loader_builder`](../tests/data.rs), [`tests/data.rs::facade_reexports_task_transform_and_worker_context_contracts`](../tests/data.rs), [`crates/rusttorch-data/tests/current_api.rs::owned_loader_generic_defaults_remain_source_compatible`](../crates/rusttorch-data/tests/current_api.rs), [`crates/rusttorch-data/tests/loader_builder.rs::defaults_batch_scalars_and_fresh_iterations_restart`](../crates/rusttorch-data/tests/loader_builder.rs), [`crates/rusttorch-data/tests/loader_builder.rs::batching_controls_custom_sources_and_collators`](../crates/rusttorch-data/tests/loader_builder.rs), [`crates/rusttorch-data/tests/loader_builder.rs::no_batching_uses_default_and_custom_conversion`](../crates/rusttorch-data/tests/loader_builder.rs), [`crates/rusttorch-data/tests/loader_builder.rs::optional_lengths_never_gate_iteration`](../crates/rusttorch-data/tests/loader_builder.rs), [`crates/rusttorch-data/tests/loader_builder.rs::set_epoch_forwards_through_every_plan`](../crates/rusttorch-data/tests/loader_builder.rs), [`crates/rusttorch-data/tests/loader_builder.rs::pipeline_failures_remain_typed_and_terminate_iteration`](../crates/rusttorch-data/tests/loader_builder.rs), [`crates/rusttorch-data/tests/loader_builder.rs::conflicts_are_order_independent`](../crates/rusttorch-data/tests/loader_builder.rs), [`crates/rusttorch-data/tests/loader_builder.rs::batch_sampler_conflicts_do_not_require_discarded_operational_bounds`](../crates/rusttorch-data/tests/loader_builder.rs), [`crates/rusttorch-data/tests/loader_builder.rs::unallocatable_batch_size_is_a_typed_build_error_without_panicking`](../crates/rusttorch-data/tests/loader_builder.rs), [`crates/rusttorch-data/tests/transform.rs::every_serial_stage_keeps_its_concrete_error_and_metadata`](../crates/rusttorch-data/tests/transform.rs), [`crates/rusttorch-data/tests/transform.rs::every_pipeline_variant_preserves_the_standard_error_source_chain`](../crates/rusttorch-data/tests/transform.rs)
- **Notes:** rusttorch-data owns the direct loader and rusttorch::data preserves it. Owned loading defaults to batch size one, sequential sampling, zero workers, ordered output, no pinning, no timeout, and no persistence. Positive map workers share an Arc dataset, fetch and transform on bounded deterministic Rust-thread lanes, and collate only on the coordinator. Rust threads replace Python multiprocessing\_context, subprocesses, and pickling. Rust cannot force-cancel non-cooperative dataset or native calls, so iterator and owner drop wait for those calls before joining. Explicit stream workers are tracked separately in data.stream\_workers; byte-budget, pinning, and exact serial checkpoint details are tracked in data.loader.prefetch, data.loader.pinning, and data.loader.checkpoint.

### `data.loader.checkpoint_stream`

- **PyTorch:** `No PyTorch symbol (RustTorch stream checkpoint extension)`
- **RustTorch:** `rusttorch_data::CheckpointableSource`, `rusttorch_data::CheckpointSourceFactory`, `rusttorch_data::StreamLoaderState`, `rusttorch_data::StreamLaneState`, `rusttorch_data::StreamCheckpointConfiguration`, `rusttorch_data::StreamCheckpointBuildError`, `rusttorch_data::StreamDataLoaderBuilder::checkpointable`, `rusttorch_data::StreamDataLoaderBuilder::resume`, `rusttorch_data::ExactStreamDataLoader`, `rusttorch_data::ExactStreamLoaderIter::checkpoint`, `rusttorch::data::StreamLoaderState`
- **Implementation:** Implemented by RustTorch
- **Pinned inventory:** 0 identities ([exact mapping](../compat/pytorch_inventory_map.toml)); disposition only, not a support claim.
- **Scope:** RustTorch-native exact next-visible-batch replay for explicitly checkpointable sharded stream factories. Ordered shards emit strictly increasing global sequence IDs. A barrier cancels active reads, restores paired pre-attempt source/transform snapshots, drains unpublished records, and advances transport generation while retaining logical factory identity. Resume validates the envelope and all suspended source/transform/coordinator components before applying state. Original continuation, serde round trips, unequal/empty shards, global tail policy, terminal sources, and replay of advanced source/transform failures are covered.
- **Pinned source:** [`torch/utils/data/dataloader.py`](https://github.com/pytorch/pytorch/blob/cf30153/torch/utils/data/dataloader.py)
- **Evidence:** [`crates/rusttorch-data/tests/checkpoint_stream.rs::checkpoints_replay_every_boundary_and_original_continuation`](../crates/rusttorch-data/tests/checkpoint_stream.rs), [`crates/rusttorch-data/tests/checkpoint_stream.rs::resume_validation_is_atomic_and_static_rejection_precedes_callbacks`](../crates/rusttorch-data/tests/checkpoint_stream.rs), [`crates/rusttorch-data/tests/checkpoint_stream.rs::retained_source_gets_fresh_context_and_cancels_at_each_barrier_and_drop`](../crates/rusttorch-data/tests/checkpoint_stream.rs), [`crates/rusttorch-data/tests/checkpoint_stream.rs::active_transform_rolls_back_to_paired_pre_source_boundary`](../crates/rusttorch-data/tests/checkpoint_stream.rs), [`crates/rusttorch-data/tests/checkpoint_stream.rs::source_error_rolls_back_pre_attempt_and_preserves_error_chain`](../crates/rusttorch-data/tests/checkpoint_stream.rs), [`crates/rusttorch-data/tests/checkpoint_stream.rs::transform_failure_restores_paired_state_and_nonfused_end_replays`](../crates/rusttorch-data/tests/checkpoint_stream.rs), [`crates/rusttorch-data/tests/checkpoint_stream.rs::malformed_protocol_errors_once_and_ordinary_modes_stay_available`](../crates/rusttorch-data/tests/checkpoint_stream.rs), [`crates/rusttorch-data/tests/checkpoint_stream.rs::init_errors_and_panics_preserve_context_and_join`](../crates/rusttorch-data/tests/checkpoint_stream.rs), [`crates/rusttorch-data/tests/checkpoint_stream.rs::inline_snapshot_shapes_participate_in_aggregate_retention_limit`](../crates/rusttorch-data/tests/checkpoint_stream.rs), [`crates/rusttorch-data/tests/checkpoint_stream.rs::terminal_shards_do_not_hide_a_full_active_lane_with_a_gap`](../crates/rusttorch-data/tests/checkpoint_stream.rs), [`crates/rusttorch-data/tests/checkpoint_stream.rs::global_duplicate_and_state_configuration_drift_are_rejected`](../crates/rusttorch-data/tests/checkpoint_stream.rs), [`crates/rusttorch-data/tests/checkpoint_stream.rs::capacity_overflow_and_unsupported_settings_reject_before_workers`](../crates/rusttorch-data/tests/checkpoint_stream.rs), [`crates/rusttorch-data/tests/checkpoint_stream.rs::faster_later_failures_wait_for_lower_records_and_replay_in_order`](../crates/rusttorch-data/tests/checkpoint_stream.rs), [`crates/rusttorch-data/tests/checkpoint_stream.rs::source_failure_positions_obey_monotonic_and_bounded_gap_checks`](../crates/rusttorch-data/tests/checkpoint_stream.rs)
- **Notes:** This does not claim Python iterator-checkpoint parity. Exact streams require MemoryDisabled, NoWorkerInit, nonpersistent workers, and no timeout; ordinary stream defaults and generic auto-traits remain unchanged. Sources retaining context must implement set\_run\_context. Bounded journals retain at most prefetch\_factor + batch\_size + 1 entries per lane under the checked 64 MiB aggregate allocation ceiling; nested user-state heap contents are not a total-RSS bound. No samples are serialized or discarded records collated/pinned. Blocking callbacks remain cooperatively cancellable and drop joins. Persistence format and policy belong to the application.

### `data.random_split`

- **PyTorch:** `torch.utils.data.random_split`
- **RustTorch:** `rusttorch_data::SplitLength`, `rusttorch_data::random_split`, `rusttorch::data::SplitLength`, `rusttorch::data::random_split`
- **Implementation:** Implemented by RustTorch
- **Pinned inventory:** 0 identities ([exact mapping](../compat/pytorch_inventory_map.toml)); disposition only, not a support claim.
- **Scope:** Seeded non-overlapping splits from exact usize counts or finite fractions summing to one, with fractional floors and round-robin remainder distribution.
- **Pinned source:** [`torch/utils/data/dataset.py`](https://github.com/pytorch/pytorch/blob/cf30153/torch/utils/data/dataset.py)
- **Evidence:** [`crates/rusttorch-data/tests/datasets.rs::random_split_requires_integer_lengths_to_sum_to_dataset_length`](../crates/rusttorch-data/tests/datasets.rs), [`crates/rusttorch-data/tests/datasets.rs::random_split_floors_fractions_and_distributes_remainder_round_robin`](../crates/rusttorch-data/tests/datasets.rs), [`crates/rusttorch-data/tests/datasets.rs::random_split_rejects_fraction_floors_larger_than_the_dataset`](../crates/rusttorch-data/tests/datasets.rs), [`crates/rusttorch-data/tests/datasets.rs::random_split_is_deterministic_and_allows_zero_length_parts`](../crates/rusttorch-data/tests/datasets.rs)
- **Notes:** SplitLength is a typed Rust enum replacing Python's mixed numeric list, and produced subset indices are usize; the seeded ChaCha12 permutation is reproducible within RustTorch rather than claimed PyTorch RNG identity.

### `data.sampler`

- **PyTorch:** `torch.utils.data.Sampler`, `torch.utils.data.BatchSampler`, `torch.utils.data.SequentialSampler`, `torch.utils.data.RandomSampler`, `torch.utils.data.SubsetRandomSampler`, `torch.utils.data.WeightedRandomSampler`, `torch.utils.data.sampler.BatchSampler`, `torch.utils.data.sampler.RandomSampler`, `torch.utils.data.sampler.Sampler`, `torch.utils.data.sampler.SequentialSampler`, `torch.utils.data.sampler.SubsetRandomSampler`, `torch.utils.data.sampler.WeightedRandomSampler`
- **RustTorch:** `rusttorch_data::Sampler`, `rusttorch_data::BatchSource`, `rusttorch_data::FnSampler`, `rusttorch_data::FnBatchSource`, `rusttorch_data::BatchSampler`, `rusttorch_data::SequentialSampler`, `rusttorch_data::RandomSampler`, `rusttorch_data::SubsetRandomSampler`, `rusttorch_data::WeightedRandomSampler`, `rusttorch::data::Sampler`, `rusttorch::data::BatchSource`, `rusttorch::data::FnSampler`, `rusttorch::data::FnBatchSource`, `rusttorch::data::BatchSampler`, `rusttorch::data::SequentialSampler`, `rusttorch::data::RandomSampler`, `rusttorch::data::SubsetRandomSampler`, `rusttorch::data::WeightedRandomSampler`
- **Implementation:** Implemented by RustTorch
- **Pinned inventory:** 12 identities ([exact mapping](../compat/pytorch_inventory_map.toml)); disposition only, not a support claim.
- **Scope:** Fresh finite epoch-aware index and index-batch iterator contracts with optional exact lengths; direct fixed-size batching with explicit tail policy; direct sequential, seeded replacement and repeated-permutation random, subset, and weighted sampling; and sized or unsized closure factories. Caller-controlled storage dimensions fail with typed configuration errors rather than capacity-overflow panics. Weighted sampling validates positive sample count, nonempty finite nonnegative weights, positive finite total weight, replacement cardinality, and unique numerically stable positive-first selection with deterministic zero-weight fill without replacement.
- **Pinned source:** [`torch/utils/data/sampler.py`](https://github.com/pytorch/pytorch/blob/cf30153/torch/utils/data/sampler.py)
- **Evidence:** [`tests/data.rs::sequential_sampler_yields_every_index_in_order`](../tests/data.rs), [`tests/data.rs::random_sampler_is_seeded_and_yields_a_permutation`](../tests/data.rs), [`tests/data_libtorch.rs::random_sampler_does_not_change_libtorch_global_rng`](../tests/data_libtorch.rs), [`crates/rusttorch-data/tests/samplers.rs::random_sampler_preserves_the_empty_length_error_contract`](../crates/rusttorch-data/tests/samplers.rs), [`crates/rusttorch-data/tests/samplers.rs::random_sampler_with_replacement_is_seeded_and_bounded`](../crates/rusttorch-data/tests/samplers.rs), [`crates/rusttorch-data/tests/samplers.rs::random_sampler_without_replacement_repeats_complete_permutations`](../crates/rusttorch-data/tests/samplers.rs), [`crates/rusttorch-data/tests/samplers.rs::random_sampler_rejects_unrepresentable_storage_without_panicking`](../crates/rusttorch-data/tests/samplers.rs), [`crates/rusttorch-data/tests/samplers.rs::subset_random_sampler_yields_one_seeded_permutation`](../crates/rusttorch-data/tests/samplers.rs), [`crates/rusttorch-data/tests/samplers.rs::weighted_random_sampler_validates_inputs`](../crates/rusttorch-data/tests/samplers.rs), [`crates/rusttorch-data/tests/samplers.rs::weighted_random_sampler_with_replacement_is_deterministic_and_has_cardinality`](../crates/rusttorch-data/tests/samplers.rs), [`crates/rusttorch-data/tests/samplers.rs::weighted_random_sampler_rejects_unrepresentable_storage_without_panicking`](../crates/rusttorch-data/tests/samplers.rs), [`crates/rusttorch-data/tests/samplers.rs::weighted_random_sampler_without_replacement_is_unique_and_fills_zero_weights`](../crates/rusttorch-data/tests/samplers.rs), [`crates/rusttorch-data/tests/samplers.rs::weighted_random_sampler_keeps_equal_subnormal_weights_random`](../crates/rusttorch-data/tests/samplers.rs), [`crates/rusttorch-data/tests/samplers.rs::concrete_samplers_create_fresh_epoch_aware_iterators`](../crates/rusttorch-data/tests/samplers.rs), [`crates/rusttorch-data/tests/samplers.rs::subset_and_weighted_samplers_create_fresh_epoch_iterators`](../crates/rusttorch-data/tests/samplers.rs), [`crates/rusttorch-data/tests/samplers.rs::fn_sampler_factories_are_fresh_and_length_is_optional`](../crates/rusttorch-data/tests/samplers.rs), [`crates/rusttorch-data/tests/samplers.rs::fn_batch_source_factories_are_fresh_and_length_is_optional`](../crates/rusttorch-data/tests/samplers.rs), [`crates/rusttorch-data/tests/batch_sampler.rs::batch_sampler_keeps_or_drops_the_exact_tail`](../crates/rusttorch-data/tests/batch_sampler.rs), [`crates/rusttorch-data/tests/batch_sampler.rs::batch_sampler_accepts_a_one_shot_custom_iterator`](../crates/rusttorch-data/tests/batch_sampler.rs), [`crates/rusttorch-data/tests/batch_sampler.rs::batch_sampler_validates_public_storage_dimensions_without_panicking`](../crates/rusttorch-data/tests/batch_sampler.rs), [`crates/rusttorch-data/tests/batch_sampler.rs::batch_sampler_recreates_sized_sampler_iterations_and_forwards_epoch`](../crates/rusttorch-data/tests/batch_sampler.rs), [`crates/rusttorch-data/tests/batch_sampler.rs::batch_sampler_preserves_an_unsized_sampler_source`](../crates/rusttorch-data/tests/batch_sampler.rs), [`crates/rusttorch-data/tests/batch_sampler.rs::fn_batch_source_recreates_nonuniform_batches_for_each_epoch`](../crates/rusttorch-data/tests/batch_sampler.rs)
- **Notes:** rusttorch-data owns the direct samplers and rusttorch::data preserves them. Concrete samplers and BatchSampler over an iterator remain ordinary one-shot Iterator values for source compatibility, while Sampler and BatchSource create fresh iterators for owned-loader epochs. Randomness uses sampler-local ChaCha12 state and never LibTorch's global RNG; deterministic RustTorch seeds do not provide exact PyTorch Philox sequence parity.

### `data.sampler.distributed`

- **PyTorch:** `torch.utils.data.DistributedSampler`, `torch.utils.data.distributed.DistributedSampler`
- **RustTorch:** `rusttorch_data::DistributedSampler`, `rusttorch::data::DistributedSampler`
- **Implementation:** Implemented by RustTorch
- **Pinned inventory:** 1 identities ([exact mapping](../compat/pytorch_inventory_map.toml)); disposition only, not a support claim.
- **Scope:** Explicit replica/rank sharding over finite usize index ranges, with equal per-rank lengths, cyclic padding or global-tail truncation, deterministic epoch-aware optional shuffling, fresh reusable iterations, and direct-iterator position reporting. Empty datasets yield no indices on every valid rank, and invalid or unrepresentable dimensions return typed configuration errors.
- **Pinned source:** [`torch/utils/data/distributed.py`](https://github.com/pytorch/pytorch/blob/cf30153/torch/utils/data/distributed.py)
- **Evidence:** [`crates/rusttorch-data/tests/distributed_sampler.rs::distributed_sampler_cyclically_pads_equal_rank_lengths`](../crates/rusttorch-data/tests/distributed_sampler.rs), [`crates/rusttorch-data/tests/distributed_sampler.rs::distributed_sampler_truncates_to_disjoint_rank_strides`](../crates/rusttorch-data/tests/distributed_sampler.rs), [`crates/rusttorch-data/tests/distributed_sampler.rs::distributed_sampler_validates_replica_and_rank_configuration`](../crates/rusttorch-data/tests/distributed_sampler.rs), [`crates/rusttorch-data/tests/distributed_sampler.rs::distributed_sampler_rejects_unrepresentable_padding_and_storage_without_panicking`](../crates/rusttorch-data/tests/distributed_sampler.rs), [`crates/rusttorch-data/tests/distributed_sampler.rs::distributed_sampler_is_deterministic_per_epoch_and_creates_fresh_iterations`](../crates/rusttorch-data/tests/distributed_sampler.rs), [`crates/rusttorch-data/tests/distributed_sampler.rs::distributed_sampler_tracks_direct_iteration_position_and_resets_on_epoch`](../crates/rusttorch-data/tests/distributed_sampler.rs), [`crates/rusttorch-data/tests/distributed_sampler.rs::distributed_sampler_accepts_empty_datasets_for_every_valid_rank`](../crates/rusttorch-data/tests/distributed_sampler.rs), [`crates/rusttorch-data/tests/distributed_sampler.rs::distributed_sampler_does_not_change_libtorch_global_rng`](../crates/rusttorch-data/tests/distributed_sampler.rs)
- **Notes:** RustTorch requires explicit replica and rank values instead of consulting a process group. Shuffle uses sampler-local ChaCha12 state and never LibTorch's global RNG; deterministic RustTorch seeds do not claim exact PyTorch Philox sequence parity. Versioned distributed sampler configuration and active cursor state are proven for exact serial and ordered prefetched worker checkpoints in data.loader.checkpoint.

### `data.stack_dataset`

- **PyTorch:** `torch.utils.data.StackDataset`, `torch.utils.data.dataset.StackDataset`
- **RustTorch:** `rusttorch_data::StackDataset`, `rusttorch_data::StackTuple`, `rusttorch::data::StackDataset`, `rusttorch::data::StackTuple`
- **Implementation:** Implemented by RustTorch
- **Pinned inventory:** 2 identities ([exact mapping](../compat/pytorch_inventory_map.toml)); disposition only, not a support claim.
- **Scope:** Equal-length typed dataset tuples at arities two through eight, producing aligned sample tuples whose children share one error type.
- **Pinned source:** [`torch/utils/data/dataset.py`](https://github.com/pytorch/pytorch/blob/cf30153/torch/utils/data/dataset.py)
- **Evidence:** [`crates/rusttorch-data/tests/datasets.rs::stack_dataset_checks_lengths_and_returns_tuples`](../crates/rusttorch-data/tests/datasets.rs), [`crates/rusttorch-data/tests/datasets.rs::stack_dataset_supports_tuple_arities_two_through_eight`](../crates/rusttorch-data/tests/datasets.rs)
- **Notes:** Typed Rust tuples replace Python's positional tuple or string-keyed dictionary StackDataset forms; indices are usize and dictionary stacking is represented by an application-defined typed struct instead of dynamic keys.

### `data.subset`

- **PyTorch:** `torch.utils.data.Subset`, `torch.utils.data.dataset.Subset`
- **RustTorch:** `rusttorch_data::Subset`, `rusttorch::data::Subset`
- **Implementation:** Implemented by RustTorch
- **Pinned inventory:** 2 identities ([exact mapping](../compat/pytorch_inventory_map.toml)); disposition only, not a support claim.
- **Scope:** Validated selection of usize source indices with shared ownership available through blanket Dataset delegation for Arc&lt;D&gt;.
- **Pinned source:** [`torch/utils/data/dataset.py`](https://github.com/pytorch/pytorch/blob/cf30153/torch/utils/data/dataset.py)
- **Evidence:** [`crates/rusttorch-data/tests/datasets.rs::subset_validates_source_indices_and_arc_delegates_dataset`](../crates/rusttorch-data/tests/datasets.rs)
- **Notes:** Construction rejects out-of-range usize indices, so Python negative indexing is intentionally not reproduced.

### `data.tensor_dataset`

- **PyTorch:** `torch.utils.data.TensorDataset`, `torch.utils.data.dataset.TensorDataset`
- **RustTorch:** `rusttorch_data::TensorDataset`, `rusttorch::data::TensorDataset`
- **Implementation:** RustTorch frontend backed by LibTorch
- **Pinned inventory:** 2 identities ([exact mapping](../compat/pytorch_inventory_map.toml)); disposition only, not a support claim.
- **Scope:** Nonempty tensors with equal first dimensions and ordered Vec&lt;Tensor&gt; row samples whose ordinary indexed views share LibTorch storage with the source tensors.
- **Pinned source:** [`torch/utils/data/dataset.py`](https://github.com/pytorch/pytorch/blob/cf30153/torch/utils/data/dataset.py)
- **Evidence:** [`crates/rusttorch-data/tests/datasets.rs::tensor_dataset_returns_one_row_from_each_tensor`](../crates/rusttorch-data/tests/datasets.rs), [`crates/rusttorch-data/tests/datasets.rs::tensor_dataset_rejects_mismatched_first_dimensions`](../crates/rusttorch-data/tests/datasets.rs), [`crates/rusttorch-data/tests/datasets.rs::tensor_dataset_get_returns_storage_sharing_views`](../crates/rusttorch-data/tests/datasets.rs), [`crates/rusttorch-data/tests/datasets.rs::tensor_dataset_get_batch_returns_storage_sharing_views`](../crates/rusttorch-data/tests/datasets.rs)
- **Notes:** A typed Vec&lt;Tensor&gt; replaces Python's dynamically sized tuple, indices are usize, and storage-sharing mutation means this adapter is not automatically replay-safe.

### `graph.executor`

- **PyTorch:** `torch.fx.Interpreter`, `torch.fx.interpreter.Interpreter`
- **RustTorch:** `rusttorch::graph::EagerExecutor`, `rusttorch::graph::GraphModule`, `rusttorch::graph::GraphInputs`, `rusttorch::graph::GraphOutputs`
- **Implementation:** RustTorch frontend backed by LibTorch
- **Pinned inventory:** 2 identities ([exact mapping](../compat/pytorch_inventory_map.toml)); disposition only, not a support claim.
- **Scope:** Fallible eager execution of RustTorch typed graphs with named inputs and outputs, mode tracking, autograd, and runtime tensor-spec validation.
- **Pinned source:** [`torch/fx/interpreter.py`](https://github.com/pytorch/pytorch/blob/cf30153/torch/fx/interpreter.py)
- **Evidence:** [`tests/graph.rs::all_public_graph_operations_execute_with_expected_values`](../tests/graph.rs), [`tests/graph.rs::residual_branch_accumulates_input_and_all_linear_parameter_gradients`](../tests/graph.rs), [`tests/graph.rs::runtime_rejects_dtype_rank_and_known_dimension_mismatches`](../tests/graph.rs), [`tests/graph.rs::dropout_follows_train_and_eval_mode_without_rng_assumptions`](../tests/graph.rs)
- **Notes:** Execution delegates kernels to LibTorch and does not consume Python FX graphs.

### `graph.inspection`

- **PyTorch:** `torch.fx.Graph.print_tabular`, `torch.fx.Graph.__str__`
- **RustTorch:** `rusttorch::graph::Graph::summary`, `rusttorch::graph::Graph::to_dot`, `rusttorch::graph::GraphModule::summary`, `rusttorch::graph::GraphModule::to_dot`
- **Implementation:** Implemented by RustTorch
- **Pinned inventory:** 1 identities ([exact mapping](../compat/pytorch_inventory_map.toml)); disposition only, not a support claim.
- **Scope:** Deterministic textual summaries and DOT output for RustTorch graphs.
- **Pinned source:** [`torch/fx/graph.py`](https://github.com/pytorch/pytorch/blob/cf30153/torch/fx/graph.py)
- **Evidence:** [`tests/graph.rs::summary_and_dot_are_deterministic_and_describe_the_graph`](../tests/graph.rs)
- **Notes:** DOT generation returns text and does not invoke Graphviz.

### `graph.ops`

- **PyTorch:** `ATen identity, linear, relu, gelu, dropout, flatten, add, sub, mul, cat, mse_loss, and cross_entropy operations`
- **RustTorch:** `rusttorch::graph::GraphOp`, `rusttorch::graph::GraphBuilder`
- **Implementation:** RustTorch frontend backed by LibTorch
- **Pinned inventory:** 0 identities ([exact mapping](../compat/pytorch_inventory_map.toml)); disposition only, not a support claim.
- **Scope:** Exactly the enumerated graph operations, eager execution, current validation, and tested shape-propagation rules.
- **Pinned source:** [`torch/nn/functional.py`](https://github.com/pytorch/pytorch/blob/cf30153/torch/nn/functional.py)
- **Evidence:** [`tests/graph.rs::all_public_graph_operations_execute_with_expected_values`](../tests/graph.rs), [`tests/graph.rs::binary_shape_propagation_preserves_dimension_order`](../tests/graph.rs)
- **Notes:** Arbitrary ATen dispatch and unlisted operators are not included.

### `graph.passes`

- **PyTorch:** `torch.fx.passes`
- **RustTorch:** `rusttorch::graph::GraphPass`, `rusttorch::graph::Validation`, `rusttorch::graph::DeadNodeElimination`, `rusttorch::graph::ShapePropagation`, `rusttorch::graph::PassReport`
- **Implementation:** Implemented by RustTorch
- **Pinned inventory:** 1 identities ([exact mapping](../compat/pytorch_inventory_map.toml)); disposition only, not a support claim.
- **Scope:** Validation, dead-node deactivation, and the tested shape-propagation subset for RustTorch graphs.
- **Pinned source:** [`torch/fx/passes/__init__.py`](https://github.com/pytorch/pytorch/blob/cf30153/torch/fx/passes/__init__.py)
- **Evidence:** [`tests/graph.rs::finish_eliminates_dead_nodes_and_propagates_flatten_linear_shapes`](../tests/graph.rs)
- **Notes:** These passes operate on RustTorch graphs and do not accept arbitrary FX passes.

### `nn.flatten`

- **PyTorch:** `torch.nn.Flatten`, `torch.flatten`
- **RustTorch:** `rusttorch::nn::Flatten`, `rusttorch::nn::functional::flatten`
- **Implementation:** Delegated to LibTorch
- **Pinned inventory:** 1 identities ([exact mapping](../compat/pytorch_inventory_map.toml)); disposition only, not a support claim.
- **Scope:** Dimension-range flattening with Rust integer dimensions for the tested default and graph negative-end ranges.
- **Pinned source:** [`torch/nn/modules/flatten.py`](https://github.com/pytorch/pytorch/blob/cf30153/torch/nn/modules/flatten.py)
- **Evidence:** [`tests/eager.rs::identity_relu_gelu_and_flatten_match_expected_behavior`](../tests/eager.rs), [`tests/graph.rs::finish_eliminates_dead_nodes_and_propagates_flatten_linear_shapes`](../tests/graph.rs)
- **Notes:** Python dynamic argument coercion is not supported.

### `nn.identity`

- **PyTorch:** `torch.nn.Identity`, `torch.nn.modules.linear.Identity`
- **RustTorch:** `rusttorch::nn::Identity`
- **Implementation:** Delegated to LibTorch
- **Pinned inventory:** 2 identities ([exact mapping](../compat/pytorch_inventory_map.toml)); disposition only, not a support claim.
- **Scope:** Identity forward behavior on the tested eager tensor and graph path.
- **Pinned source:** [`torch/nn/modules/linear.py`](https://github.com/pytorch/pytorch/blob/cf30153/torch/nn/modules/linear.py)
- **Evidence:** [`tests/eager.rs::identity_relu_gelu_and_flatten_match_expected_behavior`](../tests/eager.rs), [`tests/graph.rs::all_public_graph_operations_execute_with_expected_values`](../tests/graph.rs)
- **Notes:** The Rust unit type does not accept arbitrary ignored Python arguments.

### `nn.linear`

- **PyTorch:** `torch.nn.Linear`, `torch.nn.functional.linear`, `torch.nn.modules.linear.Linear`
- **RustTorch:** `rusttorch::nn::Linear`, `rusttorch::nn::LinearConfig`, `rusttorch::nn::linear`, `rusttorch::nn::functional::linear`
- **Implementation:** RustTorch frontend backed by LibTorch
- **Pinned inventory:** 3 identities ([exact mapping](../compat/pytorch_inventory_map.toml)); disposition only, not a support claim.
- **Scope:** Biased and bias-free forward behavior, parameter shapes/names, gradients, deterministic values, the short constructor, and weight-before-bias initialization uniformly within +/-1/sqrt(in\_features), including zero-input-feature bias initialization.
- **Pinned source:** [`torch/nn/modules/linear.py`](https://github.com/pytorch/pytorch/blob/cf30153/torch/nn/modules/linear.py)
- **Evidence:** [`tests/eager.rs::linear_bias_and_no_bias_have_expected_shapes_and_values`](../tests/eager.rs), [`tests/eager.rs::gradients_flow_through_linear`](../tests/eager.rs), [`tests/eager.rs::short_linear_constructor_uses_bias`](../tests/eager.rs), [`tests/nn_layers.rs::invalid_parameter_dtype_returns_errors_without_poisoning_the_store`](../tests/nn_layers.rs), [`tests/nn_layers.rs::undefined_tensors_are_rejected_without_metadata_panics`](../tests/nn_layers.rs), [`tests/nn_layers.rs::linear_initialization_uses_fan_in_uniform_before_bias`](../tests/nn_layers.rs), [`tests/nn_sequence.rs::sequence_python_parity`](../tests/nn_sequence.rs), [`tests/nn_layers.rs::biased_linear_preserves_values_and_all_gradients_across_ranks_and_devices`](../tests/nn_layers.rs), [`tests/deployment.rs::portable_execution_matches_cpu_on_available_accelerators`](../tests/deployment.rs)
- **Notes:** Rust configuration replaces Python keyword arguments; kernels delegate to LibTorch. CPU standalone attention and transformer-layer fixtures exercise the seeded shared Linear initializer. This does not claim identical full Transformer initialization streams or every dtype/backend combination. RustTorch-owned MPS Float/Half/BFloat16 affine paths use separate matmul and bias addition to avoid the macOS 26 virtual-M1 fused-linear bias defect. Analytic values and input/weight/bias gradients cover vector, matrix, batched and strided inputs through functional/layer paths; portable execution also checks fixed classifier values and gradients. Raw native tensor methods and existing native artifacts retain runtime behavior.

### `nn.relu`

- **PyTorch:** `torch.nn.ReLU`, `torch.nn.functional.relu`, `torch.nn.modules.activation.ReLU`
- **RustTorch:** `rusttorch::nn::ReLU`, `rusttorch::nn::functional::relu`
- **Implementation:** Delegated to LibTorch
- **Pinned inventory:** 3 identities ([exact mapping](../compat/pytorch_inventory_map.toml)); disposition only, not a support claim.
- **Scope:** Out-of-place ReLU values on the tested eager and graph paths, including gradients in a composed residual graph.
- **Pinned source:** [`torch/nn/modules/activation.py`](https://github.com/pytorch/pytorch/blob/cf30153/torch/nn/modules/activation.py)
- **Evidence:** [`tests/eager.rs::identity_relu_gelu_and_flatten_match_expected_behavior`](../tests/eager.rs), [`tests/graph.rs::residual_branch_accumulates_input_and_all_linear_parameter_gradients`](../tests/graph.rs)
- **Notes:** In-place mutation is not exposed.

### `runtime.setup`

- **PyTorch:** `PyTorch binary backend selection`
- **RustTorch:** `rusttorch setup --backend auto`, `rusttorch setup --backend cpu`, `rusttorch setup --backend cuda-12.6`
- **Implementation:** Implemented by RustTorch
- **Pinned inventory:** 0 identities ([exact mapping](../compat/pytorch_inventory_map.toml)); disposition only, not a support claim.
- **Scope:** Project-local LibTorch selection for automatic, CPU or MPS, and CUDA 12.6 distributions with conflict and driver validation.
- **Pinned source:** [`torch/__init__.py`](https://github.com/pytorch/pytorch/blob/cf30153/torch/__init__.py)
- **Evidence:** [`crates/rusttorch-cli/src/main.rs::backend_parser_accepts_only_the_approved_names`](../crates/rusttorch-cli/src/main.rs), [`crates/rusttorch-cli/src/main.rs::preconfiguration_detects_every_supported_environment_variable`](../crates/rusttorch-cli/src/main.rs), [`crates/rusttorch-cli/src/main.rs::driver_parser_uses_the_first_output_line`](../crates/rusttorch-cli/src/main.rs), [`crates/rusttorch-cli/src/main.rs::auto_reuses_preconfiguration_and_selects_supported_acceleration`](../crates/rusttorch-cli/src/main.rs), [`crates/rusttorch-cli/src/main.rs::explicit_backend_refuses_active_preconfiguration`](../crates/rusttorch-cli/src/main.rs), [`crates/rusttorch-cli/src/main.rs::explicit_cuda_requires_a_supported_platform_and_driver`](../crates/rusttorch-cli/src/main.rs), [`crates/rusttorch-cli/src/main.rs::auto_falls_back_to_cpu_for_incompatible_drivers`](../crates/rusttorch-cli/src/main.rs), [`crates/rusttorch-cli/src/main.rs::configuration_preserves_unrelated_toml_and_writes_cuda_selection`](../crates/rusttorch-cli/src/main.rs), [`crates/rusttorch-cli/src/main.rs::configuration_switches_owned_cuda_selection_to_cpu`](../crates/rusttorch-cli/src/main.rs), [`crates/rusttorch-cli/src/main.rs::managed_setup_rejects_target_overrides_before_configuration_write`](../crates/rusttorch-cli/src/main.rs), [`crates/rusttorch-cli/src/main.rs::cargo_selectors_preserve_auto_and_reject_explicit_before_probe_or_write`](../crates/rusttorch-cli/src/main.rs), [`crates/rusttorch-cli/src/main.rs::cargo_selectors_cover_ancestors_home_legacy_and_every_runtime_variable`](../crates/rusttorch-cli/src/main.rs), [`crates/rusttorch-cli/src/main.rs::cargo_selectors_merge_tables_and_obey_process_force_precedence`](../crates/rusttorch-cli/src/main.rs), [`crates/rusttorch-cli/src/main.rs::cargo_owned_cuda_can_switch_but_cannot_hide_ancestor_runtime`](../crates/rusttorch-cli/src/main.rs), [`crates/rusttorch-cli/src/main.rs::cargo_unresolved_config_fails_closed_without_writes`](../crates/rusttorch-cli/src/main.rs), [`crates/rusttorch-cli/src/main.rs::cargo_build_script_confirms_effective_selector_resolution`](../crates/rusttorch-cli/src/main.rs)
- **Notes:** Setup resolves process and applicable workspace/ancestor/CARGO\_HOME selectors with Cargo legacy-file and env-table precedence before backend selection; managed CUDA ownership permits switching. Unresolvable includes, mixed entry types, and inactive user-owned CUDA entries fail closed. Setup invokes Cargo and the upstream downloader; it never installs or modifies system drivers.

## Partial

### `amp`

- **PyTorch:** `torch.amp.autocast`, `torch.amp.GradScaler`
- **RustTorch:** `rusttorch::amp::autocast`, `rusttorch::amp::autocast_for`, `rusttorch::amp::GradScaler`, `rusttorch::amp::GradScalerConfig`, `rusttorch::amp::GradScalerState`
- **Implementation:** RustTorch frontend backed by LibTorch
- **Pinned inventory:** 0 identities ([exact mapping](../compat/pytorch_inventory_map.toml)); disposition only, not a support claim.
- **Scope:** CPU-tested dense gradient scaling, accumulation, optional unscale and clipping, finite-update checks, skipped nonfinite updates, growth/backoff, disabled execution, validated step ordering, and versioned scaler state. The CUDA autocast scope exposes native nesting and unwind restoration with explicit device selection.
- **Pinned source:** [`torch/amp/autocast_mode.py`](https://github.com/pytorch/pytorch/blob/cf30153/torch/amp/autocast_mode.py)
- **Evidence:** [`tests/amp.rs::scaling_preserves_updates_skips_nonfinite_steps_and_replays_state`](../tests/amp.rs), [`tests/amp.rs::scaler_enforces_step_order_and_validates_before_restore`](../tests/amp.rs), [`tests/amp.rs::scaler_supports_accumulation_clipping_and_disabled_execution`](../tests/amp.rs), [`tests/amp.rs::autocast_preserves_results_and_strict_device_policy`](../tests/amp.rs), [`tests/amp.rs::grad_scaler_matches_python_growth_backoff_and_updates`](../tests/amp.rs), [`tests/amp.rs::cuda_autocast_restores_dtype_after_nesting_and_unwind`](../tests/amp.rs)
- **Notes:** Numerical scaler evidence is CPU only; torch/amp/grad\_scaler.py supplies the pinned scaling reference. The CUDA test explicitly skips without CUDA and is not a verified CUDA pass here. CPU/BFloat16 and MPS autocast policies, dtype/cache selection, sparse scaling, multi-optimizer cycles, and every upstream scale-extreme behavior are not claimed. Rust scale bounds prevent zero/infinite stored multipliers. Python parity requires scripts/run-python-parity.sh.

### `audio`

- **PyTorch:** `torch.utils.data.Dataset for audio samples`
- **RustTorch:** `rusttorch::audio::Waveform`, `rusttorch::audio::decode_audio`, `rusttorch::audio::AudioFiles`, `rusttorch::audio::PadAudio`, `rusttorch::audio::SpectrogramConfig`, `rusttorch::audio::mel_filter_bank`, `rusttorch::audio::mask_axis`
- **Implementation:** RustTorch frontend backed by LibTorch
- **Pinned inventory:** 0 identities ([exact mapping](../compat/pytorch_inventory_map.toml)); disposition only, not a support claim.
- **Scope:** Optional rusttorch-audio CPU WAV/PCM and FLAC decoding, typed waveform rate/layout/time metadata, bounded worker loading and variable-length collation, Rubato sinc resampling, gain/noise/mixing/time shift, differentiable uncentered STFT power spectra, HTK triangular Mel features, natural-log orthonormal MFCCs and deterministic axis masking.
- **Pinned source:** [`torch/utils/data/dataset.py`](https://github.com/pytorch/pytorch/blob/cf30153/torch/utils/data/dataset.py)
- **Evidence:** [`crates/rusttorch-audio/tests/pipelines.rs::wav_decode_workers_and_padding_preserve_rates_and_lengths`](../crates/rusttorch-audio/tests/pipelines.rs), [`crates/rusttorch-audio/tests/pipelines.rs::spectral_features_retain_gradients_and_known_sine_peak`](../crates/rusttorch-audio/tests/pipelines.rs), [`crates/rusttorch-audio/tests/pipelines.rs::resampling_gain_shift_and_masks_have_explicit_behavior`](../crates/rusttorch-audio/tests/pipelines.rs), [`crates/rusttorch-audio/tests/pipelines.rs::audio_boundaries_reject_rate_shape_and_oversize`](../crates/rusttorch-audio/tests/pipelines.rs), [`crates/rusttorch-audio/tests/pipelines.rs::spectral_values_and_gradients_match_pinned_python`](../crates/rusttorch-audio/tests/pipelines.rs), [`crates/rusttorch-audio/tests/pipelines.rs::flac_decodes_the_same_samples_as_pcm_wav`](../crates/rusttorch-audio/tests/pipelines.rs), [`crates/rusttorch-audio/tests/pipelines.rs::mel_expansion_checks_output_shape_before_projection`](../crates/rusttorch-audio/tests/pipelines.rs), [`crates/rusttorch-audio/tests/pipelines.rs::padded_audio_limits_cover_records_duration_masks_and_lengths`](../crates/rusttorch-audio/tests/pipelines.rs), [`crates/rusttorch-audio/tests/pipelines.rs::audio_noise_and_downsampling_bound_host_payload_before_allocation`](../crates/rusttorch-audio/tests/pipelines.rs)
- **Notes:** The Dataset reference records typed DataLoader integration, not torchaudio equivalence. STFT, Mel, MFCC values and input gradients match the pinned CPU Python fixture via crates/rusttorch-audio/tests/generate\_reference.py --check. CPU resampling rejects gradient-tracked inputs; callers must detach explicitly. Mel uses the documented HTK/no-area-normalization convention; centered padding, dB MFCC, pitch/time stretching, all codecs and accelerator evidence are not claimed.

### `autograd.functional`

- **PyTorch:** `torch.autograd.grad`, `torch.autograd.functional.vjp`, `torch.autograd.functional.jvp`, `torch.autograd.functional.jacobian`, `torch.autograd.functional.hessian`
- **RustTorch:** `rusttorch::autograd::GradOptions`, `rusttorch::autograd::grad`, `rusttorch::autograd::vjp`, `rusttorch::autograd::jvp`, `rusttorch::autograd::jacobian`, `rusttorch::autograd::hessian`
- **Implementation:** RustTorch frontend backed by LibTorch
- **Pinned inventory:** 5 identities ([exact mapping](../compat/pytorch_inventory_map.toml)); disposition only, not a support claim.
- **Scope:** Dense real single-input functional derivatives: scalar gradients without leaf-buffer accumulation; fixed-cotangent VJP; reverse-over-reverse JVP; Jacobians shaped output-shape plus input-shape; scalar Hessians and optional higher-order graphs. Constant/unused functional inputs produce zero derivatives, while direct grad rejects disconnected inputs.
- **Pinned source:** [`torch/autograd/functional.py`](https://github.com/pytorch/pytorch/blob/cf30153/torch/autograd/functional.py)
- **Evidence:** [`tests/autograd.rs::gradients_preserve_leaf_buffers_and_support_higher_orders`](../tests/autograd.rs), [`tests/autograd.rs::vector_products_and_jacobian_hessian_match_analytic_derivatives`](../tests/autograd.rs), [`tests/autograd.rs::constant_unused_empty_and_multidimensional_derivatives_are_defined`](../tests/autograd.rs), [`tests/autograd.rs::functional_derivatives_match_pinned_python`](../tests/autograd.rs)
- **Notes:** CPU Double numerical parity uses scripts/run-python-parity.sh. No native dual tensors, vectorized transforms, complex differentiation, batched gradients, or arbitrary custom Function hooks. Jacobians use one backward pass per output element; JVP requires native double-backward support. Tangent/cotangent seeds are detached. Native operation errors propagate.

### `autograd.reverse_mode`

- **PyTorch:** `torch.Tensor.backward`, `torch.no_grad`, `torch.Tensor.detach`, `torch.autograd.grad_mode.no_grad`
- **RustTorch:** `rusttorch_core::Tensor`, `rusttorch_core::no_grad`, `rusttorch_core::no_grad_guard`, `rusttorch::Tensor`, `rusttorch::no_grad`, `rusttorch::no_grad_guard`
- **Implementation:** Delegated to LibTorch
- **Pinned inventory:** 4 identities ([exact mapping](../compat/pytorch_inventory_map.toml)); disposition only, not a support claim.
- **Scope:** Reverse-mode gradients through the tested eager and graph operations, plus tested no-grad and detach behavior.
- **Pinned source:** [`torch/autograd/__init__.py`](https://github.com/pytorch/pytorch/blob/cf30153/torch/autograd/__init__.py)
- **Evidence:** [`tests/eager.rs::gradients_accumulate_across_eager_residual_branches`](../tests/eager.rs), [`tests/eager.rs::no_grad_and_detach_stop_gradient_recording`](../tests/eager.rs)
- **Notes:** rusttorch-core owns these direct reexports and the rusttorch facade preserves them; LibTorch owns autograd, while hooks, custom Function, forward AD, and the rest of the Python surface remain outside this claim.

### `codec`

- **PyTorch:** `torch.utils.data.Dataset for encoded media`
- **RustTorch:** `rusttorch::vision::decode_image`, `rusttorch::audio::decode_audio`, `rusttorch::codec::MediaDecoder`, `rusttorch::codec::MediaFrame`
- **Implementation:** RustTorch frontend backed by LibTorch
- **Pinned inventory:** 0 identities ([exact mapping](../compat/pytorch_inventory_map.toml)); disposition only, not a support claim.
- **Scope:** Optional domain packages decode bounded local PNG/JPEG images, WAV/PCM and FLAC audio, and selected FFmpeg CPU audio/video streams into owned typed samples for the shared Dataset and fallible-iterator batching interfaces.
- **Pinned source:** [`torch/utils/data/dataset.py`](https://github.com/pytorch/pytorch/blob/cf30153/torch/utils/data/dataset.py)
- **Evidence:** [`crates/rusttorch-vision/tests/pipelines.rs::imagefolder_workers_decode_classify_and_bound_payload`](../crates/rusttorch-vision/tests/pipelines.rs), [`crates/rusttorch-audio/tests/pipelines.rs::wav_decode_workers_and_padding_preserve_rates_and_lengths`](../crates/rusttorch-audio/tests/pipelines.rs), [`crates/rusttorch-audio/tests/pipelines.rs::flac_decodes_the_same_samples_as_pcm_wav`](../crates/rusttorch-audio/tests/pipelines.rs), [`crates/rusttorch-codec/tests/pipelines.rs::cpu_video_streams_batches_and_seeks_with_timestamps`](../crates/rusttorch-codec/tests/pipelines.rs), [`crates/rusttorch-codec/tests/pipelines.rs::native_audio_copies_checked_float_buffers`](../crates/rusttorch-codec/tests/pipelines.rs)
- **Notes:** Umbrella decoding integration row; vision, audio and video specify the exact format, transform and native-backend contracts. Core/data remain format-agnostic and decoding dependencies are opt-in. No universal codec registry, implicit downloads, hardware decoding or full external media-library parity. Native FFmpeg availability and licensing follow the explicitly selected system/vcpkg build.

### `compiler.export.interop`

- **PyTorch:** `torch.export.save`, `torch.export.load`
- **RustTorch:** `rusttorch::deployment::Model::load_pt2`, `rusttorch::deployment::Model::save_pt2`, `rusttorch::deployment::Model::run`
- **Implementation:** RustTorch frontend backed by LibTorch
- **Pinned inventory:** 2 identities ([exact mapping](../compat/pytorch_inventory_map.toml)); disposition only, not a support claim.
- **Scope:** Bounded CPU PT2 archive0/serialization6/export-schema8.20/ATen10/tree1 import and export for the documented functional operator subset, Float/Double/Int64/Bool tensor state, named parameters/buffers/constants, shared non-overlapping storage views, tensor calling trees and named dimension range/equality guards. CPU Float numerical round trips use the pinned exporter loader at batch2/3/8 and compare input and parameter gradients; all four dtypes have native round-trip evidence.
- **Pinned source:** [`torch/export/__init__.py`](https://github.com/pytorch/pytorch/blob/cf30153/torch/export/__init__.py)
- **Evidence:** [`tests/deployment.rs::python_pt2_onnx_and_torchscript_numerical_round_trips`](../tests/deployment.rs), [`tests/deployment.rs::pt2_and_onnx_native_round_trips_preserve_values_and_guards`](../tests/deployment.rs), [`tests/deployment.rs::state_aliases_survive_json_and_pt2_with_bounded_views`](../tests/deployment.rs), [`tests/deployment.rs::tied_parameters_keep_one_gradient_leaf_and_symbol_guards_agree`](../tests/deployment.rs), [`tests/deployment.rs::pt2_rejects_versions_pickle_mutation_truncated_storage_and_unsafe_paths`](../tests/deployment.rs), [`tests/deployment.rs::all_portable_dtypes_and_operator_shapes_round_trip`](../tests/deployment.rs)
- **Notes:** Pinned sources also include torch/\_export/serde/{schema,serialize}.py, torch/export/pt2\_archive/\_package.py and torch/csrc/export/pt2\_archive\_constants.h. No Python capture, pickle, subclass/custom-object payloads, mutation, higher-order control flow, executable guard code, arbitrary symbolic expressions or AOTInductor binaries. State shared across weights/constants directories and internally overlapping state views are rejected. Interchange graphs execute eagerly through LibTorch; export shape rules are algebraic, not sampled compilation.

### `core.random`

- **PyTorch:** `torch.manual_seed`, `torch.random.manual_seed`
- **RustTorch:** `rusttorch_core::manual_seed`, `rusttorch::manual_seed`
- **Implementation:** Delegated to LibTorch
- **Pinned inventory:** 2 identities ([exact mapping](../compat/pytorch_inventory_map.toml)); disposition only, not a support claim.
- **Scope:** LibTorch seed delegation with CPU parity evidence for the tested convolution, embedding, transposed-convolution, recurrent, standalone attention and transformer-layer initializations; shared Linear initialization is exercised by those standalone sequence fixtures.
- **Pinned source:** [`torch/random.py`](https://github.com/pytorch/pytorch/blob/cf30153/torch/random.py)
- **Evidence:** [`tests/python_parity.rs::bidirectional_python_parity`](../tests/python_parity.rs), [`tests/nn_spatial.rs::spatial_layers_match_pinned_python_outputs_gradients_and_buffers`](../tests/nn_spatial.rs), [`tests/nn_sequence.rs::sequence_python_parity`](../tests/nn_sequence.rs)
- **Notes:** rusttorch-core owns the function and rusttorch preserves it. Seeded fixtures run through scripts/run-python-parity.sh. These checks do not establish universal generator state, deterministic algorithms, or cross-backend stream identity. Full Transformer construction has a different allocation/random-consumption sequence; its loaded-state numerical parity does not imply identical initial weights for the same seed.

### `core.tensor`

- **PyTorch:** `torch.Tensor`, `torch.dtype`, `torch.nn.functional reduction`
- **RustTorch:** `rusttorch_core::Tensor`, `rusttorch_core::Kind`, `rusttorch_core::Reduction`, `rusttorch::Tensor`, `rusttorch::Kind`, `rusttorch::Reduction`
- **Implementation:** Delegated to LibTorch
- **Pinned inventory:** 2 identities ([exact mapping](../compat/pytorch_inventory_map.toml)); disposition only, not a support claim.
- **Scope:** Root type reexports plus the tensor construction, dtype, device, and eager operations exercised by current RustTorch tests.
- **Pinned source:** [`torch/_tensor.py`](https://github.com/pytorch/pytorch/blob/cf30153/torch/_tensor.py)
- **Evidence:** [`tests/eager.rs::tensor_core_types_are_reexported`](../tests/eager.rs)
- **Notes:** rusttorch-core owns the direct reexports and rusttorch preserves them. Reexporting tch::Tensor does not establish every method as compatible. Checked indexing, storage/view semantics, conversion/reductions and quantized primitives have separate scoped rows; advanced numerical families have their own rows.

### `core.tensor.conversion_reductions`

- **PyTorch:** `torch.Tensor.to`, `torch.mean`, `torch.std`, `torch.clamp`
- **RustTorch:** `rusttorch::tensor::standardize`, `rusttorch::Tensor::f_to_kind`, `rusttorch::Tensor::f_to_device`, `rusttorch::Tensor::f_mean`, `rusttorch::Tensor::f_std_dim`
- **Implementation:** RustTorch frontend backed by LibTorch
- **Pinned inventory:** 4 identities ([exact mapping](../compat/pytorch_inventory_map.toml)); disposition only, not a support claim.
- **Scope:** CPU-tested explicit integer-to-float conversion and population-standard-deviation feature normalization along a validated positive/negative axis: (x-mean)/max(std,epsilon), retained reduction dimensions, epsilon that remains finite and positive in the input dtype, constant features producing zero, empty reduction rejection and float32/float64 inputs.
- **Pinned source:** [`aten/src/ATen/native/native_functions.yaml`](https://github.com/pytorch/pytorch/blob/cf30153/aten/src/ATen/native/native_functions.yaml)
- **Evidence:** [`tests/tensor_workflows.rs::views_copies_broadcasts_and_standardization`](../tests/tensor_workflows.rs), [`tests/tensor_workflows.rs::empty_nested_and_copy_gradient_boundaries`](../tests/tensor_workflows.rs), [`tests/tensor_workflows.rs::malformed_inputs_return_errors_without_mutation`](../tests/tensor_workflows.rs), [`tests/tensor_workflows.rs::tensor_workflows_python_parity`](../tests/tensor_workflows.rs)
- **Notes:** The native same-device CPU conversion is exercised in the executable tutorial; this is not accelerator transfer evidence or every reduction, accumulation dtype, correction, NaN policy or conversion mode. Population variance uses correction=0. Integer conversion cannot preserve floating gradients.

### `core.tensor.indexing`

- **PyTorch:** `torch.index_select`, `torch.gather`, `torch.index_add`, `torch.where`
- **RustTorch:** `rusttorch::tensor::select_rows`, `rusttorch::tensor::gather_rows`, `rusttorch::tensor::scatter_add_rows`, `rusttorch::tensor::replace_masked`
- **Implementation:** RustTorch frontend backed by LibTorch
- **Pinned inventory:** 4 identities ([exact mapping](../compat/pytorch_inventory_map.toml)); disposition only, not a support claim.
- **Scope:** CPU-tested out-of-place row selection, one class per matrix row, additive aggregation of repeated row IDs, and exact-shape Boolean masked replacement. IDs are int64, nonnegative, in bounds and on the input device; helper-specific shapes and kinds are validated. Native selected-input gradients accumulate across repeated indices; empty row selections and empty aggregation are tested.
- **Pinned source:** [`aten/src/ATen/native/native_functions.yaml`](https://github.com/pytorch/pytorch/blob/cf30153/aten/src/ATen/native/native_functions.yaml)
- **Evidence:** [`tests/tensor_workflows.rs::indexing_updates_preserve_inputs_and_accumulate_gradients`](../tests/tensor_workflows.rs), [`tests/tensor_workflows.rs::malformed_inputs_return_errors_without_mutation`](../tests/tensor_workflows.rs), [`tests/tensor_workflows.rs::empty_nested_and_copy_gradient_boundaries`](../tests/tensor_workflows.rs), [`tests/tensor_workflows.rs::tensor_workflows_python_parity`](../tests/tensor_workflows.rs)
- **Notes:** Task-oriented helpers use native index\_select/gather/index\_add/where. This is not every indexing mode, Python negative indexing, assignment syntax or advanced-index broadcasting. Native f\_\* methods remain available; accelerator reductions retain native nondeterminism. Python parity runs through scripts/run-python-parity.sh.

### `core.tensor.quantization`

- **PyTorch:** `torch.quantize_per_tensor`, `torch.Tensor.dequantize`, `torch.Tensor.int_repr`
- **RustTorch:** `rusttorch::tensor::quantize_per_tensor`, `rusttorch::Tensor::f_dequantize`, `rusttorch::Tensor::f_int_repr`
- **Implementation:** RustTorch frontend backed by LibTorch
- **Pinned inventory:** 3 identities ([exact mapping](../compat/pytorch_inventory_map.toml)); disposition only, not a support claim.
- **Scope:** CPU per-tensor affine quantization of finite detached float32 input to QInt8 or QUInt8 with scale that remains finite and positive after float32 conversion and a representable zero point. Signed 8-bit values, tie rounding, saturation, integer representation and dequantization are numerically tested.
- **Pinned source:** [`aten/src/ATen/native/native_functions.yaml`](https://github.com/pytorch/pytorch/blob/cf30153/aten/src/ATen/native/native_functions.yaml)
- **Evidence:** [`tests/tensor_workflows.rs::sparse_coo_csr_and_quantized_boundaries`](../tests/tensor_workflows.rs), [`tests/tensor_workflows.rs::malformed_inputs_return_errors_without_mutation`](../tests/tensor_workflows.rs), [`tests/tensor_workflows.rs::tensor_workflows_python_parity`](../tests/tensor_workflows.rs)
- **Notes:** Pinned PyTorch 2.13 deprecates these legacy quantized tensor constructors. Requires-grad inputs are rejected instead of silently disconnecting gradients. QUInt8 parameter validation is tested; no full unsigned numerical fixture, model conversion, observers, calibration algorithms, quantized operators or quantization-aware training is claimed. torch.ao.quantization remains planned separately.

### `core.tensor.views`

- **PyTorch:** `torch.Tensor.view`, `torch.reshape`, `torch.transpose`, `torch.Tensor.expand`, `torch.view_copy`
- **RustTorch:** `rusttorch::tensor::flatten_features`, `rusttorch::Tensor::f_view`, `rusttorch::Tensor::f_reshape`, `rusttorch::Tensor::f_transpose`, `rusttorch::Tensor::f_expand`, `rusttorch::Tensor::f_view_copy`
- **Implementation:** RustTorch frontend backed by LibTorch
- **Pinned inventory:** 5 identities ([exact mapping](../compat/pytorch_inventory_map.toml)); disposition only, not a support claim.
- **Scope:** CPU-tested batch-feature flattening with explicit shared-view or always-independent-copy storage, noncontiguous view rejection/copy success, empty batches, copy gradients, transpose layout and zero-stride broadcasting. Native reshape may alias or copy; helper copy=true always allocates.
- **Pinned source:** [`aten/src/ATen/native/native_functions.yaml`](https://github.com/pytorch/pytorch/blob/cf30153/aten/src/ATen/native/native_functions.yaml)
- **Evidence:** [`tests/tensor_workflows.rs::views_copies_broadcasts_and_standardization`](../tests/tensor_workflows.rs), [`tests/tensor_workflows.rs::empty_nested_and_copy_gradient_boundaries`](../tests/tensor_workflows.rs), [`tests/tensor_workflows.rs::tensor_workflows_python_parity`](../tests/tensor_workflows.rs)
- **Notes:** The helper requires at least a batch and feature axis; feature-count overflow and undefined/unsupported nested metadata return errors. Mutation through a view changes its source; expanded repeated storage should not be mutated. Arbitrary memory formats and overlapping-stride construction are not covered.

### `data.collation`

- **PyTorch:** `torch.utils.data.default_collate`, `torch.utils.data.default_convert`, `torch.utils.data._utils.collate.collate`
- **RustTorch:** `rusttorch_data::Collate`, `rusttorch_data::VecCollate`, `rusttorch_data::FnCollate`, `rusttorch_data::DefaultCollator`, `rusttorch_data::DefaultCollate`, `rusttorch_data::DefaultConverter`, `rusttorch_data::DefaultConvert`, `rusttorch_data::Bytes`, `rusttorch_data::CollateError`, `rusttorch::data::Collate`, `rusttorch::data::VecCollate`, `rusttorch::data::FnCollate`, `rusttorch::data::DefaultCollator`, `rusttorch::data::DefaultCollate`, `rusttorch::data::DefaultConverter`, `rusttorch::data::DefaultConvert`, `rusttorch::data::Bytes`, `rusttorch::data::CollateError`
- **Implementation:** RustTorch frontend backed by LibTorch
- **Pinned inventory:** 3 identities ([exact mapping](../compat/pytorch_inventory_map.toml)); disposition only, not a support claim.
- **Scope:** Typed Rust collation stacks tensors on dimension zero, creates exact-kind tensors from supported Rust scalars, preserves strings and Bytes records, and recursively collates uniform options, equal-length vectors, tuples of arity two through eight, and BTreeMap values with identical keys. Typed no-batching conversion preserves leaves and recursively converts those containers without vector transposition. VecCollate and fallible FnCollate provide explicit escape hatches.
- **Pinned source:** [`torch/utils/data/_utils/collate.py`](https://github.com/pytorch/pytorch/blob/cf30153/torch/utils/data/_utils/collate.py)
- **Evidence:** [`crates/rusttorch-data/tests/collate.rs::tensors_stack_on_a_new_leading_dimension`](../crates/rusttorch-data/tests/collate.rs), [`crates/rusttorch-data/tests/collate.rs::numeric_scalars_use_their_exact_libtorch_kinds`](../crates/rusttorch-data/tests/collate.rs), [`crates/rusttorch-data/tests/collate.rs::strings_and_bytes_remain_records`](../crates/rusttorch-data/tests/collate.rs), [`crates/rusttorch-data/tests/collate.rs::tuples_collate_each_field_through_arity_eight`](../crates/rusttorch-data/tests/collate.rs), [`crates/rusttorch-data/tests/collate.rs::equal_vectors_transpose_before_recursive_collation`](../crates/rusttorch-data/tests/collate.rs), [`crates/rusttorch-data/tests/collate.rs::mismatched_vector_lengths_are_typed_errors`](../crates/rusttorch-data/tests/collate.rs), [`crates/rusttorch-data/tests/collate.rs::options_require_uniform_presence_and_recurse`](../crates/rusttorch-data/tests/collate.rs), [`crates/rusttorch-data/tests/collate.rs::maps_require_identical_keys_and_recurse_over_values`](../crates/rusttorch-data/tests/collate.rs), [`crates/rusttorch-data/tests/collate.rs::empty_batches_and_incompatible_tensors_return_errors`](../crates/rusttorch-data/tests/collate.rs), [`crates/rusttorch-data/tests/collate.rs::default_converter_preserves_leaves_and_recurses_without_transposing`](../crates/rusttorch-data/tests/collate.rs), [`crates/rusttorch-data/tests/collate.rs::default_converter_collate_requires_exactly_one_sample`](../crates/rusttorch-data/tests/collate.rs), [`crates/rusttorch-data/tests/collate.rs::custom_and_vector_collators_are_explicit_escape_hatches`](../crates/rusttorch-data/tests/collate.rs), [`tests/data.rs::facade_reexports_typed_collation_contracts`](../tests/data.rs)
- **Notes:** RustTorch uses associated Rust types and a Bytes newtype instead of Python's runtime type registry. It does not support NumPy arrays/scalars, Python mappings/sequences/namedtuples, mutable registry extension, dynamic coercion between unrelated Rust types, or every Python scalar type. Tensor construction and stacking delegate fallibly to LibTorch; structural mismatches and checked allocation boundaries return non-exhaustive CollateError variants.

### `data.dataset.datapipes`

- **PyTorch:** `torch.utils.data.DataChunk`, `torch.utils.data.DFIterDataPipe`, `torch.utils.data.IterDataPipe`, `torch.utils.data.MapDataPipe`
- **RustTorch:** `std::iter::Iterator`, `rusttorch_data::Dataset`, `rusttorch_data::WorkerSourceFactory`, `rusttorch_data::Transform`, `rusttorch::data::Dataset`, `rusttorch::data::WorkerSourceFactory`, `rusttorch::data::Transform`
- **Implementation:** Implemented by RustTorch
- **Pinned inventory:** 0 identities ([exact mapping](../compat/pytorch_inventory_map.toml)); disposition only, not a support claim.
- **Scope:** Ordinary typed Rust iterators replace basic iterable DataPipe traversal, Dataset replaces indexed MapDataPipe access, WorkerSourceFactory creates independent sharded iterators, and Transform composes typed sample operations.
- **Pinned source:** [`torch/utils/data/datapipes/datapipe.py`](https://github.com/pytorch/pytorch/blob/cf30153/torch/utils/data/datapipes/datapipe.py)
- **Evidence:** [`crates/rusttorch-data/tests/stream_workers.rs::four_explicit_modulo_shards_produce_each_logical_record_once`](../crates/rusttorch-data/tests/stream_workers.rs), [`tests/data.rs::dataset_samples_borrow_and_fetch_lazily_in_order`](../tests/data.rs)
- **Notes:** RustTorch does not reproduce functional-name registration, reset/single-iterator hooks, Python serialization hooks, dataframe tracing, or DFIterDataPipe. Vec is the closest DataChunk container but does not retain a separate original-items raw iterator, so DataChunk is not claimed as supported.

### `data.loader.checkpoint`

- **PyTorch:** `No PyTorch symbol (RustTorch checkpoint extension)`
- **RustTorch:** `rusttorch_data::LOADER_STATE_SCHEMA_VERSION`, `rusttorch_data::LoaderState`, `rusttorch_data::LoaderConfiguration`, `rusttorch_data::CheckpointPinRequest`, `rusttorch_data::CheckpointPinStatus`, `rusttorch_data::CheckpointBuildError`, `rusttorch_data::Checkpointable`, `rusttorch_data::ReplaySafeDataset`, `rusttorch_data::DatasetCheckpoint`, `rusttorch_data::Stateless`, `rusttorch_data::TransactionalCheckpoint`, `rusttorch_data::WorkerCheckpoint`, `rusttorch_data::ReplaySafeMap`, `rusttorch_data::TransactionalMap`, `rusttorch_data::ReplaySafeTensorDataset`, `rusttorch_data::StatelessWorker`, `rusttorch_data::TransactionalWorker`, `rusttorch_data::DataLoaderBuilder::dataset_identity`, `rusttorch_data::DataLoaderBuilder::resume_from`, `rusttorch_data::DataLoaderBuilder::checkpoint_stateless`, `rusttorch_data::DataLoaderBuilder::checkpoint_transactional`, `rusttorch_data::LoaderIter::checkpoint`, `rusttorch_data::WorkerLoaderIter::checkpoint`, `rusttorch_data::WorkerTransformState`, `rusttorch_data::WorkerTransformLanes`, `rusttorch_data::WorkerLaneState`, `rusttorch_data::SequentialSamplerState`, `rusttorch_data::RandomSamplerState`, `rusttorch_data::SubsetRandomSamplerState`, `rusttorch_data::WeightedRandomSamplerState`, `rusttorch_data::DistributedSamplerState`, `rusttorch_data::BatchSamplerState`, `rusttorch::data::LoaderState`, `rusttorch::data::CheckpointBuildError`, `rusttorch::data::ReplaySafeMap`, `rusttorch::data::TransactionalMap`, `rusttorch::data::ReplaySafeTensorDataset`
- **Implementation:** Implemented by RustTorch
- **Pinned inventory:** 0 identities ([exact mapping](../compat/pytorch_inventory_map.toml)); disposition only, not a support claim.
- **Scope:** Versioned serde state and exact next-visible-batch resume for serial map loaders and ordered prefetched map workers. Serial replay supports explicit replay-safe or transactional datasets. Positive workers require ReplaySafeMap (or a copy-safe tensor wrapper satisfying native Send/Sync), MemoryDisabled, NoWorkerInit, nonpersistent workers, and no timeout. Every built-in checkpointable sampler, automatic/explicit/no batching, transactional or explicitly stateless transforms, coordinator state, and pin identity are supported. Worker barriers cancel and account dispatched tasks, restore bounded per-lane pre-task snapshots, discard unpublished samples, rewind the sampler, and replay in deterministic lanes. Resume validates the envelope and all components before any apply and retains suspended worker instances.
- **Pinned source:** [`torch/utils/data/dataloader.py`](https://github.com/pytorch/pytorch/blob/cf30153/torch/utils/data/dataloader.py)
- **Evidence:** [`crates/rusttorch-data/tests/checkpoint_map.rs::prefetched_every_boundary_continues_and_resumes`](../crates/rusttorch-data/tests/checkpoint_map.rs), [`crates/rusttorch-data/tests/checkpoint_map.rs::prefetched_transactional_lanes_and_zero_workers_restore_every_boundary`](../crates/rusttorch-data/tests/checkpoint_map.rs), [`crates/rusttorch-data/tests/checkpoint_map.rs::prefetched_delayed_low_lane_keeps_earliest_unconsumed_snapshot`](../crates/rusttorch-data/tests/checkpoint_map.rs), [`crates/rusttorch-data/tests/checkpoint_map.rs::prefetched_hidden_transform_failure_replays_after_lower_batches`](../crates/rusttorch-data/tests/checkpoint_map.rs), [`crates/rusttorch-data/tests/checkpoint_map.rs::prefetched_fetch_and_cardinality_errors_recur_at_hidden_batch`](../crates/rusttorch-data/tests/checkpoint_map.rs), [`crates/rusttorch-data/tests/checkpoint_map.rs::prefetched_sampler_and_stateless_task_rng_replay`](../crates/rusttorch-data/tests/checkpoint_map.rs), [`crates/rusttorch-data/tests/checkpoint_map.rs::prefetched_explicit_and_no_batch_plans_restore`](../crates/rusttorch-data/tests/checkpoint_map.rs), [`crates/rusttorch-data/tests/checkpoint_map.rs::prefetched_validation_is_transactional_and_threads_join`](../crates/rusttorch-data/tests/checkpoint_map.rs), [`crates/rusttorch-data/tests/checkpoint_map.rs::prefetched_capability_drift_and_factory_sources_are_explicit`](../crates/rusttorch-data/tests/checkpoint_map.rs), [`crates/rusttorch-data/tests/checkpoint_map.rs::prefetched_factory_identity_survives_transport_generation_changes`](../crates/rusttorch-data/tests/checkpoint_map.rs), [`crates/rusttorch-data/tests/checkpoint_map.rs::json_round_trip_resumes_every_serial_boundary_exactly`](../crates/rusttorch-data/tests/checkpoint_map.rs), [`crates/rusttorch-data/tests/checkpoint_map.rs::short_tail_drop_last_and_invalid_boundaries_are_explicit`](../crates/rusttorch-data/tests/checkpoint_map.rs), [`crates/rusttorch-data/tests/checkpoint_map.rs::every_concrete_sampler_and_epoch_restores_its_active_cursor`](../crates/rusttorch-data/tests/checkpoint_map.rs), [`crates/rusttorch-data/tests/checkpoint_map.rs::explicit_batch_sampler_and_no_batch_converter_resume`](../crates/rusttorch-data/tests/checkpoint_map.rs), [`crates/rusttorch-data/tests/checkpoint_map.rs::stateful_transform_and_coordinator_restore_after_last_visible_batch`](../crates/rusttorch-data/tests/checkpoint_map.rs), [`crates/rusttorch-data/tests/checkpoint_map.rs::deterministic_transform_failure_recurs_at_the_same_logical_batch`](../crates/rusttorch-data/tests/checkpoint_map.rs), [`crates/rusttorch-data/tests/checkpoint_map.rs::transactional_dataset_restores_serial_fetch_state`](../crates/rusttorch-data/tests/checkpoint_map.rs), [`crates/rusttorch-data/tests/checkpoint_map.rs::resume_validates_every_component_before_any_apply`](../crates/rusttorch-data/tests/checkpoint_map.rs), [`crates/rusttorch-data/tests/checkpoint_map.rs::envelope_and_configuration_drift_reject_before_iteration`](../crates/rusttorch-data/tests/checkpoint_map.rs), [`crates/rusttorch-data/tests/checkpoint_map.rs::replay_safe_tensor_dataset_owns_backing_and_each_fetched_row`](../crates/rusttorch-data/tests/checkpoint_map.rs), [`crates/rusttorch-data/tests/checkpoint_map.rs::no_batch_state_targets_the_effective_converter`](../crates/rusttorch-data/tests/checkpoint_map.rs), [`crates/rusttorch-data/tests/checkpoint_map.rs::resume_build_error_preserves_configuration_and_factory_sources`](../crates/rusttorch-data/tests/checkpoint_map.rs), [`crates/rusttorch-data/tests/checkpoint_map.rs::pin_request_and_effective_status_are_checkpoint_identity`](../crates/rusttorch-data/tests/checkpoint_map.rs), [`crates/rusttorch-data/tests/checkpoint_map.rs::sampler_and_distributed_semantic_corruption_rejects_without_panicking`](../crates/rusttorch-data/tests/checkpoint_map.rs), [`crates/rusttorch-data/tests/checkpoint_map.rs::malformed_json_is_a_storage_error_not_a_loader_fallback`](../crates/rusttorch-data/tests/checkpoint_map.rs), [`tests/data.rs::facade_reexports_exact_serial_checkpoint_contracts`](../tests/data.rs)
- **Notes:** This is a RustTorch-native replay capability, not Python iterator-checkpoint parity. Serial schema v1 remains unchanged; worker transform state carries a separate versioned lane/configuration and factory/transport-generation envelope. Each map lane retains at most prefetch\_factor + 1 snapshots. Typed checkpoint queues/rings and coordinator ledgers participate in the checked 64 MiB allocation preflight; arbitrary state heap contents are item-bounded, not a total-RSS guarantee. Blocking callbacks remain cooperatively cancellable and drop joins. Transactional datasets remain serial-only. Persistent/initialized/byte-enabled/timeout worker replay remains unsupported. Exact sharded streams are tracked in data.loader.checkpoint\_stream. Storage format and persistence policy are caller-owned.

### `data.loader.pinning`

- **PyTorch:** `torch.utils.data.DataLoader(pin_memory=...)`
- **RustTorch:** `rusttorch_data::PinMemory`, `rusttorch_data::PinMemoryStatus`, `rusttorch_data::PinDisabled`, `rusttorch_data::PinEnabled`, `rusttorch_data::Auto`, `rusttorch_data::Explicit`, `rusttorch_data::DataLoaderBuilder::pin_memory`, `rusttorch_data::DataLoaderBuilder::pin_memory_for`, `rusttorch_data::OwnedDataLoader::pin_memory_enabled`, `rusttorch_data::OwnedDataLoader::pin_memory_status`, `rusttorch_data::StreamDataLoaderBuilder::pin_memory`, `rusttorch_data::StreamDataLoaderBuilder::pin_memory_for`, `rusttorch_data::StreamDataLoader::pin_memory_enabled`, `rusttorch_data::StreamDataLoader::pin_memory_status`, `rusttorch::data::PinMemory`, `rusttorch::data::PinMemoryStatus`, `rusttorch::data::DataLoaderBuilder::pin_memory`, `rusttorch::data::DataLoaderBuilder::pin_memory_for`, `rusttorch::data::OwnedDataLoader::pin_memory_status`, `rusttorch::data::StreamDataLoaderBuilder::pin_memory`, `rusttorch::data::StreamDataLoaderBuilder::pin_memory_for`, `rusttorch::data::StreamDataLoader::pin_memory_status`
- **Implementation:** Implemented by RustTorch
- **Pinned inventory:** 0 identities ([exact mapping](../compat/pytorch_inventory_map.toml)); disposition only, not a support claim.
- **Scope:** Type-state-enabled recursive post-collation pinning for map and explicitly sharded stream loaders across Tensor, Vec, Option, tuples of arity two through eight, and BTreeMap values, with identity scalar/string/Bytes leaves, exact batch types, typed source-preserving failures, automatic CUDA-device-zero selection, and explicit available-CUDA validation before callbacks.
- **Pinned source:** [`torch/utils/data/dataloader.py`](https://github.com/pytorch/pytorch/blob/cf30153/torch/utils/data/dataloader.py)
- **Evidence:** [`crates/rusttorch-data/tests/pin_memory.rs::recursive_pin_memory_preserves_identity_leaves_keys_and_shape_without_clone`](../crates/rusttorch-data/tests/pin_memory.rs), [`crates/rusttorch-data/tests/pin_memory.rs::tensor_and_nested_cuda_pinning_is_checked_when_cuda_exists`](../crates/rusttorch-data/tests/pin_memory.rs), [`crates/rusttorch-data/tests/pin_memory.rs::automatic_pin_status_is_effective_and_preserves_the_exact_batch_type`](../crates/rusttorch-data/tests/pin_memory.rs), [`crates/rusttorch-data/tests/pin_memory.rs::disabled_custom_batch_has_no_pin_memory_bound`](../crates/rusttorch-data/tests/pin_memory.rs), [`crates/rusttorch-data/tests/pin_memory.rs::explicit_unsupported_devices_reject_before_factory_callbacks`](../crates/rusttorch-data/tests/pin_memory.rs), [`crates/rusttorch-data/tests/pin_memory.rs::pinning_runs_after_collation_in_both_setter_orders_when_cuda_exists`](../crates/rusttorch-data/tests/pin_memory.rs), [`crates/rusttorch-data/tests/pin_memory.rs::pin_failure_is_typed_once_when_cuda_exists`](../crates/rusttorch-data/tests/pin_memory.rs), [`crates/rusttorch-data/tests/pin_memory.rs::stream_auto_pin_status_and_batch_type_are_preserved`](../crates/rusttorch-data/tests/pin_memory.rs), [`tests/data.rs::facade_reexports_memory_and_pinning_contracts`](../tests/data.rs)
- **Notes:** Automatic pinning uses CUDA device zero because RustTorch has no current-CUDA-index API. CPU-only and MPS-only runtimes report DisabledNoAccelerator and perform a no-op; explicit CPU, MPS, Vulkan, other devices, and unavailable CUDA indices are rejected. CUDA storage assertions and forced pin-failure evidence are conditional on the linked runtime exposing CUDA. Deprecated Python pin\_memory\_device is not reproduced; pin\_memory\_for(Device) is the typed replacement. This does not claim PyTorch custom pin\_memory duck typing, accelerator selection beyond CUDA, or asynchronous transfer benchmarks.

### `data.loader.prefetch`

- **PyTorch:** `torch.utils.data.DataLoader(prefetch_factor=...)`
- **RustTorch:** `rusttorch_data::MemoryFootprint`, `rusttorch_data::MemoryDisabled`, `rusttorch_data::MemoryEnabled`, `rusttorch_data::DataLoaderBuilder::prefetch_factor`, `rusttorch_data::DataLoaderBuilder::prefetch_bytes`, `rusttorch_data::OwnedDataLoader::effective_prefetch_factor`, `rusttorch_data::OwnedDataLoader::effective_prefetch_bytes`, `rusttorch_data::StreamDataLoaderBuilder::prefetch_factor`, `rusttorch_data::StreamDataLoaderBuilder::prefetch_bytes`, `rusttorch_data::StreamDataLoader::effective_prefetch_factor`, `rusttorch_data::StreamDataLoader::effective_prefetch_bytes`, `rusttorch::data::MemoryFootprint`, `rusttorch::data::DataLoaderBuilder::prefetch_factor`, `rusttorch::data::DataLoaderBuilder::prefetch_bytes`, `rusttorch::data::OwnedDataLoader::effective_prefetch_bytes`, `rusttorch::data::StreamDataLoaderBuilder::prefetch_bytes`, `rusttorch::data::StreamDataLoader::effective_prefetch_bytes`
- **Implementation:** Implemented by RustTorch
- **Pinned inventory:** 0 identities ([exact mapping](../compat/pytorch_inventory_map.toml)); disposition only, not a support claim.
- **Scope:** Positive map workers use checked bounded task/control/result storage and a global item-credit limit of workers multiplied by prefetch\_factor. Optional nonzero prefetch\_bytes adds a strict generation-scoped post-transform logical-payload budget to map batches and stream records through result queues and ordered reassembly, with cancellation-safe RAII permits, exact oversize metadata, sequence-aware ordered admission, bounded stream front waiters, and one-error-then-exhaust behavior.
- **Pinned source:** [`torch/utils/data/dataloader.py`](https://github.com/pytorch/pytorch/blob/cf30153/torch/utils/data/dataloader.py)
- **Evidence:** [`crates/rusttorch-data/tests/loader_builder.rs::scalar_configuration_is_validated_and_prefetch_is_normalized`](../crates/rusttorch-data/tests/loader_builder.rs), [`crates/rusttorch-data/tests/map_workers.rs::global_outstanding_work_uses_default_and_explicit_checked_credits`](../crates/rusttorch-data/tests/map_workers.rs), [`crates/rusttorch-data/tests/map_workers.rs::build_rejects_before_sampler_or_batch_source_epoch_callbacks`](../crates/rusttorch-data/tests/map_workers.rs), [`crates/rusttorch-data/tests/memory_budget.rs::footprints_are_recursive_capacity_aware_and_saturating`](../crates/rusttorch-data/tests/memory_budget.rs), [`crates/rusttorch-data/tests/memory_budget.rs::byte_accounting_uses_the_final_transform_type_in_either_setter_order`](../crates/rusttorch-data/tests/memory_budget.rs), [`crates/rusttorch-data/tests/memory_budget.rs::disabled_custom_types_remain_item_bounded_without_new_trait_bounds`](../crates/rusttorch-data/tests/memory_budget.rs), [`crates/rusttorch-data/tests/memory_budget.rs::map_zero_workers_reject_byte_prefetch_before_iteration_callbacks`](../crates/rusttorch-data/tests/memory_budget.rs), [`crates/rusttorch-data/tests/memory_budget.rs::oversized_transformed_map_batch_has_exact_metadata_once`](../crates/rusttorch-data/tests/memory_budget.rs), [`crates/rusttorch-data/tests/memory_budget.rs::ordered_map_byte_admission_blocks_high_until_delayed_low_is_consumable`](../crates/rusttorch-data/tests/memory_budget.rs), [`crates/rusttorch-data/tests/memory_budget.rs::unordered_unsequenced_oversize_preserves_exact_stream_metadata_once`](../crates/rusttorch-data/tests/memory_budget.rs), [`crates/rusttorch-data/tests/memory_budget.rs::ordered_oversize_preserves_stream_identity_without_guessing_a_batch`](../crates/rusttorch-data/tests/memory_budget.rs), [`crates/rusttorch-data/tests/memory_budget.rs::ordered_byte_stream_rejects_missing_and_nonmonotonic_same_shard_sequences`](../crates/rusttorch-data/tests/memory_budget.rs), [`crates/rusttorch-data/tests/memory_budget.rs::ordered_byte_admission_allows_delayed_low_progress_and_persistent_reuse`](../crates/rusttorch-data/tests/memory_budget.rs), [`crates/rusttorch-data/tests/memory_budget.rs::early_drop_cancels_a_blocked_permit_and_persistent_restart_has_no_leak`](../crates/rusttorch-data/tests/memory_budget.rs), [`crates/rusttorch-data/tests/memory_budget.rs::timeout_cancels_ordered_budget_waiters_before_persistent_restart`](../crates/rusttorch-data/tests/memory_budget.rs), [`crates/rusttorch-data/tests/worker_lifecycle.rs::full_result_queue_and_idle_task_waits_wake_on_drop`](../crates/rusttorch-data/tests/worker_lifecycle.rs)
- **Notes:** MemoryFootprint is an infallible saturating logical-payload estimate, not whole-process RSS: tensor views/shared backing storage and allocator/node overhead are outside the contract. The coordinator releases permits when moving values into its one active item-bounded collation batch, which is deliberately outside prefetch\_bytes. Byte accounting is opt-in and requires the final post-transform type; disabled custom types retain the item-only contract.

### `data.loader.transforms`

- **PyTorch:** `torch.utils.data.Dataset transform conventions`, `torch.utils.data.DataLoader(generator=...)`
- **RustTorch:** `rusttorch_data::TaskContext`, `rusttorch_data::CancellationToken`, `rusttorch_data::Deadline`, `rusttorch_data::WaitOutcome`, `rusttorch_data::LoaderCancelled`, `rusttorch_data::Transform`, `rusttorch_data::FnTransform`, `rusttorch_data::TransformFactory`, `rusttorch_data::FnTransformFactory`, `rusttorch_data::IdentityTransformFactory`, `rusttorch_data::DataLoaderBuilder::transform`, `rusttorch_data::DataLoaderBuilder::transform_factory`, `rusttorch_data::DataLoaderBuilder::seed`, `rusttorch_data::DataLoaderBuilder::epoch`, `rusttorch_data::DataLoaderBuilder::rank`, `rusttorch_data::TASK_RNG_DERIVATION_VERSION`, `rusttorch::data::TaskContext`, `rusttorch::data::CancellationToken`, `rusttorch::data::Deadline`, `rusttorch::data::WaitOutcome`, `rusttorch::data::LoaderCancelled`, `rusttorch::data::Transform`, `rusttorch::data::FnTransform`, `rusttorch::data::TransformFactory`, `rusttorch::data::FnTransformFactory`, `rusttorch::data::IdentityTransformFactory`, `rusttorch::data::DataLoaderBuilder::transform`, `rusttorch::data::DataLoaderBuilder::transform_factory`, `rusttorch::data::DataLoaderBuilder::seed`, `rusttorch::data::DataLoaderBuilder::epoch`, `rusttorch::data::DataLoaderBuilder::rank`, `rusttorch::data::TASK_RNG_DERIVATION_VERSION`
- **Implementation:** Implemented by RustTorch
- **Pinned inventory:** 0 identities ([exact mapping](../compat/pytorch_inventory_map.toml)); disposition only, not a support claim.
- **Scope:** Owned loading constructs one typed transform per serial iterator or per worker, reuses it for that lifecycle, supplies monotonic logical occurrence IDs plus cooperative cancellation and deadline state, and preserves dataset, transform, collation, transform-construction, and worker-initialization error types through PipelineError. Version-1 task seeds deterministically mix loader seed, epoch, rank, logical sample, and stage into task-local ChaCha12 state without worker assignment.
- **Pinned source:** [`torch/utils/data/dataloader.py`](https://github.com/pytorch/pytorch/blob/cf30153/torch/utils/data/dataloader.py)
- **Evidence:** [`crates/rusttorch-data/tests/transform.rs::task_rng_is_versioned_schedule_independent_and_has_a_locked_seed`](../crates/rusttorch-data/tests/transform.rs), [`crates/rusttorch-data/tests/transform.rs::task_rng_does_not_change_libtorch_global_rng`](../crates/rusttorch-data/tests/transform.rs), [`crates/rusttorch-data/tests/transform.rs::fn_transform_preserves_output_and_error_types`](../crates/rusttorch-data/tests/transform.rs), [`crates/rusttorch-data/tests/transform.rs::serial_factory_creates_one_transform_per_iterator_and_context_ids_restart`](../crates/rusttorch-data/tests/transform.rs), [`crates/rusttorch-data/tests/transform.rs::transform_builder_clones_fresh_state_for_each_iterator`](../crates/rusttorch-data/tests/transform.rs), [`crates/rusttorch-data/tests/transform.rs::every_serial_stage_keeps_its_concrete_error_and_metadata`](../crates/rusttorch-data/tests/transform.rs), [`crates/rusttorch-data/tests/transform.rs::pipeline_error_generic_positions_are_distinct`](../crates/rusttorch-data/tests/transform.rs), [`crates/rusttorch-data/tests/worker_lifecycle.rs::context_aware_transform_wakes_on_drop_and_deadline`](../crates/rusttorch-data/tests/worker_lifecycle.rs), [`tests/data.rs::facade_reexports_task_transform_and_worker_context_contracts`](../tests/data.rs)
- **Notes:** The fixed SplitMix64-style mixer and ChaCha12 sequence are versioned RustTorch contracts; they do not reproduce PyTorch generator or Philox sequences. Deterministic modulo lanes give stateful worker transforms a reproducible history.

### `data.loader.workers`

- **PyTorch:** `torch.utils.data.DataLoader(num_workers=...)`, `torch.utils.data.get_worker_info`
- **RustTorch:** `rusttorch_data::DataLoaderBuilder::workers`, `rusttorch_data::DataLoaderBuilder::persistent_workers`, `rusttorch_data::DataLoaderBuilder::timeout`, `rusttorch_data::DataLoaderBuilder::worker_init`, `rusttorch_data::OwnedDataLoader::workers`, `rusttorch_data::WorkerInfo`, `rusttorch_data::WorkerContext`, `rusttorch_data::CancellationToken`, `rusttorch_data::Deadline`, `rusttorch_data::WaitOutcome`, `rusttorch_data::LoaderCancelled`, `rusttorch_data::WorkerInit`, `rusttorch_data::FnWorkerInit`, `rusttorch_data::NoWorkerInit`, `rusttorch_data::get_worker_info`, `rusttorch_data::WORKER_SEED_DERIVATION_VERSION`, `rusttorch::data::DataLoaderBuilder::workers`, `rusttorch::data::DataLoaderBuilder::persistent_workers`, `rusttorch::data::DataLoaderBuilder::timeout`, `rusttorch::data::DataLoaderBuilder::worker_init`, `rusttorch::data::OwnedDataLoader::workers`, `rusttorch::data::WorkerInfo`, `rusttorch::data::WorkerContext`, `rusttorch::data::CancellationToken`, `rusttorch::data::Deadline`, `rusttorch::data::WaitOutcome`, `rusttorch::data::LoaderCancelled`, `rusttorch::data::WorkerInit`, `rusttorch::data::FnWorkerInit`, `rusttorch::data::NoWorkerInit`, `rusttorch::data::get_worker_info`, `rusttorch::data::WORKER_SEED_DERIVATION_VERSION`
- **Implementation:** Implemented by RustTorch
- **Pinned inventory:** 1 identities ([exact mapping](../compat/pytorch_inventory_map.toml)); disposition only, not a support claim.
- **Scope:** Positive map-worker counts create joinable bounded Rust threads sharing an Arc dataset, route batch sequence s to worker s modulo worker count, initialize and construct one transform per worker, fetch and transform with cooperative generation cancellation and per-next deadlines, collate on the coordinator, preserve sampler order by default, optionally yield completion order, convert worker panics, and terminate after one typed failure. Optional persistent pools reuse threads, initial seeds, initializer calls, and factory-created transforms while quiescing and discarding tagged stale work between fresh generations.
- **Pinned source:** [`torch/utils/data/_utils/worker.py`](https://github.com/pytorch/pytorch/blob/cf30153/torch/utils/data/_utils/worker.py)
- **Evidence:** [`crates/rusttorch-data/tests/map_workers.rs::positive_workers_fetch_batches_concurrently_on_distinct_threads`](../crates/rusttorch-data/tests/map_workers.rs), [`crates/rusttorch-data/tests/map_workers.rs::ordered_and_completion_modes_follow_the_selected_contract`](../crates/rusttorch-data/tests/map_workers.rs), [`crates/rusttorch-data/tests/map_workers.rs::batch_sequence_routes_to_its_modulo_worker_across_iterations`](../crates/rusttorch-data/tests/map_workers.rs), [`crates/rusttorch-data/tests/map_workers.rs::factory_and_initializer_run_once_per_worker_with_fresh_generations`](../crates/rusttorch-data/tests/map_workers.rs), [`crates/rusttorch-data/tests/map_workers.rs::worker_and_coordinator_errors_are_typed_visible_once_and_contextual`](../crates/rusttorch-data/tests/map_workers.rs), [`crates/rusttorch-data/tests/map_workers.rs::worker_panics_are_converted_with_worker_and_batch_context`](../crates/rusttorch-data/tests/map_workers.rs), [`crates/rusttorch-data/tests/map_workers.rs::early_drop_disconnects_saturated_work_and_joins_every_worker`](../crates/rusttorch-data/tests/map_workers.rs), [`crates/rusttorch-data/tests/map_workers.rs::overflowing_timeout_rejects_before_plan_or_worker_callbacks`](../crates/rusttorch-data/tests/map_workers.rs), [`crates/rusttorch-data/tests/worker_context.rs::worker_info_scopes_are_nested_and_panic_safe`](../crates/rusttorch-data/tests/worker_context.rs), [`crates/rusttorch-data/tests/worker_context.rs::worker_info_is_isolated_between_concurrent_threads`](../crates/rusttorch-data/tests/worker_context.rs), [`crates/rusttorch-data/tests/worker_context.rs::worker_info_validates_identity_and_locks_versioned_seed_derivation`](../crates/rusttorch-data/tests/worker_context.rs), [`crates/rusttorch-data/tests/worker_context.rs::worker_seed_derivation_does_not_change_libtorch_global_rng`](../crates/rusttorch-data/tests/worker_context.rs), [`crates/rusttorch-data/tests/worker_lifecycle.rs::public_cancellation_and_deadline_waits_are_notification_driven`](../crates/rusttorch-data/tests/worker_lifecycle.rs), [`crates/rusttorch-data/tests/worker_lifecycle.rs::timeout_deadline_is_fresh_for_each_blocking_next`](../crates/rusttorch-data/tests/worker_lifecycle.rs), [`crates/rusttorch-data/tests/worker_lifecycle.rs::unordered_ready_batch_does_not_block_on_saturated_lane_refill`](../crates/rusttorch-data/tests/worker_lifecycle.rs), [`crates/rusttorch-data/tests/worker_lifecycle.rs::first_error_cancels_siblings_and_every_worker_exits_once`](../crates/rusttorch-data/tests/worker_lifecycle.rs), [`crates/rusttorch-data/tests/worker_lifecycle.rs::worker_init_error_and_panic_are_visible_once`](../crates/rusttorch-data/tests/worker_lifecycle.rs), [`crates/rusttorch-data/tests/worker_lifecycle.rs::full_result_queue_and_idle_task_waits_wake_on_drop`](../crates/rusttorch-data/tests/worker_lifecycle.rs), [`crates/rusttorch-data/tests/worker_lifecycle.rs::nonpersistent_iterations_use_fresh_consecutive_seed_ranges`](../crates/rusttorch-data/tests/worker_lifecycle.rs), [`crates/rusttorch-data/tests/worker_lifecycle.rs::serial_factory_gets_none_and_worker_callbacks_get_lifecycle_context`](../crates/rusttorch-data/tests/worker_lifecycle.rs), [`crates/rusttorch-data/tests/worker_lifecycle.rs::persistent_workers_reuse_threads_seeds_and_callbacks_across_epochs`](../crates/rusttorch-data/tests/worker_lifecycle.rs), [`crates/rusttorch-data/tests/worker_lifecycle.rs::persistent_early_drop_discards_stale_sequence_zero_in_ordered_and_unordered_modes`](../crates/rusttorch-data/tests/worker_lifecycle.rs), [`crates/rusttorch-data/tests/worker_lifecycle.rs::non_cooperative_fetch_makes_drop_wait_until_explicit_release`](../crates/rusttorch-data/tests/worker_lifecycle.rs), [`tests/data.rs::facade_reexports_task_transform_and_worker_context_contracts`](../tests/data.rs)
- **Notes:** Rust threads replace Python subprocesses: map datasets are shared rather than copied, collation stays on the coordinator, and WorkerInfo intentionally omits an erased dataset. Worker and task seeds are versioned local derivations with no PyTorch generator or Philox identity. Persistent factory and initializer contexts use the pool-lifetime shutdown token; fetch and task contexts use a fresh generation token and dynamic deadline. The compiling WorkerContext rustdoc demonstrates both cancellation and deadline outcomes. Nonzero loader timeouts must fit the platform monotonic clock; public overflowing deadlines fail closed as expired. Rust cannot force-cancel a non-cooperative dataset or native call, so drop waits until it returns before joining. Optional post-collation recursive pinning is tracked separately in data.loader.pinning.

### `data.stream_workers`

- **PyTorch:** `torch.utils.data.IterableDataset`, `torch.utils.data.DataLoader(num_workers=...)`, `torch.utils.data.DataLoader(in_order=...)`, `torch.utils.data.DataLoader(persistent_workers=...)`
- **RustTorch:** `rusttorch_data::SequenceId`, `rusttorch_data::LogicalSampleId`, `rusttorch_data::WorkerRecord`, `rusttorch_data::WorkerSourceFactory`, `rusttorch_data::StreamDataLoaderBuilder`, `rusttorch_data::StreamDataLoader`, `rusttorch_data::StreamLoaderIter`, `rusttorch::data::SequenceId`, `rusttorch::data::LogicalSampleId`, `rusttorch::data::WorkerRecord`, `rusttorch::data::WorkerSourceFactory`, `rusttorch::data::StreamDataLoaderBuilder`, `rusttorch::data::StreamDataLoader`, `rusttorch::data::StreamLoaderIter`
- **Implementation:** Implemented by RustTorch
- **Pinned inventory:** 0 identities ([exact mapping](../compat/pytorch_inventory_map.toml)); disposition only, not a support claim.
- **Scope:** Explicitly sharded positive-worker Rust streams with one owned iterator per worker and generation, stable logical sample identity, optional exact global length, ordered contiguous global sequence reassembly or completion-order delivery, coordinator-side global batching and collation, checked bounded result/preallocated-flat-reassembly/batch allocation, typed pipeline/protocol/panic failures, ready-completion-first cooperative per-next timeout and cancellation, and optional loader-owned persistent worker pools.
- **Pinned source:** [`torch/utils/data/dataloader.py`](https://github.com/pytorch/pytorch/blob/cf30153/torch/utils/data/dataloader.py)
- **Evidence:** [`crates/rusttorch-data/tests/stream_workers.rs::four_explicit_modulo_shards_produce_each_logical_record_once`](../crates/rusttorch-data/tests/stream_workers.rs), [`crates/rusttorch-data/tests/stream_workers.rs::ordered_sequence_protocol_rejects_every_gap_and_duplicate_shape_once`](../crates/rusttorch-data/tests/stream_workers.rs), [`crates/rusttorch-data/tests/stream_workers.rs::ordered_full_credit_window_reports_first_gap_instead_of_timing_out`](../crates/rusttorch-data/tests/stream_workers.rs), [`crates/rusttorch-data/tests/stream_workers.rs::ordered_internal_gap_beyond_same_worker_quota_is_protocol_error`](../crates/rusttorch-data/tests/stream_workers.rs), [`crates/rusttorch-data/tests/stream_workers.rs::unordered_records_may_be_unsequenced_and_task_rng_uses_logical_id`](../crates/rusttorch-data/tests/stream_workers.rs), [`crates/rusttorch-data/tests/stream_workers.rs::coordinator_batches_globally_and_drops_only_one_global_tail`](../crates/rusttorch-data/tests/stream_workers.rs), [`crates/rusttorch-data/tests/stream_workers.rs::per_worker_credits_bound_fast_shards_without_blocking_their_progress`](../crates/rusttorch-data/tests/stream_workers.rs), [`crates/rusttorch-data/tests/stream_workers.rs::every_stream_stage_failure_is_typed_contextual_and_visible_once`](../crates/rusttorch-data/tests/stream_workers.rs), [`crates/rusttorch-data/tests/stream_workers.rs::queued_low_record_beats_an_expired_deadline_after_high_reassembly`](../crates/rusttorch-data/tests/stream_workers.rs), [`crates/rusttorch-data/tests/stream_workers.rs::queued_protocol_error_beats_expiry_after_a_high_record`](../crates/rusttorch-data/tests/stream_workers.rs), [`crates/rusttorch-data/src/stream.rs::queued_error_and_end_beat_an_expired_receive_deadline`](../crates/rusttorch-data/src/stream.rs), [`crates/rusttorch-data/tests/stream_workers.rs::cooperative_stream_source_wakes_on_timeout_and_early_drop`](../crates/rusttorch-data/tests/stream_workers.rs), [`crates/rusttorch-data/tests/stream_workers.rs::drop_waits_for_a_noncooperative_source_instead_of_detaching_it`](../crates/rusttorch-data/tests/stream_workers.rs), [`crates/rusttorch-data/tests/stream_workers.rs::full_result_queue_drop_wakes_and_joins_every_worker`](../crates/rusttorch-data/tests/stream_workers.rs), [`crates/rusttorch-data/tests/stream_workers.rs::persistent_ordered_and_unordered_workers_recreate_sources_but_keep_pool_state`](../crates/rusttorch-data/tests/stream_workers.rs), [`crates/rusttorch-data/tests/stream_workers.rs::persistent_early_drop_drains_stale_results_before_both_delivery_modes_restart`](../crates/rusttorch-data/tests/stream_workers.rs), [`crates/rusttorch-data/tests/stream_workers.rs::persistent_exhaustion_waits_until_the_generation_source_is_dropped`](../crates/rusttorch-data/tests/stream_workers.rs), [`crates/rusttorch-data/tests/stream_workers.rs::persistent_source_destructor_panic_is_visible_and_poisons_the_pool`](../crates/rusttorch-data/tests/stream_workers.rs), [`crates/rusttorch-data/tests/stream_workers.rs::first_protocol_failure_cancels_before_releasing_reassembly_credits`](../crates/rusttorch-data/tests/stream_workers.rs), [`crates/rusttorch-data/tests/stream_workers.rs::iterator_drop_cancels_before_releasing_reassembly_credits`](../crates/rusttorch-data/tests/stream_workers.rs), [`crates/rusttorch-data/tests/stream_workers.rs::invalid_stream_builders_fail_before_factory_or_worker_side_effects`](../crates/rusttorch-data/tests/stream_workers.rs), [`crates/rusttorch-data/tests/stream_workers.rs::large_inline_batch_and_reassembly_storage_are_rejected_before_callbacks`](../crates/rusttorch-data/tests/stream_workers.rs), [`crates/rusttorch-data/tests/stream_workers.rs::sparse_one_entry_reassembly_uses_one_concrete_vec_slot`](../crates/rusttorch-data/tests/stream_workers.rs), [`crates/rusttorch-data/tests/stream_workers.rs::oversized_one_entry_vec_aggregate_is_rejected_before_every_callback`](../crates/rusttorch-data/tests/stream_workers.rs), [`crates/rusttorch-data/tests/current_api.rs::stream_loader_remains_sync_for_send_but_not_sync_output`](../crates/rusttorch-data/tests/current_api.rs), [`tests/data.rs::facade_exposes_explicit_stream_worker_contracts`](../tests/data.rs)
- **Notes:** RustTorch uses threads and typed explicitly sharded factories rather than Python worker processes or a shared IterableDataset object. Ordered sources must provide a unique zero-based contiguous global sequence; unordered sources may omit sequence but must provide stable logical IDs. Byte-enabled ordered shards additionally emit strictly increasing IDs per shard; bounded front-waiter state detects a globally missing ID without byte deadlock. Ordered reassembly is one loader-owned preallocated flat vector with linear lookup in the bounded credit window; its actual retained capacity is validated before callbacks and reused across generations. RustTorch merges before batching, so drop\_last removes at most one global tail instead of PyTorch iterable-style per-process tails. Cancellation is cooperative and drop joins rather than force-cancelling a blocking native source. Checkpoint/resume remains outside this row.

### `distributed.c10d`

- **PyTorch:** `torch.distributed.init_process_group`, `torch.distributed.ProcessGroup`, `torch.distributed.distributed_c10d.ProcessGroup`, `torch.distributed.all_reduce`, `torch.distributed.broadcast`, `torch.distributed.reduce`, `torch.distributed.all_gather`, `torch.distributed.gather`, `torch.distributed.scatter`, `torch.distributed.reduce_scatter`, `torch.distributed.all_to_all`, `torch.distributed.barrier`, `torch.distributed.send`, `torch.distributed.recv`
- **RustTorch:** `rusttorch::distributed::GroupOptions`, `rusttorch::distributed::ProcessGroup`, `rusttorch::distributed::ReduceOp`
- **Implementation:** RustTorch frontend backed by LibTorch
- **Pinned inventory:** 13 identities ([exact mapping](../compat/pytorch_inventory_map.toml)); disposition only, not a support claim.
- **Scope:** Blocking CPU TCP process groups with explicit rank/world/session rendezvous; barrier, broadcast, sum/mean/min/max/product all-reduce and reduce, equal-spec gather/all-gather/scatter/reduce-scatter/all-to-all, and tagged two-peer send/recv. Dense Float/Double/Int64 payloads, checked byte/shape limits, collective order/root/type agreement, finite communication deadlines and permanent failure on peer/protocol errors are implemented.
- **Pinned source:** [`torch/distributed/distributed_c10d.py`](https://github.com/pytorch/pytorch/blob/cf30153/torch/distributed/distributed_c10d.py)
- **Evidence:** [`tests/distributed.rs::multiprocess_collectives_and_point_to_point_preserve_rank_order`](../tests/distributed.rs), [`tests/distributed.rs::mismatched_collectives_and_local_errors_poison_every_rank`](../tests/distributed.rs), [`tests/distributed.rs::disconnected_and_stalled_workers_fail_with_bounded_cleanup`](../tests/distributed.rs), [`tests/distributed.rs::configuration_and_untrusted_frames_fail_before_large_allocation`](../tests/distributed.rs), [`tests/distributed.rs::cpu_collectives_ddp_and_shards_match_pinned_pytorch_gloo`](../tests/distributed.rs)
- **Notes:** Transport and coordination are original safe Rust, with LibTorch tensor arithmetic; this is not a native c10d/Gloo/NCCL binding. Pinned CPU Gloo supplies numerical reference evidence. Sockets form a full mesh and rank zero coordinates collectives; no throughput or scaling claim. Trusted peers only, without encryption/authentication. Deadlines bound communication waits, not synchronous kernels/serialization. Async handles, accelerator transports, uneven split variants, Python global group registration and elastic membership remain absent.

### `distributed.ddp`

- **PyTorch:** `torch.nn.parallel.DistributedDataParallel`, `torch.nn.parallel.distributed.DistributedDataParallel`
- **RustTorch:** `rusttorch::distributed::DistributedDataParallel`
- **Implementation:** RustTorch frontend backed by LibTorch
- **Pinned inventory:** 2 identities ([exact mapping](../compat/pytorch_inventory_map.toml)); disposition only, not a support claim.
- **Scope:** Explicit replicated CPU training for fixed named Float/Double parameters and dense supported buffers: rank-zero initialization/buffer broadcasts, averaged gradients, delayed synchronization for accumulation, and coordinated backward/update. Parameter layout and optimizer configuration agreement are validated; globally unused gradients skip, differing used-parameter sets reject. Equal-size local mean-loss updates and accumulation match a global-batch reference.
- **Pinned source:** [`torch/nn/parallel/distributed.py`](https://github.com/pytorch/pytorch/blob/cf30153/torch/nn/parallel/distributed.py)
- **Evidence:** [`tests/distributed.rs::replicated_training_and_accumulation_match_global_batch`](../tests/distributed.rs), [`tests/distributed.rs::mismatched_collectives_and_local_errors_poison_every_rank`](../tests/distributed.rs), [`tests/distributed.rs::cpu_collectives_ddp_and_shards_match_pinned_pytorch_gloo`](../tests/distributed.rs)
- **Notes:** Native CPU PyTorch DDP is numerically compared. Rust callers explicitly synchronize buffers and gradients; automatic backward hooks, bucket overlap, asynchronous work, join contexts, changing parameter registration, rank-dependent unused-parameter recovery, accelerator execution and synchronized batch normalization are not implemented. Unequal local batches require explicit loss weighting. A failure during final updates requires recreating the group and restoring a completed checkpoint.

### `distributed.fsdp`

- **PyTorch:** `torch.distributed.fsdp.FullyShardedDataParallel`, `torch.distributed.fsdp.fully_sharded_data_parallel.FullyShardedDataParallel`
- **RustTorch:** `rusttorch::distributed::ShardedTrainer`, `rusttorch::distributed::ShardedCheckpoint`, `rusttorch::distributed::ConsolidatedCheckpoint`
- **Implementation:** RustTorch frontend backed by LibTorch
- **Pinned inventory:** 2 identities ([exact mapping](../compat/pytorch_inventory_map.toml)); disposition only, not a support claim.
- **Scope:** Functional CPU Float/Double training with actual persistent parameter, gradient and optimizer-moment shards: gather one full named parameter group for a scalar loss closure, mean-reduce-scatter gradients and update local shards with any of seven optimizer families. Versioned coordinated model/optimizer checkpoints include session/capture identities, exact same-world restore, full-state consolidation and parameter/moment repartitioning to a different world size.
- **Pinned source:** [`torch/distributed/fsdp/fully_sharded_data_parallel.py`](https://github.com/pytorch/pytorch/blob/cf30153/torch/distributed/fsdp/fully_sharded_data_parallel.py)
- **Evidence:** [`tests/distributed.rs::sharded_training_and_exact_resume_cover_all_optimizer_families`](../tests/distributed.rs), [`tests/distributed.rs::consolidated_checkpoint_reshards_parameters_and_moments_to_new_world_size`](../tests/distributed.rs), [`tests/distributed.rs::corrupted_sharded_state_rejects_weights_optimizer_and_rank_metadata`](../tests/distributed.rs), [`tests/distributed.rs::mismatched_collectives_and_local_errors_poison_every_rank`](../tests/distributed.rs), [`tests/distributed.rs::cpu_collectives_ddp_and_shards_match_pinned_pytorch_gloo`](../tests/distributed.rs)
- **Notes:** A single-group functional Rust equivalent is compared numerically with native CPU PyTorch FSDP; no complete FSDP API or memory/throughput benchmark claim. Full parameters coexist during forward/backward and full checkpoints temporarily materialize on all ranks. Automatic module conversion/hooks, layer-wise reshard/overlap, mixed precision, accelerator/mesh APIs, multiple optimizer groups and Python DCP state formats remain absent. Closures must use every parameter and release gathered tensors; buffers, input/loader/RNG/scheduler state and partial accumulation are application-owned. Same-world resume is exact; changed-world reductions may differ in floating-point order.

### `distributions`

- **PyTorch:** `torch.distributions.Distribution`, `torch.distributions.Normal`, `torch.distributions.Bernoulli`, `torch.distributions.Categorical`
- **RustTorch:** `rusttorch::distributions::Normal`, `rusttorch::distributions::Bernoulli`, `rusttorch::distributions::Categorical`
- **Implementation:** RustTorch frontend backed by LibTorch
- **Pinned inventory:** 0 identities ([exact mapping](../compat/pytorch_inventory_map.toml)); disposition only, not a support claim.
- **Scope:** Finite dense real Normal, Bernoulli and Categorical parameters with broadcast batch shapes, leading sample dimensions, detached sampling, log probability and entropy. Normal additionally exposes pathwise rsample, mean and variance; discrete families accept probabilities or logits. Parameter and observation validation returns errors.
- **Pinned source:** [`torch/distributions/distribution.py`](https://github.com/pytorch/pytorch/blob/cf30153/torch/distributions/distribution.py)
- **Evidence:** [`tests/distributions.rs::continuous_samples_and_scores_have_the_expected_gradient_boundary`](../tests/distributions.rs), [`tests/distributions.rs::discrete_distributions_broadcast_scores_and_preserve_parameter_gradients`](../tests/distributions.rs), [`tests/distributions.rs::invalid_distribution_parameters_and_observations_return_errors`](../tests/distributions.rs), [`tests/distributions.rs::distribution_scores_samples_and_gradients_match_pinned_python`](../tests/distributions.rs)
- **Notes:** Pinned source implementations: torch/distributions/{normal,bernoulli,categorical,utils}.py. CPU Double parity covers scores, entropy, parameter gradients and seeded rsample/Bernoulli/Categorical draws; no universal generator-stream or backend guarantee. The shared native RNG is affected by concurrent draws. Transforms, constraints framework, multivariate/event distributions, infinite parameters and the remaining distribution catalog are not exposed.

### `fft`

- **PyTorch:** `torch.fft`, `torch.fft.rfft`, `torch.fft.irfft`, `torch.fft.fft`, `torch.fft.ifft`
- **RustTorch:** `rusttorch::tensor::spectral_filter`, `rusttorch::Tensor::f_fft_rfft`, `rusttorch::Tensor::f_fft_irfft`, `rusttorch::Tensor::f_fft_fft`, `rusttorch::Tensor::f_fft_ifft`
- **Implementation:** RustTorch frontend backed by LibTorch
- **Pinned inventory:** 5 identities ([exact mapping](../compat/pytorch_inventory_map.toml)); disposition only, not a support claim.
- **Scope:** CPU real-last-axis spectral filtering with exact frequency-bin gain shape, backward normalization and explicit original length for odd/even inverse real transforms; float32/float64 reconstruction and native input/gain gradients. Complex128 one-dimensional FFT/IFFT with ortho normalization, real/imaginary representation and numerical round-trip fixtures are tested.
- **Pinned source:** [`torch/fft/__init__.py`](https://github.com/pytorch/pytorch/blob/cf30153/torch/fft/__init__.py)
- **Evidence:** [`tests/tensor_workflows.rs::fft_and_special_functions_keep_native_gradients`](../tests/tensor_workflows.rs), [`tests/tensor_workflows.rs::empty_nested_and_copy_gradient_boundaries`](../tests/tensor_workflows.rs), [`tests/tensor_workflows.rs::malformed_inputs_return_errors_without_mutation`](../tests/tensor_workflows.rs), [`tests/tensor_workflows.rs::tensor_workflows_python_parity`](../tests/tensor_workflows.rs)
- **Notes:** The helper applies a periodic filter, not padded linear convolution. Full FFT namespace, arbitrary multidimensional transform families, complex64 numerical fixtures, all normalizations and accelerator kernels remain outside this scope. Python fixture compares spectrum, filtered output and selected gradients.

### `graph.conditional`

- **PyTorch:** `torch.cond`
- **RustTorch:** `rusttorch::deployment::Operator::If`, `rusttorch::deployment::Model::run`
- **Implementation:** RustTorch frontend backed by LibTorch
- **Pinned inventory:** 1 identities ([exact mapping](../compat/pytorch_inventory_map.toml)); disposition only, not a support claim.
- **Scope:** Explicit scalar-Bool, single-output conditional subgraphs with matching input signatures, a shared result guard, only-selected-branch execution and gradient connectivity. CPU Float branch values and input gradients match pinned torch.cond for square versus doubled inputs. Portable JSON retains the branch definitions.
- **Pinned source:** [`torch/_higher_order_ops/cond.py`](https://github.com/pytorch/pytorch/blob/cf30153/torch/_higher_order_ops/cond.py)
- **Evidence:** [`tests/deployment.rs::conditional_executes_one_branch_and_preserves_selected_gradient`](../tests/deployment.rs), [`tests/deployment.rs::python_pt2_onnx_and_torchscript_numerical_round_trips`](../tests/deployment.rs)
- **Notes:** Rust explicit subgraphs replace Python callable capture. No loop capture, cond Python signature parity, multi-output branches, PT2/ONNX higher-order conversion or native conditional tracing. Selected result dtype/shape/ranges are validated at runtime.

### `graph.ir`

- **PyTorch:** `torch.fx.Graph`, `torch.fx.Node`, `torch.fx.node.Node`
- **RustTorch:** `rusttorch::graph::Graph`, `rusttorch::graph::GraphBuilder`, `rusttorch::graph::Node`, `rusttorch::graph::NodeId`, `rusttorch::graph::ValueId`, `rusttorch::graph::TensorSpec`, `rusttorch::deployment::Program`, `rusttorch::deployment::Model`, `rusttorch::deployment::ValueSpec`, `rusttorch::deployment::Dimension`, `rusttorch::deployment::Tree`
- **Implementation:** Implemented by RustTorch
- **Pinned inventory:** 2 identities ([exact mapping](../compat/pytorch_inventory_map.toml)); disposition only, not a support claim.
- **Scope:** The tested construction, validation, branching, named-value, topological-order, reachability, and tensor-spec behavior of RustTorch's typed DAG. A separate version-one portable functional program adds serialized graph/operator versions, explicit calling trees, state storage roles/aliases and input range/equality guards; the existing evaluation graph subset lowers with named state.
- **Pinned source:** [`torch/fx/graph.py`](https://github.com/pytorch/pytorch/blob/cf30153/torch/fx/graph.py)
- **Evidence:** [`tests/graph.rs::builder_rejects_a_value_from_another_graph`](../tests/graph.rs), [`tests/graph.rs::builder_rejects_duplicate_node_names`](../tests/graph.rs), [`tests/graph.rs::graph_without_an_output_is_rejected`](../tests/graph.rs), [`tests/deployment.rs::portable_graph_guards_state_and_gradients_round_trip`](../tests/deployment.rs), [`tests/deployment.rs::graph_module_lowering_reuses_named_state_and_evaluation_behavior`](../tests/deployment.rs)
- **Notes:** Neither graph interface claims FX serialization or full FX node/transformation parity. Portable JSON is a RustTorch schema; PT2, ONNX and native JIT use separately evidenced rows.

### `linalg`

- **PyTorch:** `torch.linalg`, `torch.linalg.solve`, `torch.linalg.lstsq`, `torch.linalg.svd`, `torch.linalg.eigh`, `torch.linalg.det`, `torch.linalg.norm`
- **RustTorch:** `rusttorch::tensor::least_squares`, `rusttorch::tensor::LeastSquares`, `rusttorch::Tensor::f_linalg_solve`, `rusttorch::Tensor::f_svd`, `rusttorch::Tensor::f_linalg_eigh`, `rusttorch::Tensor::f_linalg_det`, `rusttorch::Tensor::f_linalg_norm`
- **Implementation:** RustTorch frontend backed by LibTorch
- **Pinned inventory:** 7 identities ([exact mapping](../compat/pytorch_inventory_map.toml)); disposition only, not a support claim.
- **Scope:** CPU real two-dimensional least squares with finite float32/float64 matching inputs and SVD-based gelsd driver, nonnegative optional rcond, solution/residual/rank/singular-value diagnostics, rank-deficiency handling and native gradient connectivity. Float64 CPU fixtures additionally cover square solve, SVD singular values/reconstruction, symmetric eigendecomposition, determinant and matrix spectral norm.
- **Pinned source:** [`torch/linalg/__init__.py`](https://github.com/pytorch/pytorch/blob/cf30153/torch/linalg/__init__.py)
- **Evidence:** [`tests/tensor_workflows.rs::least_squares_handles_rank_deficiency_and_native_linalg`](../tests/tensor_workflows.rs), [`tests/tensor_workflows.rs::malformed_inputs_return_errors_without_mutation`](../tests/tensor_workflows.rs), [`tests/tensor_workflows.rs::tensor_workflows_python_parity`](../tests/tensor_workflows.rs)
- **Notes:** Safe CPU SVD uses native f\_svd returning V, not Vh: generated f\_linalg\_svd requires a string driver and cannot express driver=None for CPU. This is partial numerical equivalence, not identical Python signature. Batched/complex solver helpers, GPU drivers, every decomposition/matrix function and derivatives at singularities/repeated eigenvalues are not claimed. Residuals can be empty according to native lstsq conditions.

### `nn.activations`

- **PyTorch:** `torch.nn.Sigmoid`, `torch.nn.Tanh`, `torch.nn.SiLU`, `torch.nn.Softmax`, `torch.nn.LogSoftmax`, `torch.nn.LeakyReLU`, `torch.nn.ELU`, `torch.nn.modules.activation.ELU`, `torch.nn.modules.activation.LeakyReLU`, `torch.nn.modules.activation.LogSoftmax`, `torch.nn.modules.activation.SiLU`, `torch.nn.modules.activation.Sigmoid`, `torch.nn.modules.activation.Softmax`, `torch.nn.modules.activation.Tanh`
- **RustTorch:** `rusttorch::nn::Sigmoid`, `rusttorch::nn::Tanh`, `rusttorch::nn::SiLU`, `rusttorch::nn::Softmax`, `rusttorch::nn::LogSoftmax`, `rusttorch::nn::LeakyReLU`, `rusttorch::nn::ELU`
- **Implementation:** RustTorch frontend backed by LibTorch
- **Pinned inventory:** 14 identities ([exact mapping](../compat/pytorch_inventory_map.toml)); disposition only, not a support claim.
- **Scope:** Out-of-place sigmoid, tanh, SiLU, dimension-selected softmax/log-softmax, finite-slope leaky ReLU and finite-alpha ELU modules. CPU Float/Double examples and Double numerical fixtures cover outputs, gradients, zero-boundary derivatives and large finite inputs; ELU avoids overflow in its unused exponential branch.
- **Pinned source:** [`torch/nn/modules/activation.py`](https://github.com/pytorch/pytorch/blob/cf30153/torch/nn/modules/activation.py)
- **Evidence:** [`tests/nn_spatial.rs::activations_handle_zero_gradients_large_values_and_invalid_options`](../tests/nn_spatial.rs), [`tests/nn_spatial.rs::spatial_layers_match_pinned_python_outputs_gradients_and_buffers`](../tests/nn_spatial.rs)
- **Notes:** These seven modules do not establish the entire activation catalog. In-place modes, standalone functional wrappers for these additions, explicit softmax dtype selection and the full dtype/backend matrix are outside this row. LeakyReLU and ELU require real floating tensors.

### `nn.attention`

- **PyTorch:** `torch.nn.MultiheadAttention`, `torch.nn.functional.scaled_dot_product_attention`, `torch.nn.modules.activation.MultiheadAttention`
- **RustTorch:** `rusttorch::nn::AttentionMask`, `rusttorch::nn::MultiheadAttentionConfig`, `rusttorch::nn::MultiheadAttention`, `rusttorch::nn::MultiheadAttention::forward_t`, `rusttorch::nn::MultiheadAttention::forward_per_head_t`, `rusttorch::nn::MultiheadAttention::forward_without_weights_t`
- **Implementation:** RustTorch frontend backed by LibTorch
- **Pinned inventory:** 3 identities ([exact mapping](../compat/pytorch_inventory_map.toml)); disposition only, not a support claim.
- **Scope:** Dense equal-width self/cross multihead attention with batched sequence-first, batch-first and unbatched layouts; optional projection bias; training dropout; boolean/additive attention and padding masks; explicit causal restrictions; head-averaged or per-head weights; and a no-weights path. CPU fixtures cover initialized parameters, outputs and input/parameter gradients.
- **Pinned source:** [`torch/nn/modules/activation.py`](https://github.com/pytorch/pytorch/blob/cf30153/torch/nn/modules/activation.py)
- **Evidence:** [`tests/nn_sequence.rs::attention_masks_block_future_and_padding_tokens_with_gradients`](../tests/nn_sequence.rs), [`tests/nn_sequence.rs::attention_scales_queries_before_half_precision_dot_products`](../tests/nn_sequence.rs), [`tests/nn_sequence.rs::attention_validation_and_dropout_cover_cross_attention_and_unbatched_inputs`](../tests/nn_sequence.rs), [`tests/nn_sequence.rs::sequence_python_parity`](../tests/nn_sequence.rs), [`tests/nn_sequence.rs::biased_attention_projections_match_cpu_outputs_and_gradients_on_mps`](../tests/nn_sequence.rs)
- **Notes:** Separate kdim/vdim, appended bias/zero tokens, nested tensors, cached keys, grouped-query attention and kernel-selection controls are not exposed. The no-weights path delegates to native scaled-dot-product attention; there is no standalone RustTorch functional scaled\_dot\_product\_attention wrapper. Boolean true means blocked for AttentionMask, and causal=true explicitly constructs restrictions rather than acting only as a kernel hint. Fully blocked rows produce NaN returned softmax maps; the no-weights path contributes zero before output projection. CPU evidence does not establish accelerator or full dtype parity. A conditional MPS Float fixture with nonzero biases checks batch-first self-attention outputs, weights and input/all-parameter gradients against CPU; it is narrow projection evidence, not a complete accelerator matrix.

### `nn.convolution`

- **PyTorch:** `torch.nn.Conv1d`, `torch.nn.Conv2d`, `torch.nn.Conv3d`, `torch.nn.functional.conv1d`, `torch.nn.functional.conv2d`, `torch.nn.functional.conv3d`, `torch.nn.modules.conv.Conv1d`, `torch.nn.modules.conv.Conv2d`, `torch.nn.modules.conv.Conv3d`
- **RustTorch:** `rusttorch::nn::ConvConfig`, `rusttorch::nn::Conv1d`, `rusttorch::nn::Conv2d`, `rusttorch::nn::Conv3d`, `rusttorch::nn::functional::conv1d`, `rusttorch::nn::functional::conv2d`, `rusttorch::nn::functional::conv3d`
- **Implementation:** RustTorch frontend backed by LibTorch
- **Pinned inventory:** 9 identities ([exact mapping](../compat/pytorch_inventory_map.toml)); disposition only, not a support claim.
- **Scope:** Fallible one-, two-, and three-dimensional convolution with batched or unbatched inputs, per-axis kernel/stride/zero-padding/dilation, channel groups, optional bias, fan-in uniform initialization, stable parameter names, and Sequential composition.
- **Pinned source:** [`torch/nn/modules/conv.py`](https://github.com/pytorch/pytorch/blob/cf30153/torch/nn/modules/conv.py)
- **Evidence:** [`tests/nn_layers.rs::grouped_convolution_respects_stride_padding_dilation_and_gradients`](../tests/nn_layers.rs), [`tests/nn_layers.rs::image_and_volume_convolutions_accept_unbatched_inputs`](../tests/nn_layers.rs), [`tests/nn_layers.rs::convolution_initialization_uses_fan_in_and_rejects_invalid_configuration`](../tests/nn_layers.rs), [`tests/nn_layers.rs::sequential_builds_image_and_token_models_with_registered_parameters`](../tests/nn_layers.rs), [`tests/python_parity.rs::bidirectional_python_parity`](../tests/python_parity.rs), [`tests/nn_layers.rs::invalid_parameter_dtype_returns_errors_without_poisoning_the_store`](../tests/nn_layers.rs), [`tests/nn_layers.rs::undefined_tensors_are_rejected_without_metadata_panics`](../tests/nn_layers.rs)
- **Notes:** String padding and nonzero padding modes remain unimplemented. Transposed convolutions have their own nn.convolution.transposed row. Numerical evidence is CPU only; other devices are not newly claimed.

### `nn.convolution.transposed`

- **PyTorch:** `torch.nn.ConvTranspose1d`, `torch.nn.ConvTranspose2d`, `torch.nn.ConvTranspose3d`, `torch.nn.modules.conv.ConvTranspose1d`, `torch.nn.modules.conv.ConvTranspose2d`, `torch.nn.modules.conv.ConvTranspose3d`
- **RustTorch:** `rusttorch::nn::ConvTransposeConfig`, `rusttorch::nn::ConvTranspose`, `rusttorch::nn::ConvTranspose1d`, `rusttorch::nn::ConvTranspose2d`, `rusttorch::nn::ConvTranspose3d`, `rusttorch::nn::ConvTranspose::forward_with_output_size`
- **Implementation:** RustTorch frontend backed by LibTorch
- **Pinned inventory:** 6 identities ([exact mapping](../compat/pytorch_inventory_map.toml)); disposition only, not a support claim.
- **Scope:** Fallible one-, two-, and three-dimensional transposed convolutions with optional batch, groups, per-axis stride/padding/output padding/dilation, optional bias, weight-before-bias fan-in uniform initialization, and requested spatial/full output-size resolution. CPU fixtures compare initialization, grouped numerical outputs and input/parameter gradients.
- **Pinned source:** [`torch/nn/modules/conv.py`](https://github.com/pytorch/pytorch/blob/cf30153/torch/nn/modules/conv.py)
- **Evidence:** [`tests/nn_spatial.rs::transposed_convolution_initialization_output_size_and_validation`](../tests/nn_spatial.rs), [`tests/nn_spatial.rs::spatial_layers_match_pinned_python_outputs_gradients_and_buffers`](../tests/nn_spatial.rs)
- **Notes:** Only zero padding is exposed; standalone functional wrappers, lazy variants, and full dtype/backend coverage are not claimed. Full output-size batch/channel entries do not affect padding resolution. Invalid options, channel counts and output-size ranges return errors.

### `nn.cross_entropy`

- **PyTorch:** `torch.nn.functional.cross_entropy`
- **RustTorch:** `rusttorch::nn::functional::cross_entropy`, `rusttorch::nn::functional::CrossEntropyOptions`, `rusttorch::nn::functional::cross_entropy_with_options`
- **Implementation:** RustTorch frontend backed by LibTorch
- **Pinned inventory:** 1 identities ([exact mapping](../compat/pytorch_inventory_map.toml)); disposition only, not a support claim.
- **Scope:** Class-index and probability-target cross entropy from raw logits, optional class weights, ignored class labels, label smoothing in \[0, 1\], and None/Mean/Sum reductions. CPU fixtures cover weighted/smoothed class indices, probability targets, loss values and input gradients.
- **Pinned source:** [`torch/nn/functional.py`](https://github.com/pytorch/pytorch/blob/cf30153/torch/nn/functional.py)
- **Evidence:** [`tests/eager.rs::mse_and_cross_entropy_have_deterministic_values`](../tests/eager.rs), [`tests/training_losses.rs::binary_and_weighted_classification_losses_backpropagate`](../tests/training_losses.rs), [`tests/training_losses.rs::loss_validation_rejects_invalid_settings_and_undefined_tensors`](../tests/training_losses.rs), [`tests/training_losses.rs::configured_losses_match_python_values_and_gradients`](../tests/training_losses.rs)
- **Notes:** Probability-target normalization is the caller responsibility. Rust options replace deprecated size\_average/reduce arguments; a stateful CrossEntropyLoss wrapper and the full spatial/dtype/backend matrix are not claimed. Python parity runs through scripts/run-python-parity.sh.

### `nn.dropout`

- **PyTorch:** `torch.nn.Dropout`, `torch.nn.functional.dropout`, `torch.nn.modules.dropout.Dropout`
- **RustTorch:** `rusttorch::nn::Dropout`, `rusttorch::nn::functional::dropout`
- **Implementation:** RustTorch frontend backed by LibTorch
- **Pinned inventory:** 3 identities ([exact mapping](../compat/pytorch_inventory_map.toml)); disposition only, not a support claim.
- **Scope:** Validated probabilities, explicit functional mode, module train/eval behavior, boundary probabilities, and evaluation gradients.
- **Pinned source:** [`torch/nn/modules/dropout.py`](https://github.com/pytorch/pytorch/blob/cf30153/torch/nn/modules/dropout.py)
- **Evidence:** [`tests/eager.rs::dropout_boundary_probabilities_and_eval_gradients_are_correct`](../tests/eager.rs)
- **Notes:** The full stochastic distribution, all shapes and dtypes, and backend parity are not claimed.

### `nn.embedding`

- **PyTorch:** `torch.nn.Embedding`, `torch.nn.functional.embedding`, `torch.nn.modules.sparse.Embedding`
- **RustTorch:** `rusttorch::nn::Embedding`, `rusttorch::nn::EmbeddingConfig`, `rusttorch::nn::functional::embedding`
- **Implementation:** RustTorch frontend backed by LibTorch
- **Pinned inventory:** 3 identities ([exact mapping](../compat/pytorch_inventory_map.toml)); disposition only, not a support claim.
- **Scope:** Trainable embedding lookup with normal initialization, checked integer indices, optional normalized negative padding index with a zero-initialized padding row, padding gradient exclusion, frequency-scaled dense gradients or sparse gradients, stable parameters, and Sequential composition.
- **Pinned source:** [`torch/nn/modules/sparse.py`](https://github.com/pytorch/pytorch/blob/cf30153/torch/nn/modules/sparse.py)
- **Evidence:** [`tests/nn_layers.rs::embedding_padding_frequency_scaling_sparse_gradients_and_indices_are_checked`](../tests/nn_layers.rs), [`tests/nn_layers.rs::sequential_builds_image_and_token_models_with_registered_parameters`](../tests/nn_layers.rs), [`tests/python_parity.rs::bidirectional_python_parity`](../tests/python_parity.rs), [`tests/nn_layers.rs::invalid_parameter_dtype_returns_errors_without_poisoning_the_store`](../tests/nn_layers.rs), [`tests/nn_layers.rs::undefined_tensors_are_rejected_without_metadata_panics`](../tests/nn_layers.rs)
- **Notes:** max\_norm, norm\_type and EmbeddingBag remain unimplemented. Sparse plus frequency-scaled gradients is rejected before use. CPU initialization, forward and gradient parity runs through scripts/run-python-parity.sh.

### `nn.gelu`

- **PyTorch:** `torch.nn.GELU`, `torch.nn.functional.gelu`, `torch.nn.modules.activation.GELU`
- **RustTorch:** `rusttorch::nn::Gelu`, `rusttorch::nn::GeluApproximation`, `rusttorch::nn::functional::gelu`, `rusttorch::nn::functional::gelu_with_approximation`
- **Implementation:** Delegated to LibTorch
- **Pinned inventory:** 3 identities ([exact mapping](../compat/pytorch_inventory_map.toml)); disposition only, not a support claim.
- **Scope:** Exact GELU forward values for the tested default approximation.
- **Pinned source:** [`torch/nn/modules/activation.py`](https://github.com/pytorch/pytorch/blob/cf30153/torch/nn/modules/activation.py)
- **Evidence:** [`tests/eager.rs::identity_relu_gelu_and_flatten_match_expected_behavior`](../tests/eager.rs)
- **Notes:** GeluApproximation::Tanh is exposed but lacks focused numerical and gradient evidence.

### `nn.losses.binary_cross_entropy`

- **PyTorch:** `torch.nn.functional.binary_cross_entropy`, `torch.nn.functional.binary_cross_entropy_with_logits`
- **RustTorch:** `rusttorch::nn::functional::binary_cross_entropy`, `rusttorch::nn::functional::binary_cross_entropy_with_logits`
- **Implementation:** RustTorch frontend backed by LibTorch
- **Pinned inventory:** 2 identities ([exact mapping](../compat/pytorch_inventory_map.toml)); disposition only, not a support claim.
- **Scope:** Binary cross entropy from probabilities or directly from logits with matching input/target shapes, optional native-broadcast loss weights, positive-class weights for logits, and None/Mean/Sum reductions. CPU weighted loss and gradient fixtures cover both operations.
- **Pinned source:** [`torch/nn/functional.py`](https://github.com/pytorch/pytorch/blob/cf30153/torch/nn/functional.py)
- **Evidence:** [`tests/training_losses.rs::binary_and_weighted_classification_losses_backpropagate`](../tests/training_losses.rs), [`tests/training_losses.rs::loss_validation_rejects_invalid_settings_and_undefined_tensors`](../tests/training_losses.rs), [`tests/training_losses.rs::configured_losses_match_python_values_and_gradients`](../tests/training_losses.rs)
- **Notes:** Standalone BCELoss/BCEWithLogitsLoss modules, deprecated reduction flags and exhaustive dtype/backend/weight-broadcast coverage are not claimed. Target validity and native probability-range checks follow the underlying operation; this row does not establish all boundary cases.

### `nn.losses.nll`

- **PyTorch:** `torch.nn.functional.nll_loss`
- **RustTorch:** `rusttorch::nn::functional::nll_loss`
- **Implementation:** RustTorch frontend backed by LibTorch
- **Pinned inventory:** 1 identities ([exact mapping](../compat/pytorch_inventory_map.toml)); disposition only, not a support claim.
- **Scope:** Negative log likelihood from log-probabilities and integer targets with optional class weights, an ignore index and None/Mean/Sum reductions. The native rank-general operation is exposed; CPU batched weighted/ignored-label values and input gradients are verified.
- **Pinned source:** [`torch/nn/functional.py`](https://github.com/pytorch/pytorch/blob/cf30153/torch/nn/functional.py)
- **Evidence:** [`tests/training_losses.rs::binary_and_weighted_classification_losses_backpropagate`](../tests/training_losses.rs), [`tests/training_losses.rs::loss_validation_rejects_invalid_settings_and_undefined_tensors`](../tests/training_losses.rs), [`tests/training_losses.rs::configured_losses_match_python_values_and_gradients`](../tests/training_losses.rs)
- **Notes:** A stateful NLLLoss module, deprecated reduction flags and exhaustive unbatched/spatial/dtype/backend parity remain outside the evidence.

### `nn.losses.regression`

- **PyTorch:** `torch.nn.functional.l1_loss`, `torch.nn.functional.smooth_l1_loss`, `torch.nn.functional.huber_loss`
- **RustTorch:** `rusttorch::nn::functional::l1_loss`, `rusttorch::nn::functional::smooth_l1_loss`, `rusttorch::nn::functional::huber_loss`
- **Implementation:** RustTorch frontend backed by LibTorch
- **Pinned inventory:** 3 identities ([exact mapping](../compat/pytorch_inventory_map.toml)); disposition only, not a support claim.
- **Scope:** Absolute, smooth-L1 and Huber regression objectives with None/Mean/Sum reductions, native broadcasting, finite nonnegative beta for smooth L1 and finite positive delta for Huber. CPU tests cover transition behavior, beta zero, loss values and input gradients.
- **Pinned source:** [`torch/nn/functional.py`](https://github.com/pytorch/pytorch/blob/cf30153/torch/nn/functional.py)
- **Evidence:** [`tests/training_losses.rs::regression_losses_cover_reductions_transitions_and_gradients`](../tests/training_losses.rs), [`tests/training_losses.rs::loss_validation_rejects_invalid_settings_and_undefined_tensors`](../tests/training_losses.rs), [`tests/training_losses.rs::configured_losses_match_python_values_and_gradients`](../tests/training_losses.rs)
- **Notes:** Stateful loss modules, optional per-element weights, deprecated size\_average/reduce flags, and the complete broadcasting/dtype/backend matrix are not exposed or claimed.

### `nn.module`

- **PyTorch:** `torch.nn.Module`, `torch.nn.modules.module.Module`
- **RustTorch:** `rusttorch::nn::Module`, `rusttorch::nn::VarStore`, `rusttorch::nn::ParameterPath`
- **Implementation:** Implemented by RustTorch
- **Pinned inventory:** 2 identities ([exact mapping](../compat/pytorch_inventory_map.toml)); disposition only, not a support claim.
- **Scope:** Send-safe fallible forward/forward\_t dispatch, train/eval state on Sequential and GraphModule, parameter store/path reexports, custom model composition, and registered non-trainable normalization buffers that survive model checkpoints.
- **Pinned source:** [`torch/nn/modules/module.py`](https://github.com/pytorch/pytorch/blob/cf30153/torch/nn/modules/module.py)
- **Evidence:** [`tests/eager.rs::sequential_uses_numeric_parameter_names_and_tracks_mode`](../tests/eager.rs), [`tests/graph.rs::dropout_follows_train_and_eval_mode_without_rng_assumptions`](../tests/graph.rs), [`tests/nn_layers.rs::grouped_convolution_respects_stride_padding_dilation_and_gradients`](../tests/nn_layers.rs), [`tests/nn_spatial.rs::sequential_spatial_factory_trains_and_restores_registered_buffers`](../tests/nn_spatial.rs), [`tests/nn_spatial.rs::normalization_untracked_modes_unbatched_inputs_and_state_roundtrip`](../tests/nn_spatial.rs)
- **Notes:** Named parameters and explicitly registered buffers use VarStore. Python attribute interception, hooks, module traversal, arbitrary child mutation and class reconstruction are not present. Module::forward defaults to evaluation for the added mode-sensitive layers; Sequential owns its training flag.

### `nn.mse_loss`

- **PyTorch:** `torch.nn.functional.mse_loss`
- **RustTorch:** `rusttorch::nn::functional::mse_loss`, `rusttorch::nn::functional::mse_loss_with_reduction`
- **Implementation:** RustTorch frontend backed by LibTorch
- **Pinned inventory:** 1 identities ([exact mapping](../compat/pytorch_inventory_map.toml)); disposition only, not a support claim.
- **Scope:** Mean-default MSE plus explicit None/Mean/Sum reductions, native broadcast-compatible tensor arithmetic, fallible target/device validation, and CPU loss/gradient fixtures.
- **Pinned source:** [`torch/nn/functional.py`](https://github.com/pytorch/pytorch/blob/cf30153/torch/nn/functional.py)
- **Evidence:** [`tests/eager.rs::mse_and_cross_entropy_have_deterministic_values`](../tests/eager.rs), [`tests/training_losses.rs::regression_losses_cover_reductions_transitions_and_gradients`](../tests/training_losses.rs), [`tests/training_losses.rs::loss_validation_rejects_invalid_settings_and_undefined_tensors`](../tests/training_losses.rs), [`tests/training_losses.rs::configured_losses_match_python_values_and_gradients`](../tests/training_losses.rs)
- **Notes:** Elementwise weighting, deprecated size\_average/reduce flags, a stateful MSELoss wrapper, and exhaustive broadcast/dtype/backend parity are not exposed or claimed.

### `nn.normalization`

- **PyTorch:** `torch.nn.BatchNorm1d`, `torch.nn.BatchNorm2d`, `torch.nn.BatchNorm3d`, `torch.nn.GroupNorm`, `torch.nn.InstanceNorm1d`, `torch.nn.InstanceNorm2d`, `torch.nn.InstanceNorm3d`, `torch.nn.modules.batchnorm.BatchNorm1d`, `torch.nn.modules.batchnorm.BatchNorm2d`, `torch.nn.modules.batchnorm.BatchNorm3d`, `torch.nn.modules.instancenorm.InstanceNorm1d`, `torch.nn.modules.instancenorm.InstanceNorm2d`, `torch.nn.modules.instancenorm.InstanceNorm3d`, `torch.nn.modules.normalization.GroupNorm`
- **RustTorch:** `rusttorch::nn::BatchNormConfig`, `rusttorch::nn::BatchNorm`, `rusttorch::nn::BatchNorm1d`, `rusttorch::nn::BatchNorm2d`, `rusttorch::nn::BatchNorm3d`, `rusttorch::nn::InstanceNormConfig`, `rusttorch::nn::InstanceNorm`, `rusttorch::nn::InstanceNorm1d`, `rusttorch::nn::InstanceNorm2d`, `rusttorch::nn::InstanceNorm3d`, `rusttorch::nn::GroupNormConfig`, `rusttorch::nn::GroupNorm`
- **Implementation:** RustTorch frontend backed by LibTorch
- **Pinned inventory:** 14 identities ([exact mapping](../compat/pytorch_inventory_map.toml)); disposition only, not a support claim.
- **Scope:** BatchNorm1d/2d/3d, InstanceNorm1d/2d/3d and GroupNorm with optional learned scale/bias, checked epsilon/channels, explicit train/eval behavior, and stable state names. Batch/instance tracking registers running\_mean, running\_var and Int64 num\_batches\_tracked buffers; BatchNorm supports exponential or cumulative updates and unbiased running variance. CPU tests cover unbatched instance input, untracked evaluation, reset, gradients, composition and checkpoint restoration.
- **Pinned source:** [`torch/nn/modules/batchnorm.py`](https://github.com/pytorch/pytorch/blob/cf30153/torch/nn/modules/batchnorm.py)
- **Evidence:** [`tests/nn_spatial.rs::batch_norm_tracks_unbiased_variance_cumulative_average_and_eval`](../tests/nn_spatial.rs), [`tests/nn_spatial.rs::normalization_untracked_modes_unbatched_inputs_and_state_roundtrip`](../tests/nn_spatial.rs), [`tests/nn_spatial.rs::normalization_validates_channels_dimensions_and_options`](../tests/nn_spatial.rs), [`tests/nn_spatial.rs::sequential_spatial_factory_trains_and_restores_registered_buffers`](../tests/nn_spatial.rs), [`tests/nn_spatial.rs::spatial_layers_match_pinned_python_outputs_gradients_and_buffers`](../tests/nn_spatial.rs)
- **Notes:** Additional pinned definitions are in torch/nn/modules/instancenorm.py and normalization.py. InstanceNorm momentum=None leaves running statistics unchanged and its batch counter remains zero. Standalone forward evaluates; forward\_t(true) trains. Channel mismatch is an error even for non-affine InstanceNorm, where Python may warn. SyncBatchNorm, lazy variants, functional wrappers and full dtype/backend coverage are not claimed; LayerNorm is separate.

### `nn.normalization.layer_norm`

- **PyTorch:** `torch.nn.LayerNorm`, `torch.nn.functional.layer_norm`, `torch.nn.modules.normalization.LayerNorm`
- **RustTorch:** `rusttorch::nn::LayerNorm`, `rusttorch::nn::LayerNormConfig`, `rusttorch::nn::functional::layer_norm`
- **Implementation:** RustTorch frontend backed by LibTorch
- **Pinned inventory:** 3 identities ([exact mapping](../compat/pytorch_inventory_map.toml)); disposition only, not a support claim.
- **Scope:** Normalization over configured trailing dimensions with validated epsilon, optional learnable affine scale and bias, ones/zeros initialization, registered state, gradients, and Sequential composition.
- **Pinned source:** [`torch/nn/modules/normalization.py`](https://github.com/pytorch/pytorch/blob/cf30153/torch/nn/modules/normalization.py)
- **Evidence:** [`tests/nn_layers.rs::layer_norm_normalizes_trailing_features_and_optional_affine_parameters`](../tests/nn_layers.rs), [`tests/nn_layers.rs::sequential_builds_image_and_token_models_with_registered_parameters`](../tests/nn_layers.rs), [`tests/python_parity.rs::bidirectional_python_parity`](../tests/python_parity.rs), [`tests/nn_layers.rs::invalid_parameter_dtype_returns_errors_without_poisoning_the_store`](../tests/nn_layers.rs), [`tests/nn_layers.rs::undefined_tensors_are_rejected_without_metadata_panics`](../tests/nn_layers.rs)
- **Notes:** CPU evidence covers the tested shapes and affine variants. Zero-sized normalized dimensions are rejected; the full dtype/backend matrix is not claimed.

### `nn.pooling`

- **PyTorch:** `torch.nn.MaxPool1d`, `torch.nn.MaxPool2d`, `torch.nn.MaxPool3d`, `torch.nn.AvgPool1d`, `torch.nn.AvgPool2d`, `torch.nn.AvgPool3d`, `torch.nn.AdaptiveMaxPool1d`, `torch.nn.AdaptiveMaxPool2d`, `torch.nn.AdaptiveMaxPool3d`, `torch.nn.AdaptiveAvgPool1d`, `torch.nn.AdaptiveAvgPool2d`, `torch.nn.AdaptiveAvgPool3d`, `torch.nn.modules.pooling.AdaptiveAvgPool1d`, `torch.nn.modules.pooling.AdaptiveAvgPool2d`, `torch.nn.modules.pooling.AdaptiveAvgPool3d`, `torch.nn.modules.pooling.AdaptiveMaxPool1d`, `torch.nn.modules.pooling.AdaptiveMaxPool2d`, `torch.nn.modules.pooling.AdaptiveMaxPool3d`, `torch.nn.modules.pooling.AvgPool1d`, `torch.nn.modules.pooling.AvgPool2d`, `torch.nn.modules.pooling.AvgPool3d`, `torch.nn.modules.pooling.MaxPool1d`, `torch.nn.modules.pooling.MaxPool2d`, `torch.nn.modules.pooling.MaxPool3d`
- **RustTorch:** `rusttorch::nn::MaxPool`, `rusttorch::nn::MaxPool1d`, `rusttorch::nn::MaxPool2d`, `rusttorch::nn::MaxPool3d`, `rusttorch::nn::AvgPool`, `rusttorch::nn::AvgPool1d`, `rusttorch::nn::AvgPool2d`, `rusttorch::nn::AvgPool3d`, `rusttorch::nn::AdaptiveMaxPool`, `rusttorch::nn::AdaptiveMaxPool1d`, `rusttorch::nn::AdaptiveMaxPool2d`, `rusttorch::nn::AdaptiveMaxPool3d`, `rusttorch::nn::AdaptiveAvgPool`, `rusttorch::nn::AdaptiveAvgPool1d`, `rusttorch::nn::AdaptiveAvgPool2d`, `rusttorch::nn::AdaptiveAvgPool3d`
- **Implementation:** RustTorch frontend backed by LibTorch
- **Pinned inventory:** 24 identities ([exact mapping](../compat/pytorch_inventory_map.toml)); disposition only, not a support claim.
- **Scope:** Max, average, adaptive-max and adaptive-average pooling in one, two and three dimensions with optional batch. Window pools expose strides, validated padding and ceil mode; max pooling adds dilation and source indices, while average pooling supports count\_include\_pad and 2-D/3-D divisor overrides. Adaptive outputs use positive per-axis sizes, with indices for adaptive maxima. CPU numerical fixtures cover outputs, gradients and indices.
- **Pinned source:** [`torch/nn/modules/pooling.py`](https://github.com/pytorch/pytorch/blob/cf30153/torch/nn/modules/pooling.py)
- **Evidence:** [`tests/nn_spatial.rs::pooling_known_values_indices_unbatched_gradients_and_validation`](../tests/nn_spatial.rs), [`tests/nn_spatial.rs::sequential_spatial_factory_trains_and_restores_registered_buffers`](../tests/nn_spatial.rs), [`tests/nn_spatial.rs::spatial_layers_match_pinned_python_outputs_gradients_and_buffers`](../tests/nn_spatial.rs)
- **Notes:** Unpooling, fractional/Lp pooling, lazy variants and standalone functional wrappers are not included. Adaptive None dimensions must be resolved from the input shape by the caller. Divisor override is unavailable in AvgPool1d. No accelerator or full dtype coverage is claimed.

### `nn.recurrent`

- **PyTorch:** `torch.nn.RNN`, `torch.nn.LSTM`, `torch.nn.GRU`, `torch.nn.modules.rnn.GRU`, `torch.nn.modules.rnn.LSTM`, `torch.nn.modules.rnn.RNN`
- **RustTorch:** `rusttorch::nn::RnnActivation`, `rusttorch::nn::RnnConfig`, `rusttorch::nn::Rnn`, `rusttorch::nn::Lstm`, `rusttorch::nn::Gru`
- **Implementation:** RustTorch frontend backed by LibTorch
- **Pinned inventory:** 6 identities ([exact mapping](../compat/pytorch_inventory_map.toml)); disposition only, not a support claim.
- **Scope:** Dense tanh/ReLU RNN, LSTM and GRU with optional explicit initial states, returned final states, unbatched/sequence-first/batch-first layouts, multiple layers, bidirectionality, optional biases, inter-layer training dropout, and LSTM hidden projections. CPU fixtures cover stable parameter names, seeded initialization, outputs, state/input/parameter gradients and carried-state sequence execution.
- **Pinned source:** [`torch/nn/modules/rnn.py`](https://github.com/pytorch/pytorch/blob/cf30153/torch/nn/modules/rnn.py)
- **Evidence:** [`tests/nn_sequence.rs::sequence_parameters_restore_exact_recurrent_states_and_masked_transformer_outputs`](../tests/nn_sequence.rs), [`tests/nn_sequence.rs::recurrent_models_preserve_states_layouts_and_parameter_names`](../tests/nn_sequence.rs), [`tests/nn_sequence.rs::recurrent_streaming_matches_complete_sequences_and_dropout_obeys_mode`](../tests/nn_sequence.rs), [`tests/nn_sequence.rs::recurrent_validation_rejects_undefined_shapes_dtypes_and_bad_configuration`](../tests/nn_sequence.rs), [`tests/nn_sequence.rs::sequence_python_parity`](../tests/nn_sequence.rs)
- **Notes:** Packed sequences, standalone recurrent cells, lazy modules, quantized variants and exhaustive dtype/backend combinations are outside this row. Hidden/cell states retain layers-first layouts independently of input batch layout. Non-LSTM projections and invalid state shapes/types return errors. Numerical evidence is CPU only.

### `nn.sequential`

- **PyTorch:** `torch.nn.Sequential`, `torch.nn.modules.container.Sequential`
- **RustTorch:** `rusttorch::nn::Sequential`, `rusttorch::nn::SequentialBuilder`, `rusttorch::nn::SequentialBuilder::layer`
- **Implementation:** Implemented by RustTorch
- **Pinned inventory:** 2 identities ([exact mapping](../compat/pytorch_inventory_map.toml)); disposition only, not a support claim.
- **Scope:** Ordered model construction with built-in specs or fallible custom layer factories receiving a numbered ParameterPath, numeric parameter/buffer names, eager forward, training-mode propagation, device movement and SafeTensors methods.
- **Pinned source:** [`torch/nn/modules/container.py`](https://github.com/pytorch/pytorch/blob/cf30153/torch/nn/modules/container.py)
- **Evidence:** [`tests/eager.rs::sequential_uses_numeric_parameter_names_and_tracks_mode`](../tests/eager.rs), [`tests/backend_parity.rs::accelerator_safetensors_and_cpu_movement_preserve_model_state`](../tests/backend_parity.rs), [`tests/nn_spatial.rs::sequential_spatial_factory_trains_and_restores_registered_buffers`](../tests/nn_spatial.rs)
- **Notes:** The generic factory composes custom or newly added Module implementations without adding a builder method for every type. Post-construction arbitrary insertion/traversal remains unavailable. Accelerator movement tests skip on unavailable hardware; new model-family numerical evidence is CPU only.

### `nn.transformer`

- **PyTorch:** `torch.nn.Transformer`, `torch.nn.TransformerEncoder`, `torch.nn.TransformerDecoder`, `torch.nn.TransformerEncoderLayer`, `torch.nn.TransformerDecoderLayer`, `torch.nn.modules.transformer.Transformer`, `torch.nn.modules.transformer.TransformerDecoder`, `torch.nn.modules.transformer.TransformerDecoderLayer`, `torch.nn.modules.transformer.TransformerEncoder`, `torch.nn.modules.transformer.TransformerEncoderLayer`
- **RustTorch:** `rusttorch::nn::TransformerActivation`, `rusttorch::nn::TransformerConfig`, `rusttorch::nn::TransformerMasks`, `rusttorch::nn::Transformer`, `rusttorch::nn::TransformerEncoder`, `rusttorch::nn::TransformerDecoder`, `rusttorch::nn::TransformerEncoderLayer`, `rusttorch::nn::TransformerDecoderLayer`
- **Implementation:** RustTorch frontend backed by LibTorch
- **Pinned inventory:** 10 identities ([exact mapping](../compat/pytorch_inventory_map.toml)); disposition only, not a support claim.
- **Scope:** Dense encoder/decoder layers, cloned-parameter-value stacks with independent parameter storage, and complete encoder-decoder models. Exposed options include model/head/feed-forward widths, depths, dropout, ReLU/exact GELU, bias, epsilon, batch-first layouts, pre/post normalization, stack final normalization and explicit source/target/memory masks. CPU fixtures compare loaded-state outputs, input/parameter gradients and mode behavior; standalone layer/stack initialization is separately exercised.
- **Pinned source:** [`torch/nn/modules/transformer.py`](https://github.com/pytorch/pytorch/blob/cf30153/torch/nn/modules/transformer.py)
- **Evidence:** [`tests/nn_sequence.rs::sequence_parameters_restore_exact_recurrent_states_and_masked_transformer_outputs`](../tests/nn_sequence.rs), [`tests/nn_sequence.rs::transformer_stacks_clone_values_without_sharing_parameters_and_train_end_to_end`](../tests/nn_sequence.rs), [`tests/nn_sequence.rs::transformer_modes_masked_rows_and_invalid_inputs_are_fallible`](../tests/nn_sequence.rs), [`tests/nn_sequence.rs::sequence_python_parity`](../tests/nn_sequence.rs)
- **Notes:** Full Transformer allocation/random-consumption order differs from Python, so same-seed full-model initial weights are not claimed identical. Loaded-state numerical parity is distinct from initializer parity. Nested tensor fast paths, custom encoder/decoder objects, arbitrary activation callables, mask inference and the complete dtype/backend matrix are excluded. Embeddings and positional representations are supplied by the caller; numerical evidence is CPU only.

### `nn.utils.clip_grad`

- **PyTorch:** `torch.nn.utils.clip_grad_norm_`, `torch.nn.utils.clip_grad_value_`, `torch.nn.utils.clip_grad.clip_grad_norm_`, `torch.nn.utils.clip_grad.clip_grad_value_`
- **RustTorch:** `rusttorch::optim::Optimizer::clip_grad_norm`, `rusttorch::optim::Optimizer::clip_grad_value`
- **Implementation:** RustTorch frontend backed by LibTorch
- **Pinned inventory:** 4 identities ([exact mapping](../compat/pytorch_inventory_map.toml)); disposition only, not a support claim.
- **Scope:** Validated finite nonnegative gradient limits, combined L2 norm clipping and element-wise value clipping for defined dense gradients, no-op with no gradients, and fallible native operations.
- **Pinned source:** [`torch/nn/utils/clip_grad.py`](https://github.com/pytorch/pytorch/blob/cf30153/torch/nn/utils/clip_grad.py)
- **Evidence:** [`tests/optimizers.rs::gradient_clipping_controls_the_update`](../tests/optimizers.rs), [`tests/optimizers.rs::optimizer_configuration_rejects_nonfinite_and_negative_values`](../tests/optimizers.rs)
- **Notes:** Clipping is exposed on Optimizer rather than as a free tensor-list function. Other norm orders, foreach selection, error\_if\_nonfinite and sparse-gradient support are not claimed.

### `onnx`

- **PyTorch:** `torch.onnx.export`
- **RustTorch:** `rusttorch::deployment::Model::load_onnx`, `rusttorch::deployment::Model::save_onnx`
- **Implementation:** RustTorch frontend backed by LibTorch
- **Pinned inventory:** 1 identities ([exact mapping](../compat/pytorch_inventory_map.toml)); disposition only, not a support claim.
- **Scope:** CPU dense ONNX IR10/default-domain opset18 import/export for Identity, Relu, Sigmoid, Tanh, Add/Sub/Mul, MatMul, Transpose, Concat, axis1 Flatten, constant-shape Reshape, dense Constant and Gemm alpha/beta1 transA0/transB1. Linear lowers to Transpose/MatMul/Add. Official ONNX1.22 checker and reference evaluator verify classifier round trips at batch2/3/8; native tests cover all portable dtypes and the remaining operator shape workflow.
- **Pinned source:** [`torch/onnx/__init__.py`](https://github.com/pytorch/pytorch/blob/cf30153/torch/onnx/__init__.py)
- **Evidence:** [`tests/deployment.rs::python_pt2_onnx_and_torchscript_numerical_round_trips`](../tests/deployment.rs), [`tests/deployment.rs::all_portable_dtypes_and_operator_shapes_round_trip`](../tests/deployment.rs), [`tests/deployment.rs::onnx_rejects_malformed_shapes_unknown_fields_and_versions`](../tests/deployment.rs), [`tests/deployment.rs::pt2_and_onnx_native_round_trips_preserve_values_and_guards`](../tests/deployment.rs)
- **Notes:** This is explicit graph interchange, not Python capture or complete torch.onnx.export signature parity. ONNX schema provenance: onnx1.22.0 commit2bb50465112feca9003e1ed654d77f01ff1415ca, onnx/onnx.proto, Apache-2.0. Protobuf decoding uses prost0.14.4 with preflight field limits. Inputs/outputs use tensor metadata; RustTorch range guards and calling trees are versioned extra metadata, not automatic enforcement by other runtimes. Initializers are inference constants; parameter roles and shared state storage are not portable. External files, sparse/quantized tensors, custom domains/functions, training/device configuration and control flow are rejected.

### `optim.adadelta`

- **PyTorch:** `torch.optim.Adadelta`, `torch.optim.adadelta.Adadelta`
- **RustTorch:** `rusttorch::optim::Adadelta`, `rusttorch::optim::Optimizer`
- **Implementation:** RustTorch frontend backed by LibTorch
- **Pinned inventory:** 2 identities ([exact mapping](../compat/pytorch_inventory_map.toml)); disposition only, not a support claim.
- **Scope:** Dense Adadelta with rho, epsilon, coupled weight decay and running squared-gradient/update averages, per-parameter update counters, undefined-gradient skipping, per-group learning rates/decay and checkpointable named moments. CPU Double fixtures compare parameter trajectories and moment tensors over eight steps with group-rate changes and omitted gradients.
- **Pinned source:** [`torch/optim/adadelta.py`](https://github.com/pytorch/pytorch/blob/cf30153/torch/optim/adadelta.py)
- **Evidence:** [`tests/optim_state.rs::all_optimizer_moments_and_group_settings_resume_exactly_at_every_step`](../tests/optim_state.rs), [`tests/optim_state.rs::optimizer_checkpoint_validation_rejects_corruption_before_any_mutation`](../tests/optim_state.rs), [`tests/optim_state.rs::pinned_python_optimizer_and_scheduler_parity`](../tests/optim_state.rs)
- **Notes:** Dense Float/Double/Half/BFloat16 parameter storage is accepted, but the new numerical evidence is CPU Double only. Sparse updates, complex parameters, native foreach/fused/capturable/differentiable/maximize variants, closures and per-group algorithm-specific hyperparameters are not implemented. The Rust checkpoint format is distinct from Python optimizer state\_dict layout.

### `optim.adagrad`

- **PyTorch:** `torch.optim.Adagrad`, `torch.optim.adagrad.Adagrad`
- **RustTorch:** `rusttorch::optim::Adagrad`, `rusttorch::optim::Optimizer`
- **Implementation:** RustTorch frontend backed by LibTorch
- **Pinned inventory:** 2 identities ([exact mapping](../compat/pytorch_inventory_map.toml)); disposition only, not a support claim.
- **Scope:** Dense Adagrad with epsilon, coupled weight decay, learning-rate decay and initial accumulated squared gradients, per-parameter update counters, undefined-gradient skipping, per-group learning rates/decay and checkpointable named moments. CPU Double fixtures compare parameter trajectories and moment tensors over eight steps with group-rate changes and omitted gradients.
- **Pinned source:** [`torch/optim/adagrad.py`](https://github.com/pytorch/pytorch/blob/cf30153/torch/optim/adagrad.py)
- **Evidence:** [`tests/optim_state.rs::all_optimizer_moments_and_group_settings_resume_exactly_at_every_step`](../tests/optim_state.rs), [`tests/optim_state.rs::optimizer_checkpoint_validation_rejects_corruption_before_any_mutation`](../tests/optim_state.rs), [`tests/optim_state.rs::pinned_python_optimizer_and_scheduler_parity`](../tests/optim_state.rs)
- **Notes:** Dense Float/Double/Half/BFloat16 parameter storage is accepted, but the new numerical evidence is CPU Double only. Sparse updates, complex parameters, native foreach/fused/capturable/differentiable/maximize variants, closures and per-group algorithm-specific hyperparameters are not implemented. The Rust checkpoint format is distinct from Python optimizer state\_dict layout.

### `optim.adam`

- **PyTorch:** `torch.optim.Adam`, `torch.optim.adam.Adam`
- **RustTorch:** `rusttorch::optim::Adam`, `rusttorch::optim::Optimizer`
- **Implementation:** RustTorch frontend backed by LibTorch
- **Pinned inventory:** 2 identities ([exact mapping](../compat/pytorch_inventory_map.toml)); disposition only, not a support claim.
- **Scope:** Dense Adam with beta1/beta2 moments, epsilon, coupled weight decay and optional AMSGrad. RustTorch stages validated updates using fallible tensor operations, tracks per-parameter steps/moments, skips undefined gradients before decay, supports named learning-rate/decay groups and saves resumable state. CPU parity covers eight updates, changing group rates and omitted gradients.
- **Pinned source:** [`torch/optim/adam.py`](https://github.com/pytorch/pytorch/blob/cf30153/torch/optim/adam.py)
- **Evidence:** [`tests/eager.rs::sgd_and_adam_each_update_a_parameter_once`](../tests/eager.rs), [`tests/eager.rs::invalid_layer_dropout_and_optimizer_configs_are_rejected`](../tests/eager.rs), [`tests/python_parity.rs::bidirectional_python_parity`](../tests/python_parity.rs), [`tests/optim_state.rs::all_optimizer_moments_and_group_settings_resume_exactly_at_every_step`](../tests/optim_state.rs), [`tests/optim_state.rs::dynamic_registration_and_undefined_gradients_preserve_group_and_skip_semantics`](../tests/optim_state.rs), [`tests/optim_state.rs::gradient_validation_and_sparse_rejection_happen_before_any_update`](../tests/optim_state.rs), [`tests/optim_state.rs::pinned_python_optimizer_and_scheduler_parity`](../tests/optim_state.rs)
- **Notes:** Update orchestration and state are implemented by RustTorch over LibTorch tensor kernels; COptimizer is used only to clear gradients to undefined. Native foreach/fused/capturable/differentiable/maximize variants, closure-driven steps and group-specific algorithm hyperparameters are not exposed. Supported parameter storage is Float/Double/Half/BFloat16, while new numerical evidence is CPU Double and existing Float cases; a full dtype/backend matrix is not claimed.

### `optim.adamax`

- **PyTorch:** `torch.optim.Adamax`, `torch.optim.adamax.Adamax`
- **RustTorch:** `rusttorch::optim::Adamax`, `rusttorch::optim::Optimizer`
- **Implementation:** RustTorch frontend backed by LibTorch
- **Pinned inventory:** 2 identities ([exact mapping](../compat/pytorch_inventory_map.toml)); disposition only, not a support claim.
- **Scope:** Dense Adamax with beta moments, epsilon, coupled weight decay and infinity-norm moment updates, per-parameter update counters, undefined-gradient skipping, per-group learning rates/decay and checkpointable named moments. CPU Double fixtures compare parameter trajectories and moment tensors over eight steps with group-rate changes and omitted gradients.
- **Pinned source:** [`torch/optim/adamax.py`](https://github.com/pytorch/pytorch/blob/cf30153/torch/optim/adamax.py)
- **Evidence:** [`tests/optim_state.rs::all_optimizer_moments_and_group_settings_resume_exactly_at_every_step`](../tests/optim_state.rs), [`tests/optim_state.rs::optimizer_checkpoint_validation_rejects_corruption_before_any_mutation`](../tests/optim_state.rs), [`tests/optim_state.rs::pinned_python_optimizer_and_scheduler_parity`](../tests/optim_state.rs)
- **Notes:** Dense Float/Double/Half/BFloat16 parameter storage is accepted, but the new numerical evidence is CPU Double only. Sparse updates, complex parameters, native foreach/fused/capturable/differentiable/maximize variants, closures and per-group algorithm-specific hyperparameters are not implemented. The Rust checkpoint format is distinct from Python optimizer state\_dict layout.

### `optim.adamw`

- **PyTorch:** `torch.optim.AdamW`, `torch.optim.adamw.AdamW`
- **RustTorch:** `rusttorch::optim::AdamW`, `rusttorch::optim::Optimizer`
- **Implementation:** RustTorch frontend backed by LibTorch
- **Pinned inventory:** 2 identities ([exact mapping](../compat/pytorch_inventory_map.toml)); disposition only, not a support claim.
- **Scope:** Dense AdamW with beta1/beta2 moments, epsilon, decoupled weight decay (default 0.01) and optional AMSGrad. RustTorch stages validated updates using fallible tensor operations, tracks per-parameter steps/moments, skips undefined gradients before decay, supports named learning-rate/decay groups and saves resumable state. CPU parity covers eight updates, changing group rates and omitted gradients.
- **Pinned source:** [`torch/optim/adamw.py`](https://github.com/pytorch/pytorch/blob/cf30153/torch/optim/adamw.py)
- **Evidence:** [`tests/optimizers.rs::adamw_applies_decoupled_decay_and_tracks_moments`](../tests/optimizers.rs), [`tests/optimizers.rs::optimizer_configuration_rejects_nonfinite_and_negative_values`](../tests/optimizers.rs), [`tests/python_parity.rs::bidirectional_python_parity`](../tests/python_parity.rs), [`tests/optim_state.rs::all_optimizer_moments_and_group_settings_resume_exactly_at_every_step`](../tests/optim_state.rs), [`tests/optim_state.rs::dynamic_registration_and_undefined_gradients_preserve_group_and_skip_semantics`](../tests/optim_state.rs), [`tests/optim_state.rs::gradient_validation_and_sparse_rejection_happen_before_any_update`](../tests/optim_state.rs), [`tests/optim_state.rs::pinned_python_optimizer_and_scheduler_parity`](../tests/optim_state.rs)
- **Notes:** Update orchestration and state are implemented by RustTorch over LibTorch tensor kernels; COptimizer is used only to clear gradients to undefined. Native foreach/fused/capturable/differentiable/maximize variants, closure-driven steps and group-specific algorithm hyperparameters are not exposed. Supported parameter storage is Float/Double/Half/BFloat16, while new numerical evidence is CPU Double and existing Float cases; a full dtype/backend matrix is not claimed.

### `optim.learning_rate`

- **PyTorch:** `torch.optim.Optimizer.param_groups`
- **RustTorch:** `rusttorch::optim::ParameterGroup`, `rusttorch::optim::Optimizer::parameter_groups`, `rusttorch::optim::Optimizer::set_learning_rate`, `rusttorch::optim::Optimizer::set_group_learning_rate`, `rusttorch::optim::Optimizer::set_group_weight_decay`, `rusttorch::optim::Optimizer::named_parameters`
- **Implementation:** Implemented by RustTorch
- **Pinned inventory:** 0 identities ([exact mapping](../compat/pytorch_inventory_map.toml)); disposition only, not a support claim.
- **Scope:** Named parameter groups from VarStore path group IDs, per-group finite nonnegative learning rates and weight decay, all-group learning-rate replacement, stable parameter snapshots, and discovery of later parameter registrations before steps, gradient reset or checkpoint synchronization. Rates and group membership persist in optimizer state.
- **Pinned source:** [`torch/optim/optimizer.py`](https://github.com/pytorch/pytorch/blob/cf30153/torch/optim/optimizer.py)
- **Evidence:** [`tests/optim_state.rs::dynamic_registration_and_undefined_gradients_preserve_group_and_skip_semantics`](../tests/optim_state.rs), [`tests/optim_state.rs::all_optimizer_moments_and_group_settings_resume_exactly_at_every_step`](../tests/optim_state.rs), [`tests/optim_state.rs::optimizer_checkpoint_validation_rejects_corruption_before_any_mutation`](../tests/optim_state.rs), [`tests/optim_state.rs::pinned_python_optimizer_and_scheduler_parity`](../tests/optim_state.rs)
- **Notes:** Algorithm-specific options such as betas and momentum are shared across groups; arbitrary Python param\_groups dictionary mutation is not reproduced. Group IDs and named membership must match during checkpoint loading. Scheduler classes/state are tracked separately in optim.schedulers.

### `optim.rmsprop`

- **PyTorch:** `torch.optim.RMSprop`, `torch.optim.rmsprop.RMSprop`
- **RustTorch:** `rusttorch::optim::RmsProp`, `rusttorch::optim::Optimizer`
- **Implementation:** RustTorch frontend backed by LibTorch
- **Pinned inventory:** 2 identities ([exact mapping](../compat/pytorch_inventory_map.toml)); disposition only, not a support claim.
- **Scope:** Dense RMSprop with squared-gradient averages, epsilon, coupled weight decay, optional momentum and centered statistics. RustTorch stages validated updates using fallible tensor operations, tracks per-parameter steps/moments, skips undefined gradients before decay, supports named learning-rate/decay groups and saves resumable state. CPU parity covers eight updates, changing group rates and omitted gradients.
- **Pinned source:** [`torch/optim/rmsprop.py`](https://github.com/pytorch/pytorch/blob/cf30153/torch/optim/rmsprop.py)
- **Evidence:** [`tests/optimizers.rs::rmsprop_uses_squared_gradient_average`](../tests/optimizers.rs), [`tests/optimizers.rs::optimizer_configuration_rejects_nonfinite_and_negative_values`](../tests/optimizers.rs), [`tests/python_parity.rs::bidirectional_python_parity`](../tests/python_parity.rs), [`tests/optim_state.rs::all_optimizer_moments_and_group_settings_resume_exactly_at_every_step`](../tests/optim_state.rs), [`tests/optim_state.rs::dynamic_registration_and_undefined_gradients_preserve_group_and_skip_semantics`](../tests/optim_state.rs), [`tests/optim_state.rs::gradient_validation_and_sparse_rejection_happen_before_any_update`](../tests/optim_state.rs), [`tests/optim_state.rs::pinned_python_optimizer_and_scheduler_parity`](../tests/optim_state.rs)
- **Notes:** Update orchestration and state are implemented by RustTorch over LibTorch tensor kernels; COptimizer is used only to clear gradients to undefined. Native foreach/fused/capturable/differentiable/maximize variants, closure-driven steps and group-specific algorithm hyperparameters are not exposed. Supported parameter storage is Float/Double/Half/BFloat16, while new numerical evidence is CPU Double and existing Float cases; a full dtype/backend matrix is not claimed. Finite nonnegative alpha follows the pinned RMSprop constructor.

### `optim.schedulers`

- **PyTorch:** `torch.optim.lr_scheduler.StepLR`, `torch.optim.lr_scheduler.ExponentialLR`, `torch.optim.lr_scheduler.MultiStepLR`, `torch.optim.lr_scheduler.CosineAnnealingLR`, `torch.optim.lr_scheduler.ReduceLROnPlateau`
- **RustTorch:** `rusttorch::optim::StepLr`, `rusttorch::optim::ExponentialLr`, `rusttorch::optim::MultiStepLr`, `rusttorch::optim::CosineAnnealingLr`, `rusttorch::optim::ReduceLrOnPlateau`, `rusttorch::optim::PlateauMode`, `rusttorch::optim::ThresholdMode`
- **Implementation:** Implemented by RustTorch
- **Pinned inventory:** 5 identities ([exact mapping](../compat/pytorch_inventory_map.toml)); disposition only, not a support claim.
- **Scope:** Five learning-rate schedulers with explicit post-update/epoch step ordering, epoch and last-rate access, per-group rates and serde state. MultiStep handles repeated/zero milestones, cosine follows the recurring curve, and plateau tracks metric direction, relative/absolute thresholds, patience, cooldown, epsilon and group minima. CPU tests verify numerical schedules and exact restore at every tested epoch.
- **Pinned source:** [`torch/optim/lr_scheduler.py`](https://github.com/pytorch/pytorch/blob/cf30153/torch/optim/lr_scheduler.py)
- **Evidence:** [`tests/optim_state.rs::all_schedulers_resume_exactly_at_every_epoch_including_plateau_cooldown`](../tests/optim_state.rs), [`tests/optim_state.rs::malformed_scheduler_state_and_overflow_cannot_partially_update_groups`](../tests/optim_state.rs), [`tests/optim_state.rs::pinned_python_optimizer_and_scheduler_parity`](../tests/optim_state.rs)
- **Notes:** The full scheduler catalog, chained/sequential composition, arbitrary callable policies, explicit epoch overrides and automatic optimizer-order warnings are not implemented. Parameter-group changes after construction and malformed serialized state are rejected before rate application. Plateau metrics must be finite. Restore optimizer and scheduler state together; no accelerator-specific behavior is newly claimed.

### `optim.sgd`

- **PyTorch:** `torch.optim.SGD`, `torch.optim.sgd.SGD`
- **RustTorch:** `rusttorch::optim::Sgd`, `rusttorch::optim::Optimizer`
- **Implementation:** RustTorch frontend backed by LibTorch
- **Pinned inventory:** 2 identities ([exact mapping](../compat/pytorch_inventory_map.toml)); disposition only, not a support claim.
- **Scope:** SGD with optional momentum, dampening, Nesterov updates and coupled weight decay; plain zero-momentum/zero-decay SGD also accepts sparse COO gradients. RustTorch stages validated updates using fallible tensor operations, tracks per-parameter steps/moments, skips undefined gradients before decay, supports named learning-rate/decay groups and saves resumable state. CPU parity covers eight updates, changing group rates and omitted gradients.
- **Pinned source:** [`torch/optim/sgd.py`](https://github.com/pytorch/pytorch/blob/cf30153/torch/optim/sgd.py)
- **Evidence:** [`tests/eager.rs::sgd_and_adam_each_update_a_parameter_once`](../tests/eager.rs), [`tests/eager.rs::invalid_layer_dropout_and_optimizer_configs_are_rejected`](../tests/eager.rs), [`tests/python_parity.rs::bidirectional_python_parity`](../tests/python_parity.rs), [`tests/optim_state.rs::all_optimizer_moments_and_group_settings_resume_exactly_at_every_step`](../tests/optim_state.rs), [`tests/optim_state.rs::dynamic_registration_and_undefined_gradients_preserve_group_and_skip_semantics`](../tests/optim_state.rs), [`tests/optim_state.rs::gradient_validation_and_sparse_rejection_happen_before_any_update`](../tests/optim_state.rs), [`tests/optim_state.rs::pinned_python_optimizer_and_scheduler_parity`](../tests/optim_state.rs)
- **Notes:** Update orchestration and state are implemented by RustTorch over LibTorch tensor kernels; COptimizer is used only to clear gradients to undefined. Native foreach/fused/capturable/differentiable/maximize variants, closure-driven steps and group-specific algorithm hyperparameters are not exposed. Supported parameter storage is Float/Double/Half/BFloat16, while new numerical evidence is CPU Double and existing Float cases; a full dtype/backend matrix is not claimed.

### `optim.state`

- **PyTorch:** `torch.optim.Optimizer.state_dict`, `torch.optim.Optimizer.load_state_dict`, `torch.optim.Optimizer.zero_grad`, `torch.optim.Optimizer.step`
- **RustTorch:** `rusttorch::optim::OptimizerState`, `rusttorch::optim::Optimizer::state_dict`, `rusttorch::optim::Optimizer::load_state_dict`, `rusttorch::optim::Optimizer::try_zero_grad`, `rusttorch::optim::Optimizer::try_step`, `rusttorch::optim::Optimizer::backward_step`
- **Implementation:** RustTorch frontend backed by LibTorch
- **Pinned inventory:** 4 identities ([exact mapping](../compat/pytorch_inventory_map.toml)); disposition only, not a support claim.
- **Scope:** Versioned serde checkpoints for all seven exposed optimizer families, with algorithm configuration, default/group rates and decay, exact named little-endian moment bytes, parameter shapes/dtypes/group membership and update counters. Complete validation and tensor staging precede restore; invalid gradient/state shapes, dtypes, groups, slot sets, payload lengths and counters return errors. CPU tests resume every tested step exactly, including untouched parameters.
- **Pinned source:** [`torch/optim/optimizer.py`](https://github.com/pytorch/pytorch/blob/cf30153/torch/optim/optimizer.py)
- **Evidence:** [`tests/optim_state.rs::all_optimizer_moments_and_group_settings_resume_exactly_at_every_step`](../tests/optim_state.rs), [`tests/optim_state.rs::optimizer_checkpoint_validation_rejects_corruption_before_any_mutation`](../tests/optim_state.rs), [`tests/optim_state.rs::dynamic_registration_and_undefined_gradients_preserve_group_and_skip_semantics`](../tests/optim_state.rs), [`tests/optim_state.rs::gradient_validation_and_sparse_rejection_happen_before_any_update`](../tests/optim_state.rs), [`tests/optim_state.rs::checkpoint_capture_rejects_parameter_dtype_or_shape_drift`](../tests/optim_state.rs), [`tests/optim_state.rs::pinned_python_optimizer_and_scheduler_parity`](../tests/optim_state.rs)
- **Notes:** The named Rust serde schema is not Python pickle or a torch.optim state\_dict wire format. Checkpoint at a completed step and save model weights separately; gradients, arbitrary objects and distributed/sharded state are excluded. Parameter identities/groups must match and dtype/shape drift is rejected. Allocation/staging failure leaves state untouched; device failure during final parameter copies can still partially update a model.

### `profiler`

- **PyTorch:** `torch.profiler.profile`, `torch.profiler.profiler.profile`, `torch.autograd.profiler.record_function`, `torch.profiler.profile.export_chrome_trace`
- **RustTorch:** `rusttorch::profiling::Profiler`, `rusttorch::profiling::Profiler::span`, `rusttorch::profiling::Profiler::record`, `rusttorch::profiling::Profiler::chrome_trace`
- **Implementation:** Implemented by RustTorch
- **Pinned inventory:** 4 identities ([exact mapping](../compat/pytorch_inventory_map.toml)); disposition only, not a support claim.
- **Scope:** Bounded thread-safe explicit host-region timing with nested RAII spans, completion/error outcomes and Chrome Trace Event JSON. Capacity is reserved before user work; active spans prevent export/clear and label/capacity limits reject invalid input.
- **Pinned source:** [`torch/profiler/profiler.py`](https://github.com/pytorch/pytorch/blob/cf30153/torch/profiler/profiler.py)
- **Evidence:** [`tests/framework_tools.rs::profiles_are_bounded_thread_safe_and_export_only_completed_regions`](../tests/framework_tools.rs)
- **Notes:** Rust application instrumentation and interchange format only. Native operator/kernel interception, accelerator events, schedules, allocation/stack capture and native profiler APIs are not implemented. No overhead or performance improvement claim.

### `reproducibility`

- **PyTorch:** `torch.Generator`, `torch.manual_seed`, `torch.set_num_threads`
- **RustTorch:** `rusttorch::reproducibility::RuntimeConfig`, `rusttorch::reproducibility::TensorRng`, `rusttorch::reproducibility::TensorRngState`
- **Implementation:** RustTorch frontend backed by LibTorch
- **Pinned inventory:** 0 identities ([exact mapping](../compat/pytorch_inventory_map.toml)); disposition only, not a support claim.
- **Scope:** Startup native seed/thread configuration plus separate serializable ChaCha12 task-local uniform and normal CPU generation followed by an explicit device copy. Version/shape/dtype/allocation checks happen before stream advancement; exact same-runtime resume and independence from global native reseeding are tested.
- **Pinned source:** [`torch/random.py`](https://github.com/pytorch/pytorch/blob/cf30153/torch/random.py)
- **Evidence:** [`tests/framework_tools.rs::local_noise_resumes_without_global_rng_and_rejects_limits_without_advancing`](../tests/framework_tools.rs), [`tests/training_checkpoint.rs::atomic_checkpoint_reproduces_next_loader_noise_optimizer_and_schedule_update`](../tests/training_checkpoint.rs)
- **Notes:** TensorRng is an original Rust stream, not torch.Generator/Philox state or sequence compatibility. Native seed configuration is process-global and intended at startup. No full deterministic-algorithm policy, native RNG state capture or cross-platform Box-Muller identity guarantee.

### `serialization.mapping`

- **PyTorch:** `torch.nn.Module.load_state_dict key adaptation`
- **RustTorch:** `rusttorch::interop::StateDictMapping`, `rusttorch::interop::load_state_dict_with_mapping`
- **Implementation:** Implemented by RustTorch
- **Pinned inventory:** 0 identities ([exact mapping](../compat/pytorch_inventory_map.toml)); disposition only, not a support claim.
- **Scope:** Explicit exact-key mapping and tested dry-run validation without fuzzy matching or implicit tensor transforms.
- **Pinned source:** [`torch/nn/modules/module.py`](https://github.com/pytorch/pytorch/blob/cf30153/torch/nn/modules/module.py)
- **Evidence:** [`tests/interop.rs::exact_mapping_loads_the_named_destination`](../tests/interop.rs), [`tests/interop.rs::dry_run_reports_a_load_without_mutating_values`](../tests/interop.rs)
- **Notes:** Prefix mapping is exposed but does not yet have focused executable evidence.

### `serialization.safetensors`

- **PyTorch:** `safetensors.torch.save_file`, `safetensors.torch.load_file`
- **RustTorch:** `rusttorch::interop::save_state_dict`, `rusttorch::interop::load_state_dict`, `rusttorch::nn::Sequential::save_weights`, `rusttorch::nn::Sequential::load_weights`, `rusttorch::graph::GraphModule::save_weights`, `rusttorch::graph::GraphModule::load_weights`
- **Implementation:** RustTorch frontend backed by LibTorch
- **Pinned inventory:** 0 identities ([exact mapping](../compat/pytorch_inventory_map.toml)); disposition only, not a support claim.
- **Scope:** Tested CPU SafeTensors parameter and registered normalization-buffer round trips, including Int64 batch counters, plus gated Python-to-Rust and Rust-to-Python model exchange with architecture supplied separately.
- **Pinned source:** [`torch/nn/modules/module.py`](https://github.com/pytorch/pytorch/blob/cf30153/torch/nn/modules/module.py)
- **Evidence:** [`tests/interop.rs::strict_safetensors_round_trip_restores_all_variables`](../tests/interop.rs), [`tests/python_parity.rs::bidirectional_python_parity`](../tests/python_parity.rs), [`tests/nn_spatial.rs::normalization_untracked_modes_unbatched_inputs_and_state_roundtrip`](../tests/nn_spatial.rs), [`tests/nn_spatial.rs::sequential_spatial_factory_trains_and_restores_registered_buffers`](../tests/nn_spatial.rs)
- **Notes:** Python exchange requires scripts/run-python-parity.sh and is ignored by ordinary Cargo test. Model state loads to the target device; optimizer/scheduler/scaler states use their separate validated serde formats.

### `serialization.state_dict`

- **PyTorch:** `torch.nn.Module.state_dict`, `torch.nn.Module.load_state_dict`
- **RustTorch:** `rusttorch::interop::save_state_dict`, `rusttorch::interop::load_state_dict`, `rusttorch::interop::LoadOptions`, `rusttorch::interop::LoadReport`
- **Implementation:** RustTorch frontend backed by LibTorch
- **Pinned inventory:** 2 identities ([exact mapping](../compat/pytorch_inventory_map.toml)); disposition only, not a support claim.
- **Scope:** Strict and non-strict SafeTensors loads with sorted reports and pre-mutation shape validation, including registered normalization running-statistic buffers and integer batch counters.
- **Pinned source:** [`torch/nn/modules/module.py`](https://github.com/pytorch/pytorch/blob/cf30153/torch/nn/modules/module.py)
- **Evidence:** [`tests/interop.rs::non_strict_load_returns_a_sorted_complete_report`](../tests/interop.rs), [`tests/interop.rs::shape_validation_happens_before_any_variable_is_mutated`](../tests/interop.rs), [`tests/nn_spatial.rs::normalization_untracked_modes_unbatched_inputs_and_state_roundtrip`](../tests/nn_spatial.rs), [`tests/nn_spatial.rs::sequential_spatial_factory_trains_and_restores_registered_buffers`](../tests/nn_spatial.rs)
- **Notes:** This row covers explicitly registered model parameters/buffers, not arbitrary Python attributes, aliases or object reconstruction. Optimizer state uses the separate optim.state serde schema; it is not embedded in model SafeTensors. Other model serialization formats remain outside this claim.

### `serialization.torchscript`

- **PyTorch:** `torch.jit.load`, `torch.jit.save`, `torch.jit.trace`, `torch.jit.ScriptModule`
- **RustTorch:** `rusttorch::deployment::Model::trace`, `rusttorch::deployment::TracedModel::load`, `rusttorch::deployment::TracedModel::save`, `rusttorch::deployment::TracedModel::run`
- **Implementation:** RustTorch frontend backed by LibTorch
- **Pinned inventory:** 0 identities ([exact mapping](../compat/pytorch_inventory_map.toml)); disposition only, not a support claim.
- **Scope:** Actual LibTorch TorchScript execution and persistence through safe tch::CModule. RustTorch traces a supported branch-free single-output portable program with a frozen state copy and retains input dtype/device/shape/range guards in an adjacent versioned sidecar. CPU Float native and pinned Python-to-Rust/Rust-to-Python artifact round trips compare classifier inference.
- **Pinned source:** [`torch/jit/__init__.py`](https://github.com/pytorch/pytorch/blob/cf30153/torch/jit/__init__.py)
- **Evidence:** [`tests/deployment.rs::actual_torchscript_trace_executes_and_reloads_with_guards`](../tests/deployment.rs), [`tests/deployment.rs::python_pt2_onnx_and_torchscript_numerical_round_trips`](../tests/deployment.rs), [`tests/deployment.rs::conditional_executes_one_branch_and_preserves_selected_gradient`](../tests/deployment.rs)
- **Notes:** Only trusted native artifacts may be loaded. No arbitrary Rust function capture, conditional tracing, multi-output trace creation, torch.compile/AOTInductor claim, ScriptModule-to-eager conversion or full Python JIT API parity. The sidecar must accompany its artifact; loading arbitrary native code is not a sandbox.

### `serialization.training_checkpoint`

- **PyTorch:** `Training checkpoint workflow with model, optimizer and application state`
- **RustTorch:** `rusttorch::checkpoint::save`, `rusttorch::checkpoint::TrainingCheckpoint`, `rusttorch::checkpoint::CheckpointLimits`
- **Implementation:** RustTorch frontend backed by LibTorch
- **Pinned inventory:** 0 identities ([exact mapping](../compat/pytorch_inventory_map.toml)); disposition only, not a support claim.
- **Scope:** Bounded versioned three-member ZIP training snapshots containing named SafeTensors weights, typed optimizer state and application JSON. Same-directory hard-link publication refuses overwrite atomically; complete metadata/alias/store validation and tensor/optimizer allocation precede model updates. A full loader/local RNG/scheduler/scaler resume reproduces the next update exactly.
- **Pinned source:** [`torch/serialization.py`](https://github.com/pytorch/pytorch/blob/cf30153/torch/serialization.py)
- **Evidence:** [`tests/training_checkpoint.rs::atomic_checkpoint_reproduces_next_loader_noise_optimizer_and_schedule_update`](../tests/training_checkpoint.rs), [`tests/training_checkpoint.rs::corrupt_mismatched_or_oversized_checkpoints_preserve_existing_models_and_files`](../tests/training_checkpoint.rs), [`tests/training_checkpoint.rs::malformed_boolean_bytes_and_false_member_sizes_fail_before_native_restore`](../tests/training_checkpoint.rs)
- **Notes:** Original Rust format, not torch.save pickle or activation checkpointing. Restore requires the exact model/optimizer store with contiguous compatible tensors. Application state must be validated before restore. Native failure during final device copies may partially update a model; use a fresh model to retain the old one. Same-filesystem hard-link support is required.

### `sparse`

- **PyTorch:** `torch.sparse`, `torch.sparse_coo_tensor`, `torch.sparse.mm`, `torch.Tensor.to_sparse`, `torch.Tensor.to_sparse_csr`, `torch.Tensor.to_dense`
- **RustTorch:** `rusttorch::tensor::sparse_coo_matrix`, `rusttorch::tensor::sparse_matmul`, `rusttorch::Tensor::f_to_sparse_sparse_dim`, `rusttorch::Tensor::f_to_sparse_csr`, `rusttorch::Tensor::f_to_dense`
- **Implementation:** RustTorch frontend backed by LibTorch
- **Pinned inventory:** 6 identities ([exact mapping](../compat/pytorch_inventory_map.toml)); disposition only, not a support claim.
- **Scope:** CPU real two-dimensional COO coordinate construction with explicit shape/kind/device/bounds validation, independent coordinate/value copies and duplicate coalescing, COO/CSR multiplication by dense features, CSR conversion and densification. Structural validation rejects malformed COO/CSR before multiplication. Native dense-to-COO conversion and sparse multiplication retain tested gradients to the dense source and dense feature tensor.
- **Pinned source:** [`torch/sparse/__init__.py`](https://github.com/pytorch/pytorch/blob/cf30153/torch/sparse/__init__.py)
- **Evidence:** [`tests/tensor_workflows.rs::sparse_coo_csr_and_quantized_boundaries`](../tests/tensor_workflows.rs), [`tests/tensor_workflows.rs::malformed_inputs_return_errors_without_mutation`](../tests/tensor_workflows.rs), [`tests/tensor_workflows.rs::empty_nested_and_copy_gradient_boundaries`](../tests/tensor_workflows.rs), [`tests/tensor_workflows.rs::tensor_workflows_python_parity`](../tests/tensor_workflows.rs)
- **Notes:** The tch C++ coordinate factory disconnects value gradients, so sparse\_coo\_matrix rejects requires-grad values; this is an explicit difference from Python torch.sparse\_coo\_tensor. Dense-to-COO conversion provides a separately tested native gradient path. Full COO value-constructor autograd, CSR gradient coverage, CSC/BSR/BSC, arbitrary sparse operations and accelerator parity are not claimed. CSR is beta upstream.

### `special`

- **PyTorch:** `torch.special`, `torch.special.ndtr`, `torch.special.log_ndtr`, `torch.special.gammaln`
- **RustTorch:** `rusttorch::Tensor::f_special_ndtr`, `rusttorch::Tensor::f_special_log_ndtr`, `rusttorch::Tensor::f_special_gammaln`
- **Implementation:** Delegated to LibTorch
- **Pinned inventory:** 4 identities ([exact mapping](../compat/pytorch_inventory_map.toml)); disposition only, not a support claim.
- **Scope:** CPU native standard-normal CDF, stable log-CDF for negative tails, and log-gamma for log-factorial calculations. Float64 numerical fixtures cover all three; CDF gradients and extreme-tail finite log-CDF are tested, and float32 CDF smoke evidence is included.
- **Pinned source:** [`torch/special/__init__.py`](https://github.com/pytorch/pytorch/blob/cf30153/torch/special/__init__.py)
- **Evidence:** [`tests/tensor_workflows.rs::fft_and_special_functions_keep_native_gradients`](../tests/tensor_workflows.rs), [`tests/tensor_workflows.rs::empty_nested_and_copy_gradient_boundaries`](../tests/tensor_workflows.rs), [`tests/tensor_workflows.rs::tensor_workflows_python_parity`](../tests/tensor_workflows.rs)
- **Notes:** Native Tensor methods are used directly without redundant wrappers. Remaining special functions, comprehensive domain/error bounds, every dtype and accelerator parity are not claimed; NaN/infinity/domain behavior remains native.

### `tabular`

- **PyTorch:** `torch.utils.data.Dataset for tabular records`
- **RustTorch:** `rusttorch::tabular::CsvRecords`, `rusttorch::tabular::JsonLines`, `rusttorch::tabular::FittedPreprocessor`, `rusttorch::tabular::TabularDataset`, `rusttorch::tabular::TabularBatch`, `rusttorch::tabular::open_arrow`, `rusttorch::tabular::open_parquet`
- **Implementation:** RustTorch frontend backed by LibTorch
- **Pinned inventory:** 0 identities ([exact mapping](../compat/pytorch_inventory_map.toml)); disposition only, not a support claim.
- **Scope:** Optional rusttorch-tabular bounded CSV and JSONL row iterators, immutable training-fitted mean imputation/population-standardization and sorted categorical IDs, validated versioned fitted-state JSON, typed worker batches, optional Arrow IPC file and Parquet row iteration with metadata/record-batch ceilings.
- **Pinned source:** [`torch/utils/data/dataset.py`](https://github.com/pytorch/pytorch/blob/cf30153/torch/utils/data/dataset.py)
- **Evidence:** [`crates/rusttorch-tabular/tests/pipelines.rs::training_fit_is_immutable_and_worker_batches_match_jsonl`](../crates/rusttorch-tabular/tests/pipelines.rs), [`crates/rusttorch-tabular/tests/pipelines.rs::quoted_csv_newlines_and_typed_json_cells_are_preserved`](../crates/rusttorch-tabular/tests/pipelines.rs), [`crates/rusttorch-tabular/tests/pipelines.rs::invalid_states_records_and_limits_fail_once`](../crates/rusttorch-tabular/tests/pipelines.rs), [`crates/rusttorch-tabular/tests/pipelines.rs::deserialized_schemas_preserve_constructor_invariants_and_wire_shape`](../crates/rusttorch-tabular/tests/pipelines.rs), [`crates/rusttorch-tabular/tests/pipelines.rs::arrow_ipc_rows_equal_csv_and_enforce_batch_budget`](../crates/rusttorch-tabular/tests/pipelines.rs), [`crates/rusttorch-tabular/tests/pipelines.rs::empty_arrow_batches_still_validate_column_names`](../crates/rusttorch-tabular/tests/pipelines.rs), [`crates/rusttorch-tabular/tests/pipelines.rs::parquet_rows_equal_csv_and_metadata_limits_precede_decode`](../crates/rusttorch-tabular/tests/pipelines.rs)
- **Notes:** CSV quoting/newlines and scalar JSON string/number/null values are supported. Columnar types are UTF8/LargeUTF8, Int32/Int64 and Float32/Float64 with nulls; default Parquet support is uncompressed. Optional features keep columnar dependencies out of basic CSV users. Native decoder scratch is not a process-RSS guarantee. Database connectors, nested/dictionary/date columns, arbitrary compression, online refitting and full external dataframe APIs are not claimed.

### `testing`

- **PyTorch:** `torch.testing.assert_close`
- **RustTorch:** `rusttorch::testing::compare`, `rusttorch::testing::assert_close`, `rusttorch::testing::CloseOptions`
- **Implementation:** RustTorch frontend backed by LibTorch
- **Pinned inventory:** 1 identities ([exact mapping](../compat/pytorch_inventory_map.toml)); disposition only, not a support claim.
- **Scope:** Dense tensor metadata validation and mismatch count/first-index diagnostics. Floating/complex values use explicit tolerances and optional equal-NaN behavior; integer/bool comparison is exact, including Int64 values beyond Float64 integer precision. Empty tensors and scalar coordinates are supported; optional cross-device copies are explicit.
- **Pinned source:** [`torch/testing/_comparison.py`](https://github.com/pytorch/pytorch/blob/cf30153/torch/testing/_comparison.py)
- **Evidence:** [`tests/framework_tools.rs::tensor_comparisons_check_metadata_nan_infinity_and_exact_integers`](../tests/framework_tools.rs), [`tests/framework_tools.rs::pinned_python_comparisons_and_gradcheck_match`](../tests/framework_tools.rs)
- **Notes:** CPU numerical fixtures match the documented tolerance cases. Rust returns a structured Result instead of Python assertion messages. Nested containers, sparse/quantized layouts, dtype-specific automatic tolerance tables and full complex-NaN parity are not claimed; no OpInfo framework.

### `testing.gradcheck`

- **PyTorch:** `torch.autograd.gradcheck`
- **RustTorch:** `rusttorch::testing::gradcheck`, `rusttorch::testing::GradcheckOptions`
- **Implementation:** RustTorch frontend backed by LibTorch
- **Pinned inventory:** 1 identities ([exact mapping](../compat/pytorch_inventory_map.toml)); disposition only, not a support claim.
- **Scope:** Bounded full-Jacobian central differences for finite deterministic nonempty dense CPU Float64 functions. Checks analytical/numerical derivative finiteness and metadata, supports noncontiguous inputs through an owned contiguous copy, preserves existing leaf gradients and rejects unrepresentable epsilon or excessive work.
- **Pinned source:** [`torch/autograd/gradcheck.py`](https://github.com/pytorch/pytorch/blob/cf30153/torch/autograd/gradcheck.py)
- **Evidence:** [`tests/framework_tools.rs::finite_differences_accept_correct_gradients_and_reject_surrogates_and_oversized_work`](../tests/framework_tools.rs), [`tests/framework_tools.rs::gradient_check_rejects_matching_infinite_derivatives`](../tests/framework_tools.rs), [`tests/framework_tools.rs::pinned_python_comparisons_and_gradcheck_match`](../tests/framework_tools.rs)
- **Notes:** Pure functions are required. Complex/sparse/stochastic gradcheck, multiple inputs, backward/forward mode option matrices and gradgradcheck are not exposed.

### `text`

- **PyTorch:** `torch.utils.data.Dataset for text samples`
- **RustTorch:** `rusttorch::text::HfTokenizer`, `rusttorch::text::TextDataset`, `rusttorch::text::EncodedSequence`, `rusttorch::text::TextCollator`, `rusttorch::text::TokenBudgetConfig`, `rusttorch::text::TokenBudgetSampler`
- **Implementation:** RustTorch frontend backed by LibTorch
- **Pinned inventory:** 0 identities ([exact mapping](../compat/pytorch_inventory_map.toml)); disposition only, not a support claim.
- **Scope:** Optional rusttorch-text local Hugging Face tokenization, bounded strings/sequences, explicit reject/right-truncation policy, fixed/longest padding, Int64 token/type/attention/special masks, worker DataLoader pipelines, distributed padded-token-cost batch sampling and validated epoch-aware sampler checkpoint restoration.
- **Pinned source:** [`torch/utils/data/dataset.py`](https://github.com/pytorch/pytorch/blob/cf30153/torch/utils/data/dataset.py)
- **Evidence:** [`crates/rusttorch-text/tests/pipelines.rs::tokenizer_to_worker_loader_produces_ids_masks_and_budget_batches`](../crates/rusttorch-text/tests/pipelines.rs), [`crates/rusttorch-text/tests/pipelines.rs::padding_policies_and_limits_reject_invalid_sequences`](../crates/rusttorch-text/tests/pipelines.rs), [`crates/rusttorch-text/tests/pipelines.rs::token_budget_resume_replays_only_remaining_complete_batches`](../crates/rusttorch-text/tests/pipelines.rs), [`crates/rusttorch-text/tests/pipelines.rs::distributed_token_batches_preserve_disjoint_rank_indices`](../crates/rusttorch-text/tests/pipelines.rs), [`crates/rusttorch-text/tests/pipelines.rs::empty_sequences_still_obey_batch_record_and_length_byte_limits`](../crates/rusttorch-text/tests/pipelines.rs)
- **Notes:** The tokenizers crate supplies established tokenizer formats without implicit downloads. This is typed Rust data integration, not torchtext or all tokenizer/model equivalence. Padding IDs and post-special-token truncation policy are explicit. Sampler checkpoints do not promise replay of stochastic tokenizers. Equal rank sample counts may still form unequal numbers of token-budget batches; packed-sequence model kernels and text augmentation are not claimed.

### `utils.benchmark`

- **PyTorch:** `torch.utils.benchmark.Timer`
- **RustTorch:** `rusttorch::profiling::benchmark`, `rusttorch::profiling::BenchmarkOptions`, `rusttorch::profiling::Measurement`
- **Implementation:** Implemented by RustTorch
- **Pinned inventory:** 1 identities ([exact mapping](../compat/pytorch_inventory_map.toml)); disposition only, not a support claim.
- **Scope:** Callable benchmark with bounded warmup/sample counts, explicit device synchronization before and after every invocation, retained output through completion, raw seconds and mean/median/population standard deviation/minimum/maximum statistics.
- **Pinned source:** [`torch/utils/benchmark/utils/timer.py`](https://github.com/pytorch/pytorch/blob/cf30153/torch/utils/benchmark/utils/timer.py)
- **Evidence:** [`tests/framework_tools.rs::benchmarks_warm_up_and_synchronize_each_completed_invocation`](../tests/framework_tools.rs)
- **Notes:** Rust closure timing is the workflow equivalent; Python statement execution, automatic accelerator discovery, adaptive blocked autorange, callgrind and comparison-table tooling are not exposed. The caller owns synchronizing the actual backend.

### `video`

- **PyTorch:** `torch.utils.data.Dataset for video samples`
- **RustTorch:** `rusttorch::codec::MediaDecoder`, `rusttorch::codec::MediaFrame`, `rusttorch::codec::VideoFrame`, `rusttorch::codec::AudioFrame`, `rusttorch::codec::TimeBase`, `rusttorch::codec::Timestamp`, `rusttorch::codec::capabilities`
- **Implementation:** RustTorch frontend backed by LibTorch
- **Pinned inventory:** 0 identities ([exact mapping](../compat/pytorch_inventory_map.toml)); disposition only, not a support claim.
- **Scope:** Optional rusttorch-codec FFmpeg 8 CPU decoding of one selected video or mono/stereo audio stream from regular local files; owned RGB CHW frames and Float audio blocks, rational presentation time, checked seeking with pre-target frame removal, lazy typed batches, cancellation checks between native operations and finite input/output/duration limits.
- **Pinned source:** [`torch/utils/data/dataset.py`](https://github.com/pytorch/pytorch/blob/cf30153/torch/utils/data/dataset.py)
- **Evidence:** [`crates/rusttorch-codec/tests/pipelines.rs::rational_time_is_checked_and_exact`](../crates/rusttorch-codec/tests/pipelines.rs), [`crates/rusttorch-codec/tests/pipelines.rs::cpu_video_streams_batches_and_seeks_with_timestamps`](../crates/rusttorch-codec/tests/pipelines.rs), [`crates/rusttorch-codec/tests/pipelines.rs::native_audio_copies_checked_float_buffers`](../crates/rusttorch-codec/tests/pipelines.rs), [`crates/rusttorch-codec/tests/pipelines.rs::limits_and_missing_streams_fail_explicitly`](../crates/rusttorch-codec/tests/pipelines.rs)
- **Notes:** Choose explicit system or vcpkg linking; no bundled native binaries. Checked fixtures use FFV1 Matroska and PCM WAV. Allowed demuxers include Matroska/WebM, WAV, AVI, MOV/MP4, MP3 and FLAC, with actual codec availability reported from the selected native build. Network/playlist input, hardware decoding, arbitrary multichannel layouts, cross-stream synchronization and exact decoder checkpointing are outside scope. The same four tests also pass against the checksummed FFmpeg 8.1.2 dynamically linked LGPL-only profile from scripts/build-ffmpeg.py; this is Linux/macOS profile support, not Windows native runtime evidence.

### `vision`

- **PyTorch:** `torch.utils.data.Dataset for image samples`
- **RustTorch:** `rusttorch::vision::VisionSample`, `rusttorch::vision::VisionBatch`, `rusttorch::vision::decode_image`, `rusttorch::vision::ImageFolder`, `rusttorch::vision::Mnist`, `rusttorch::vision::Cifar`, `rusttorch::vision::CocoDetection`
- **Implementation:** RustTorch frontend backed by LibTorch
- **Pinned inventory:** 0 identities ([exact mapping](../compat/pytorch_inventory_map.toml)); disposition only, not a support claim.
- **Scope:** Optional rusttorch-vision bounded PNG/JPEG RGB CHW decoding; stable ImageFolder classes and worker loading; local uncompressed MNIST IDX, CIFAR-10/100 binary and COCO detection/keypoint samples; stacked or variable-size batches; resize/crop/flip updating images, XYXY boxes, keypoints and integer masks together.
- **Pinned source:** [`torch/utils/data/dataset.py`](https://github.com/pytorch/pytorch/blob/cf30153/torch/utils/data/dataset.py)
- **Evidence:** [`crates/rusttorch-vision/tests/pipelines.rs::imagefolder_workers_decode_classify_and_bound_payload`](../crates/rusttorch-vision/tests/pipelines.rs), [`crates/rusttorch-vision/tests/pipelines.rs::target_geometry_tracks_image_mask_and_keypoints`](../crates/rusttorch-vision/tests/pipelines.rs), [`crates/rusttorch-vision/tests/pipelines.rs::named_dataset_families_read_real_local_formats`](../crates/rusttorch-vision/tests/pipelines.rs), [`crates/rusttorch-vision/tests/pipelines.rs::malformed_and_oversized_images_fail_without_panics`](../crates/rusttorch-vision/tests/pipelines.rs), [`crates/rusttorch-vision/tests/pipelines.rs::jpeg_decodes_and_integer_masks_keep_large_category_ids`](../crates/rusttorch-vision/tests/pipelines.rs), [`crates/rusttorch-vision/tests/pipelines.rs::vision_sample_footprint_includes_classification_label`](../crates/rusttorch-vision/tests/pipelines.rs), [`crates/rusttorch-vision/tests/pipelines.rs::resize_limit_covers_image_and_integer_mask_together`](../crates/rusttorch-vision/tests/pipelines.rs)
- **Notes:** Original tiny format fixtures establish Rust dataset behavior. No torchvision API equivalence, implicit downloads, archive extraction, pretrained vision models, EXIF/color-profile adjustment, polygon/RLE segmentation, automatic left/right keypoint permutation or accelerator support evidence. Integer nearest-neighbor masks preserve category IDs without float conversion.

## Planned

### `autograd.forward_ad`

- **PyTorch:** `torch.autograd.forward_ad`
- **RustTorch:** —
- **Implementation:** Not implemented
- **Pinned inventory:** 1 identities ([exact mapping](../compat/pytorch_inventory_map.toml)); disposition only, not a support claim.
- **Scope:** Forward-mode automatic differentiation and dual tensors are not exposed.
- **Pinned source:** [`torch/autograd/forward_ad.py`](https://github.com/pytorch/pytorch/blob/cf30153/torch/autograd/forward_ad.py)
- **Evidence:** —
- **Notes:** This row is separate from the currently tested reverse-mode subset.

### `census.aten.fft`

- **PyTorch:** `ATen canonical fft schemas`
- **RustTorch:** —
- **Implementation:** Not implemented
- **Pinned inventory:** 42 identities ([exact mapping](../compat/pytorch_inventory_map.toml)); disposition only, not a support claim.
- **Scope:** Canonical public-name ATen fft schemas mapped here are binding candidates awaiting exact Rust binding and executable compatibility evidence, including declared generated functional/out variants.
- **Pinned source:** [`aten/src/ATen/native/native_functions.yaml`](https://github.com/pytorch/pytorch/blob/cf30153/aten/src/ATen/native/native_functions.yaml)
- **Evidence:** —
- **Notes:** Runtime registration is build availability only; it is not evidence that tch or RustTorch exposes this schema. Exact IDs remain visible in compat/pytorch\_inventory\_map.toml.

### `census.aten.linalg`

- **PyTorch:** `ATen canonical linalg schemas`
- **RustTorch:** —
- **Implementation:** Not implemented
- **Pinned inventory:** 99 identities ([exact mapping](../compat/pytorch_inventory_map.toml)); disposition only, not a support claim.
- **Scope:** Canonical public-name ATen linalg schemas mapped here are binding candidates awaiting exact Rust binding and executable compatibility evidence, including declared generated functional/out variants.
- **Pinned source:** [`aten/src/ATen/native/native_functions.yaml`](https://github.com/pytorch/pytorch/blob/cf30153/aten/src/ATen/native/native_functions.yaml)
- **Evidence:** —
- **Notes:** Runtime registration is build availability only; it is not evidence that tch or RustTorch exposes this schema. Exact IDs remain visible in compat/pytorch\_inventory\_map.toml.

### `census.aten.nested`

- **PyTorch:** `ATen canonical nested schemas`
- **RustTorch:** —
- **Implementation:** Not implemented
- **Pinned inventory:** 1 identities ([exact mapping](../compat/pytorch_inventory_map.toml)); disposition only, not a support claim.
- **Scope:** Canonical public-name ATen nested schemas mapped here are binding candidates awaiting exact Rust binding and executable compatibility evidence, including declared generated functional/out variants.
- **Pinned source:** [`aten/src/ATen/native/native_functions.yaml`](https://github.com/pytorch/pytorch/blob/cf30153/aten/src/ATen/native/native_functions.yaml)
- **Evidence:** —
- **Notes:** Runtime registration is build availability only; it is not evidence that tch or RustTorch exposes this schema. Exact IDs remain visible in compat/pytorch\_inventory\_map.toml.

### `census.aten.operators`

- **PyTorch:** `ATen canonical operators schemas`
- **RustTorch:** —
- **Implementation:** Not implemented
- **Pinned inventory:** 1912 identities ([exact mapping](../compat/pytorch_inventory_map.toml)); disposition only, not a support claim.
- **Scope:** Canonical public-name ATen operators schemas mapped here are binding candidates awaiting exact Rust binding and executable compatibility evidence, including declared generated functional/out variants.
- **Pinned source:** [`aten/src/ATen/native/native_functions.yaml`](https://github.com/pytorch/pytorch/blob/cf30153/aten/src/ATen/native/native_functions.yaml)
- **Evidence:** —
- **Notes:** Runtime registration is build availability only; it is not evidence that tch or RustTorch exposes this schema. Exact IDs remain visible in compat/pytorch\_inventory\_map.toml.

### `census.aten.quantized`

- **PyTorch:** `ATen canonical quantized schemas`
- **RustTorch:** —
- **Implementation:** Not implemented
- **Pinned inventory:** 12 identities ([exact mapping](../compat/pytorch_inventory_map.toml)); disposition only, not a support claim.
- **Scope:** Canonical public-name ATen quantized schemas mapped here are binding candidates awaiting exact Rust binding and executable compatibility evidence, including declared generated functional/out variants.
- **Pinned source:** [`aten/src/ATen/native/native_functions.yaml`](https://github.com/pytorch/pytorch/blob/cf30153/aten/src/ATen/native/native_functions.yaml)
- **Evidence:** —
- **Notes:** Runtime registration is build availability only; it is not evidence that tch or RustTorch exposes this schema. Exact IDs remain visible in compat/pytorch\_inventory\_map.toml.

### `census.aten.sparse`

- **PyTorch:** `ATen canonical sparse schemas`
- **RustTorch:** —
- **Implementation:** Not implemented
- **Pinned inventory:** 25 identities ([exact mapping](../compat/pytorch_inventory_map.toml)); disposition only, not a support claim.
- **Scope:** Canonical public-name ATen sparse schemas mapped here are binding candidates awaiting exact Rust binding and executable compatibility evidence, including declared generated functional/out variants.
- **Pinned source:** [`aten/src/ATen/native/native_functions.yaml`](https://github.com/pytorch/pytorch/blob/cf30153/aten/src/ATen/native/native_functions.yaml)
- **Evidence:** —
- **Notes:** Runtime registration is build availability only; it is not evidence that tch or RustTorch exposes this schema. Exact IDs remain visible in compat/pytorch\_inventory\_map.toml.

### `census.aten.special`

- **PyTorch:** `ATen canonical special schemas`
- **RustTorch:** —
- **Implementation:** Not implemented
- **Pinned inventory:** 170 identities ([exact mapping](../compat/pytorch_inventory_map.toml)); disposition only, not a support claim.
- **Scope:** Canonical public-name ATen special schemas mapped here are binding candidates awaiting exact Rust binding and executable compatibility evidence, including declared generated functional/out variants.
- **Pinned source:** [`aten/src/ATen/native/native_functions.yaml`](https://github.com/pytorch/pytorch/blob/cf30153/aten/src/ATen/native/native_functions.yaml)
- **Evidence:** —
- **Notes:** Runtime registration is build availability only; it is not evidence that tch or RustTorch exposes this schema. Exact IDs remain visible in compat/pytorch\_inventory\_map.toml.

### `census.python.autograd`

- **PyTorch:** `torch.autograd`
- **RustTorch:** —
- **Implementation:** Not implemented
- **Pinned inventory:** 231 identities ([exact mapping](../compat/pytorch_inventory_map.toml)); disposition only, not a support claim.
- **Scope:** Remaining documented torch.autograd inventory identities mapped to this row have no individually evidenced RustTorch compatibility claim. Existing implemented subsets remain in their separate scoped ledger rows.
- **Pinned source:** [`torch/autograd/__init__.py`](https://github.com/pytorch/pytorch/blob/cf30153/torch/autograd/__init__.py)
- **Evidence:** —
- **Notes:** This is an explicit disposition for the exact IDs in compat/pytorch\_inventory\_map.toml. Membership does not imply implementation, complete family coverage, or a compatibility percentage.

### `census.python.compiler`

- **PyTorch:** `torch.compiler, torch.export and torch.fx`
- **RustTorch:** —
- **Implementation:** Not implemented
- **Pinned inventory:** 870 identities ([exact mapping](../compat/pytorch_inventory_map.toml)); disposition only, not a support claim.
- **Scope:** Remaining documented torch.compiler, torch.export and torch.fx inventory identities mapped to this row have no individually evidenced RustTorch compatibility claim. Existing implemented subsets remain in their separate scoped ledger rows.
- **Pinned source:** [`torch/compiler/__init__.py`](https://github.com/pytorch/pytorch/blob/cf30153/torch/compiler/__init__.py)
- **Evidence:** —
- **Notes:** This is an explicit disposition for the exact IDs in compat/pytorch\_inventory\_map.toml. Membership does not imply implementation, complete family coverage, or a compatibility percentage.

### `census.python.data`

- **PyTorch:** `torch.utils.data`
- **RustTorch:** —
- **Implementation:** Not implemented
- **Pinned inventory:** 49 identities ([exact mapping](../compat/pytorch_inventory_map.toml)); disposition only, not a support claim.
- **Scope:** Remaining documented torch.utils.data inventory identities mapped to this row have no individually evidenced RustTorch compatibility claim. Existing implemented subsets remain in their separate scoped ledger rows.
- **Pinned source:** [`torch/utils/data/__init__.py`](https://github.com/pytorch/pytorch/blob/cf30153/torch/utils/data/__init__.py)
- **Evidence:** —
- **Notes:** This is an explicit disposition for the exact IDs in compat/pytorch\_inventory\_map.toml. Membership does not imply implementation, complete family coverage, or a compatibility percentage.

### `census.python.devices`

- **PyTorch:** `torch accelerator and backend namespaces`
- **RustTorch:** —
- **Implementation:** Not implemented
- **Pinned inventory:** 610 identities ([exact mapping](../compat/pytorch_inventory_map.toml)); disposition only, not a support claim.
- **Scope:** Remaining documented torch accelerator and backend namespaces inventory identities mapped to this row have no individually evidenced RustTorch compatibility claim. Existing implemented subsets remain in their separate scoped ledger rows.
- **Pinned source:** [`torch/accelerator/__init__.py`](https://github.com/pytorch/pytorch/blob/cf30153/torch/accelerator/__init__.py)
- **Evidence:** —
- **Notes:** This is an explicit disposition for the exact IDs in compat/pytorch\_inventory\_map.toml. Membership does not imply implementation, complete family coverage, or a compatibility percentage.

### `census.python.distributed`

- **PyTorch:** `torch.distributed`
- **RustTorch:** —
- **Implementation:** Not implemented
- **Pinned inventory:** 938 identities ([exact mapping](../compat/pytorch_inventory_map.toml)); disposition only, not a support claim.
- **Scope:** Remaining documented torch.distributed inventory identities mapped to this row have no individually evidenced RustTorch compatibility claim. Existing implemented subsets remain in their separate scoped ledger rows.
- **Pinned source:** [`torch/distributed/__init__.py`](https://github.com/pytorch/pytorch/blob/cf30153/torch/distributed/__init__.py)
- **Evidence:** —
- **Notes:** This is an explicit disposition for the exact IDs in compat/pytorch\_inventory\_map.toml. Membership does not imply implementation, complete family coverage, or a compatibility percentage.

### `census.python.distributions`

- **PyTorch:** `torch.distributions`
- **RustTorch:** —
- **Implementation:** Not implemented
- **Pinned inventory:** 607 identities ([exact mapping](../compat/pytorch_inventory_map.toml)); disposition only, not a support claim.
- **Scope:** Remaining documented torch.distributions inventory identities mapped to this row have no individually evidenced RustTorch compatibility claim. Existing implemented subsets remain in their separate scoped ledger rows.
- **Pinned source:** [`torch/distributions/__init__.py`](https://github.com/pytorch/pytorch/blob/cf30153/torch/distributions/__init__.py)
- **Evidence:** —
- **Notes:** This is an explicit disposition for the exact IDs in compat/pytorch\_inventory\_map.toml. Membership does not imply implementation, complete family coverage, or a compatibility percentage.

### `census.python.fft`

- **PyTorch:** `torch.fft`
- **RustTorch:** —
- **Implementation:** Not implemented
- **Pinned inventory:** 18 identities ([exact mapping](../compat/pytorch_inventory_map.toml)); disposition only, not a support claim.
- **Scope:** Remaining documented torch.fft inventory identities mapped to this row have no individually evidenced RustTorch compatibility claim. Existing implemented subsets remain in their separate scoped ledger rows.
- **Pinned source:** [`torch/fft/__init__.py`](https://github.com/pytorch/pytorch/blob/cf30153/torch/fft/__init__.py)
- **Evidence:** —
- **Notes:** This is an explicit disposition for the exact IDs in compat/pytorch\_inventory\_map.toml. Membership does not imply implementation, complete family coverage, or a compatibility percentage.

### `census.python.func`

- **PyTorch:** `torch.func`
- **RustTorch:** —
- **Implementation:** Not implemented
- **Pinned inventory:** 15 identities ([exact mapping](../compat/pytorch_inventory_map.toml)); disposition only, not a support claim.
- **Scope:** Remaining documented torch.func inventory identities mapped to this row have no individually evidenced RustTorch compatibility claim. Existing implemented subsets remain in their separate scoped ledger rows.
- **Pinned source:** [`torch/func/__init__.py`](https://github.com/pytorch/pytorch/blob/cf30153/torch/func/__init__.py)
- **Evidence:** —
- **Notes:** This is an explicit disposition for the exact IDs in compat/pytorch\_inventory\_map.toml. Membership does not imply implementation, complete family coverage, or a compatibility percentage.

### `census.python.linalg`

- **PyTorch:** `torch.linalg`
- **RustTorch:** —
- **Implementation:** Not implemented
- **Pinned inventory:** 35 identities ([exact mapping](../compat/pytorch_inventory_map.toml)); disposition only, not a support claim.
- **Scope:** Remaining documented torch.linalg inventory identities mapped to this row have no individually evidenced RustTorch compatibility claim. Existing implemented subsets remain in their separate scoped ledger rows.
- **Pinned source:** [`torch/linalg/__init__.py`](https://github.com/pytorch/pytorch/blob/cf30153/torch/linalg/__init__.py)
- **Evidence:** —
- **Notes:** This is an explicit disposition for the exact IDs in compat/pytorch\_inventory\_map.toml. Membership does not imply implementation, complete family coverage, or a compatibility percentage.

### `census.python.nested`

- **PyTorch:** `torch.nested`
- **RustTorch:** —
- **Implementation:** Not implemented
- **Pinned inventory:** 6 identities ([exact mapping](../compat/pytorch_inventory_map.toml)); disposition only, not a support claim.
- **Scope:** Remaining documented torch.nested inventory identities mapped to this row have no individually evidenced RustTorch compatibility claim. Existing implemented subsets remain in their separate scoped ledger rows.
- **Pinned source:** [`torch/nested/__init__.py`](https://github.com/pytorch/pytorch/blob/cf30153/torch/nested/__init__.py)
- **Evidence:** —
- **Notes:** This is an explicit disposition for the exact IDs in compat/pytorch\_inventory\_map.toml. Membership does not imply implementation, complete family coverage, or a compatibility percentage.

### `census.python.nn`

- **PyTorch:** `torch.nn`
- **RustTorch:** —
- **Implementation:** Not implemented
- **Pinned inventory:** 1179 identities ([exact mapping](../compat/pytorch_inventory_map.toml)); disposition only, not a support claim.
- **Scope:** Remaining documented torch.nn inventory identities mapped to this row have no individually evidenced RustTorch compatibility claim. Existing implemented subsets remain in their separate scoped ledger rows.
- **Pinned source:** [`torch/nn/__init__.py`](https://github.com/pytorch/pytorch/blob/cf30153/torch/nn/__init__.py)
- **Evidence:** —
- **Notes:** This is an explicit disposition for the exact IDs in compat/pytorch\_inventory\_map.toml. Membership does not imply implementation, complete family coverage, or a compatibility percentage.

### `census.python.onnx`

- **PyTorch:** `torch.onnx`
- **RustTorch:** —
- **Implementation:** Not implemented
- **Pinned inventory:** 67 identities ([exact mapping](../compat/pytorch_inventory_map.toml)); disposition only, not a support claim.
- **Scope:** Remaining documented torch.onnx inventory identities mapped to this row have no individually evidenced RustTorch compatibility claim. Existing implemented subsets remain in their separate scoped ledger rows.
- **Pinned source:** [`torch/onnx/__init__.py`](https://github.com/pytorch/pytorch/blob/cf30153/torch/onnx/__init__.py)
- **Evidence:** —
- **Notes:** This is an explicit disposition for the exact IDs in compat/pytorch\_inventory\_map.toml. Membership does not imply implementation, complete family coverage, or a compatibility percentage.

### `census.python.optim`

- **PyTorch:** `torch.optim`
- **RustTorch:** —
- **Implementation:** Not implemented
- **Pinned inventory:** 520 identities ([exact mapping](../compat/pytorch_inventory_map.toml)); disposition only, not a support claim.
- **Scope:** Remaining documented torch.optim inventory identities mapped to this row have no individually evidenced RustTorch compatibility claim. Existing implemented subsets remain in their separate scoped ledger rows.
- **Pinned source:** [`torch/optim/__init__.py`](https://github.com/pytorch/pytorch/blob/cf30153/torch/optim/__init__.py)
- **Evidence:** —
- **Notes:** This is an explicit disposition for the exact IDs in compat/pytorch\_inventory\_map.toml. Membership does not imply implementation, complete family coverage, or a compatibility percentage.

### `census.python.profiler`

- **PyTorch:** `torch.profiler`
- **RustTorch:** —
- **Implementation:** Not implemented
- **Pinned inventory:** 26 identities ([exact mapping](../compat/pytorch_inventory_map.toml)); disposition only, not a support claim.
- **Scope:** Remaining documented torch.profiler inventory identities mapped to this row have no individually evidenced RustTorch compatibility claim. Existing implemented subsets remain in their separate scoped ledger rows.
- **Pinned source:** [`torch/profiler/__init__.py`](https://github.com/pytorch/pytorch/blob/cf30153/torch/profiler/__init__.py)
- **Evidence:** —
- **Notes:** This is an explicit disposition for the exact IDs in compat/pytorch\_inventory\_map.toml. Membership does not imply implementation, complete family coverage, or a compatibility percentage.

### `census.python.quantization`

- **PyTorch:** `torch.ao`
- **RustTorch:** —
- **Implementation:** Not implemented
- **Pinned inventory:** 725 identities ([exact mapping](../compat/pytorch_inventory_map.toml)); disposition only, not a support claim.
- **Scope:** Remaining documented torch.ao inventory identities mapped to this row have no individually evidenced RustTorch compatibility claim. Existing implemented subsets remain in their separate scoped ledger rows.
- **Pinned source:** [`torch/ao/__init__.py`](https://github.com/pytorch/pytorch/blob/cf30153/torch/ao/__init__.py)
- **Evidence:** —
- **Notes:** This is an explicit disposition for the exact IDs in compat/pytorch\_inventory\_map.toml. Membership does not imply implementation, complete family coverage, or a compatibility percentage.

### `census.python.runtime`

- **PyTorch:** `torch`
- **RustTorch:** —
- **Implementation:** Not implemented
- **Pinned inventory:** 1240 identities ([exact mapping](../compat/pytorch_inventory_map.toml)); disposition only, not a support claim.
- **Scope:** Remaining documented torch inventory identities mapped to this row have no individually evidenced RustTorch compatibility claim. Existing implemented subsets remain in their separate scoped ledger rows.
- **Pinned source:** [`torch/__init__.py`](https://github.com/pytorch/pytorch/blob/cf30153/torch/__init__.py)
- **Evidence:** —
- **Notes:** This is an explicit disposition for the exact IDs in compat/pytorch\_inventory\_map.toml. Membership does not imply implementation, complete family coverage, or a compatibility percentage.

### `census.python.serialization`

- **PyTorch:** `torch.serialization`
- **RustTorch:** —
- **Implementation:** Not implemented
- **Pinned inventory:** 17 identities ([exact mapping](../compat/pytorch_inventory_map.toml)); disposition only, not a support claim.
- **Scope:** Remaining documented torch.serialization inventory identities mapped to this row have no individually evidenced RustTorch compatibility claim. Existing implemented subsets remain in their separate scoped ledger rows.
- **Pinned source:** [`torch/serialization.py`](https://github.com/pytorch/pytorch/blob/cf30153/torch/serialization.py)
- **Evidence:** —
- **Notes:** This is an explicit disposition for the exact IDs in compat/pytorch\_inventory\_map.toml. Membership does not imply implementation, complete family coverage, or a compatibility percentage.

### `census.python.sparse`

- **PyTorch:** `torch.sparse`
- **RustTorch:** —
- **Implementation:** Not implemented
- **Pinned inventory:** 1142 identities ([exact mapping](../compat/pytorch_inventory_map.toml)); disposition only, not a support claim.
- **Scope:** Remaining documented torch.sparse inventory identities mapped to this row have no individually evidenced RustTorch compatibility claim. Existing implemented subsets remain in their separate scoped ledger rows.
- **Pinned source:** [`torch/sparse/__init__.py`](https://github.com/pytorch/pytorch/blob/cf30153/torch/sparse/__init__.py)
- **Evidence:** —
- **Notes:** This is an explicit disposition for the exact IDs in compat/pytorch\_inventory\_map.toml. Membership does not imply implementation, complete family coverage, or a compatibility percentage.

### `census.python.special`

- **PyTorch:** `torch.special`
- **RustTorch:** —
- **Implementation:** Not implemented
- **Pinned inventory:** 53 identities ([exact mapping](../compat/pytorch_inventory_map.toml)); disposition only, not a support claim.
- **Scope:** Remaining documented torch.special inventory identities mapped to this row have no individually evidenced RustTorch compatibility claim. Existing implemented subsets remain in their separate scoped ledger rows.
- **Pinned source:** [`torch/special/__init__.py`](https://github.com/pytorch/pytorch/blob/cf30153/torch/special/__init__.py)
- **Evidence:** —
- **Notes:** This is an explicit disposition for the exact IDs in compat/pytorch\_inventory\_map.toml. Membership does not imply implementation, complete family coverage, or a compatibility percentage.

### `census.python.tensor`

- **PyTorch:** `torch.Tensor`
- **RustTorch:** —
- **Implementation:** Not implemented
- **Pinned inventory:** 532 identities ([exact mapping](../compat/pytorch_inventory_map.toml)); disposition only, not a support claim.
- **Scope:** Remaining documented torch.Tensor inventory identities mapped to this row have no individually evidenced RustTorch compatibility claim. Existing implemented subsets remain in their separate scoped ledger rows.
- **Pinned source:** [`torch/_tensor.py`](https://github.com/pytorch/pytorch/blob/cf30153/torch/_tensor.py)
- **Evidence:** —
- **Notes:** This is an explicit disposition for the exact IDs in compat/pytorch\_inventory\_map.toml. Membership does not imply implementation, complete family coverage, or a compatibility percentage.

### `census.python.testing`

- **PyTorch:** `torch.testing`
- **RustTorch:** —
- **Implementation:** Not implemented
- **Pinned inventory:** 3 identities ([exact mapping](../compat/pytorch_inventory_map.toml)); disposition only, not a support claim.
- **Scope:** Remaining documented torch.testing inventory identities mapped to this row have no individually evidenced RustTorch compatibility claim. Existing implemented subsets remain in their separate scoped ledger rows.
- **Pinned source:** [`torch/testing/__init__.py`](https://github.com/pytorch/pytorch/blob/cf30153/torch/testing/__init__.py)
- **Evidence:** —
- **Notes:** This is an explicit disposition for the exact IDs in compat/pytorch\_inventory\_map.toml. Membership does not imply implementation, complete family coverage, or a compatibility percentage.

### `census.python.utils`

- **PyTorch:** `torch.utils`
- **RustTorch:** —
- **Implementation:** Not implemented
- **Pinned inventory:** 194 identities ([exact mapping](../compat/pytorch_inventory_map.toml)); disposition only, not a support claim.
- **Scope:** Remaining documented torch.utils inventory identities mapped to this row have no individually evidenced RustTorch compatibility claim. Existing implemented subsets remain in their separate scoped ledger rows.
- **Pinned source:** [`torch/utils/__init__.py`](https://github.com/pytorch/pytorch/blob/cf30153/torch/utils/__init__.py)
- **Evidence:** —
- **Notes:** This is an explicit disposition for the exact IDs in compat/pytorch\_inventory\_map.toml. Membership does not imply implementation, complete family coverage, or a compatibility percentage.

### `func`

- **PyTorch:** `torch.func`
- **RustTorch:** —
- **Implementation:** Not implemented
- **Pinned inventory:** 1 identities ([exact mapping](../compat/pytorch_inventory_map.toml)); disposition only, not a support claim.
- **Scope:** Function transforms such as vmap, grad, jacrev, jacfwd, and functionalization are not exposed.
- **Pinned source:** [`torch/_functorch/apis.py`](https://github.com/pytorch/pytorch/blob/cf30153/torch/_functorch/apis.py)
- **Evidence:** —
- **Notes:** Rust interfaces require explicit ownership and mutation semantics.

### `nested`

- **PyTorch:** `torch.nested`
- **RustTorch:** —
- **Implementation:** Not implemented
- **Pinned inventory:** 1 identities ([exact mapping](../compat/pytorch_inventory_map.toml)); disposition only, not a support claim.
- **Scope:** A supported Rust nested/jagged construction, operator, autograd and layout workflow is not exposed.
- **Pinned source:** [`torch/nested/__init__.py`](https://github.com/pytorch/pytorch/blob/cf30153/torch/nested/__init__.py)
- **Evidence:** —
- **Notes:** Safe generated internal operators can create experimental nested tensors, but this is not torch.nested workflow parity. Tensor helpers catch unsupported nested size metadata as recoverable errors; empty\_nested\_and\_copy\_gradient\_boundaries tests that boundary. Padding plus an explicit mask is the supported sequence-data route; no unsafe bridge is introduced.

### `quantization`

- **PyTorch:** `torch.ao.quantization`
- **RustTorch:** —
- **Implementation:** Not implemented
- **Pinned inventory:** 1 identities ([exact mapping](../compat/pytorch_inventory_map.toml)); disposition only, not a support claim.
- **Scope:** Eager and graph quantization, observers, calibration, fake quantization, and quantized modules are not exposed.
- **Pinned source:** [`torch/ao/quantization/__init__.py`](https://github.com/pytorch/pytorch/blob/cf30153/torch/ao/quantization/__init__.py)
- **Evidence:** —
- **Notes:** Quantized tensor construction/dequantization has a separate narrowly tested core.tensor.quantization row. Model transformation, observers, calibration, fake quantization and quantized modules remain planned; pinned legacy primitive availability does not establish torch.ao.quantization coverage.

### `utils.checkpoint`

- **PyTorch:** `torch.utils.checkpoint.checkpoint`
- **RustTorch:** —
- **Implementation:** Not implemented
- **Pinned inventory:** 1 identities ([exact mapping](../compat/pytorch_inventory_map.toml)); disposition only, not a support claim.
- **Scope:** Activation checkpointing, recomputation policy, RNG-state handling, and selective contexts are not exposed.
- **Pinned source:** [`torch/utils/checkpoint.py`](https://github.com/pytorch/pytorch/blob/cf30153/torch/utils/checkpoint.py)
- **Evidence:** —
- **Notes:** Future support must prove gradients and memory behavior.

## Python-only

### `compiler.compile`

- **PyTorch:** `torch.compile`
- **RustTorch:** —
- **Implementation:** Not implemented
- **Pinned inventory:** 1 identities ([exact mapping](../compat/pytorch_inventory_map.toml)); disposition only, not a support claim.
- **Scope:** CPython frame capture, Dynamo guards, and Python graph-break semantics are not native RustTorch APIs.
- **Pinned source:** [`torch/_dynamo/eval_frame.py`](https://github.com/pytorch/pytorch/blob/cf30153/torch/_dynamo/eval_frame.py)
- **Evidence:** —
- **Notes:** RustTorch can execute a separately scoped native TorchScript artifact without claiming Dynamo, Python runtime or AOTInductor parity.

### `compiler.export`

- **PyTorch:** `torch.export.export`
- **RustTorch:** —
- **Implementation:** Not implemented
- **Pinned inventory:** 1 identities ([exact mapping](../compat/pytorch_inventory_map.toml)); disposition only, not a support claim.
- **Scope:** Python program capture, dynamic Python object handling, and Python-side export diagnostics are not native RustTorch APIs.
- **Pinned source:** [`torch/export/__init__.py`](https://github.com/pytorch/pytorch/blob/cf30153/torch/export/__init__.py)
- **Evidence:** —
- **Notes:** Python capture remains separate from implemented, version-pinned PT2 artifact interoperability.

### `compiler.fx`

- **PyTorch:** `torch.fx.Graph`, `torch.fx.GraphModule`, `torch.fx.symbolic_trace`
- **RustTorch:** —
- **Implementation:** Not implemented
- **Pinned inventory:** 5 identities ([exact mapping](../compat/pytorch_inventory_map.toml)); disposition only, not a support claim.
- **Scope:** Python symbolic tracing, dynamic module reconstruction, and FX graph compatibility are not provided.
- **Pinned source:** [`torch/fx/graph.py`](https://github.com/pytorch/pytorch/blob/cf30153/torch/fx/graph.py)
- **Evidence:** —
- **Notes:** RustTorch's typed graph has separate rows and is not described as FX-compatible.

### `data.dataset.datapipes.decorators`

- **PyTorch:** `torch.utils.data.argument_validation`, `torch.utils.data.functional_datapipe`, `torch.utils.data.guaranteed_datapipes_determinism`, `torch.utils.data.non_deterministic`, `torch.utils.data.runtime_validation`, `torch.utils.data.runtime_validation_disabled`
- **RustTorch:** —
- **Implementation:** Not implemented
- **Pinned inventory:** 0 identities ([exact mapping](../compat/pytorch_inventory_map.toml)); disposition only, not a support claim.
- **Scope:** Python decorators dynamically register DataPipe functions, label determinism, and toggle runtime validation or construction-time determinism contexts.
- **Pinned source:** [`torch/utils/data/datapipes/_decorator.py`](https://github.com/pytorch/pytorch/blob/cf30153/torch/utils/data/datapipes/_decorator.py)
- **Evidence:** —
- **Notes:** Rust traits and the type system provide compile-time composition and validation but are not semantic implementations of these mutable Python registries and context managers.

### `data.internal.exports`

- **PyTorch:** `torch.utils.data._DatasetKind`
- **RustTorch:** —
- **Implementation:** Not implemented
- **Pinned inventory:** 0 identities ([exact mapping](../compat/pytorch_inventory_map.toml)); disposition only, not a support claim.
- **Scope:** The private loader-kind dispatch enum exported by the pinned module remains a Python implementation detail.
- **Pinned source:** [`torch/utils/data/dataloader.py`](https://github.com/pytorch/pytorch/blob/cf30153/torch/utils/data/dataloader.py)
- **Evidence:** —
- **Notes:** RustTorch uses type-state builders instead of exposing Python's internal enum. argument\_validation is separately attributed to the pinned DataPipe decorator module.

## Not supported

### `census.aten.internal`

- **PyTorch:** `ATen canonical internal schemas`
- **RustTorch:** —
- **Implementation:** Not implemented
- **Pinned inventory:** 840 identities ([exact mapping](../compat/pytorch_inventory_map.toml)); disposition only, not a support claim.
- **Scope:** Canonical schemas whose operator basename starts with an underscore are retained as non-public implementation inventory, with no public compatibility promise.
- **Pinned source:** [`aten/src/ATen/native/native_functions.yaml`](https://github.com/pytorch/pytorch/blob/cf30153/aten/src/ATen/native/native_functions.yaml)
- **Evidence:** —
- **Notes:** Runtime registration is build availability only; it is not evidence that tch or RustTorch exposes this schema. Exact IDs remain visible in compat/pytorch\_inventory\_map.toml.

### `census.python.jit`

- **PyTorch:** `torch.jit`
- **RustTorch:** —
- **Implementation:** Not implemented
- **Pinned inventory:** 1 identities ([exact mapping](../compat/pytorch_inventory_map.toml)); disposition only, not a support claim.
- **Scope:** Remaining documented torch.jit inventory identities mapped to this row have no individually evidenced RustTorch compatibility claim. Existing implemented subsets remain in their separate scoped ledger rows.
- **Pinned source:** [`torch/jit/__init__.py`](https://github.com/pytorch/pytorch/blob/cf30153/torch/jit/__init__.py)
- **Evidence:** —
- **Notes:** This is an explicit disposition for the exact IDs in compat/pytorch\_inventory\_map.toml. Membership does not imply implementation, complete family coverage, or a compatibility percentage.

### `serialization.pickle`

- **PyTorch:** `torch.save`, `torch.load`
- **RustTorch:** —
- **Implementation:** Not implemented
- **Pinned inventory:** 2 identities ([exact mapping](../compat/pytorch_inventory_map.toml)); disposition only, not a support claim.
- **Scope:** Arbitrary Python pickle objects, whole-model class reconstruction, and CPython object graphs are intentionally unavailable.
- **Pinned source:** [`torch/serialization.py`](https://github.com/pytorch/pytorch/blob/cf30153/torch/serialization.py)
- **Evidence:** —
- **Notes:** RustTorch uses typed model construction and SafeTensors instead of executing pickle payloads.