Rename SST to SLT

Author: ValerianRey

src/torchjd/autogram/_engine.py

@@ -4,7 +4,7 @@
 from torch import Tensor, nn, vmap
 from torch.autograd.graph import get_gradient_edge
 
-from torchjd.sparse import make_sst
+from torchjd.sparse import make_slt
 
 from ._edge_registry import EdgeRegistry
 from ._gramian_accumulator import GramianAccumulator
@@ -177,7 +177,7 @@ def differentiation(_grad_output: Tensor) -> tuple[Tensor, ...]:
             output_dims = list(range(output.ndim))
             identity = torch.eye(output.ndim, dtype=torch.int64)
             basis = torch.concatenate([identity, identity], dim=0)
-            jac_output = make_sst(torch.ones_like(output), basis)
+            jac_output = make_slt(torch.ones_like(output), basis)
 
             vmapped_diff = differentiation
             for _ in output_dims:

src/torchjd/sparse/__init__.py

@@ -1,3 +1,3 @@
 # Need to import this to execute the code inside and thus to override the functions
 from . import _aten_function_overrides
-from ._sparse_latticed_tensor import SparseLatticedTensor, make_sst
+from ._sparse_latticed_tensor import SparseLatticedTensor, make_slt

src/torchjd/sparse/_aten_function_overrides/einsum.py

@@ -131,8 +131,8 @@ def prepare_for_elementwise_op(
     t1: Tensor | int | float, t2: Tensor | int | float
 ) -> tuple[SparseLatticedTensor, SparseLatticedTensor]:
     """
-    Prepares two SSTs of the same shape from two args, one of those being a SST, and the other being
-    a SST, Tensor, int or float.
+    Prepares two SLTs of the same shape from two args, one of those being a SLT, and the other being
+    a SLT, Tensor, int or float.
     """
 
     assert isinstance(t1, SparseLatticedTensor) or isinstance(t2, SparseLatticedTensor)
@@ -172,7 +172,7 @@ def div_Tensor(t1: Tensor | int | float, t2: Tensor | int | float) -> Tensor:
 
 @impl(aten.mul.Scalar)
 def mul_Scalar(t: SparseLatticedTensor, scalar) -> SparseLatticedTensor:
-    # TODO: maybe it could be that scalar is a scalar SST and t is a normal tensor. Need to check
+    # TODO: maybe it could be that scalar is a scalar SLT and t is a normal tensor. Need to check
     #  that
 
     assert isinstance(t, SparseLatticedTensor)

src/torchjd/sparse/_aten_function_overrides/shape.py

@@ -178,7 +178,7 @@ def cat_default(tensors: list[Tensor], dim: int) -> Tensor:
     ref_basis = ref_tensor.basis
     if any(not torch.equal(t.basis, ref_basis) for t in tensors_[1:]):
         raise NotImplementedError(
-            "Override for aten.cat.default does not support SSTs that do not all have the same "
+            "Override for aten.cat.default does not support SLTs that do not all have the same "
             f"basis. Found the following tensors:\n{[t.debug_info() for t in tensors_]} and the "
             f"following dim: {dim}."
         )

src/torchjd/sparse/_linalg.py

@@ -179,8 +179,8 @@ def compute_gcd(S1: Tensor, S2: Tensor) -> tuple[Tensor, Tensor, Tensor]:
     # S1 = G @ K1
     # S2 = G @ K2
     #
-    # SST(p1, S1) = SST(SST(p1, K1), G)
-    # SST(p2, S2) = SST(SST(p2, K2), G)
+    # SLT(p1, S1) = SLT(SLT(p1, K1), G)
+    # SLT(p2, S2) = SLT(SLT(p2, K2), G)
 
     col_magnitudes = torch.sum(torch.abs(H), dim=0)
     non_zero_indices = torch.nonzero(col_magnitudes, as_tuple=True)[0]

src/torchjd/sparse/_sparse_latticed_tensor.py

@@ -160,7 +160,7 @@ def strides_v2(p_dims: list[int], physical_shape: list[int]) -> list[int]:
 
     Example:
         Imagine a vector of size 3, and of value [1, 2, 3].
-        Imagine a SST t of shape [3, 3] using this vector as physical and using [[0, 0]] as v_to_ps.
+        Imagine a SLT t of shape [3, 3] using this vector as physical and using [[0, 0]] as v_to_ps.
         t.to_dense() is [1, 0, 0, 0, 2, 0, 0, 0, 3] (it's the flattening of the diagonal matrix
         [[1, 0, 0], [0, 2, 0], [0, 0, 3]]).
         When you move by 1 on physical dimension 0, you move by 4 on virtual dimension 0, i.e.
@@ -203,15 +203,15 @@ def to_sparse_latticed_tensor(t: Tensor) -> SparseLatticedTensor:
     if isinstance(t, SparseLatticedTensor):
         return t
     else:
-        return make_sst(physical=t, basis=torch.eye(t.ndim, dtype=torch.int64))
+        return make_slt(physical=t, basis=torch.eye(t.ndim, dtype=torch.int64))
 
 
 def to_most_efficient_tensor(physical: Tensor, basis: Tensor) -> Tensor:
     physical, basis = fix_dim_of_size_1(physical, basis)
     physical, basis = fix_ungrouped_dims(physical, basis)
 
     if (basis.sum(dim=0) == 1).all():
-        # TODO: this can be done more efficiently (without even creating the SST)
+        # TODO: this can be done more efficiently (without even creating the SLT)
         return SparseLatticedTensor(physical, basis).to_dense()
     else:
         return SparseLatticedTensor(physical, basis)
@@ -264,7 +264,7 @@ def fix_ungrouped_dims(physical: Tensor, basis: Tensor) -> tuple[Tensor, Tensor]
     return nphysical, new_basis
 
 
-def make_sst(physical: Tensor, basis: Tensor) -> SparseLatticedTensor:
+def make_slt(physical: Tensor, basis: Tensor) -> SparseLatticedTensor:
     """Fix physical and basis and create a SparseLatticedTensor with them."""
 
     physical, basis = fix_dim_of_size_1(physical, basis)

tests/unit/sparse/test_sparse_latticed_tensor.py

@@ -370,17 +370,17 @@ def test_get_column_indices(source: list[int], destination: list[int], ndim: int
 
 
 @mark.parametrize(
-    ["sst_args", "dim"],
+    ["slt_args", "dim"],
     [
         ([([3], tensor([[1], [1]])), ([3], tensor([[1], [1]]))], 1),
         ([([3, 2], tensor([[1, 0], [1, 3]])), ([3, 2], tensor([[1, 0], [1, 3]]))], 1),
     ],
 )
 def test_concatenate(
-    sst_args: list[tuple[list[int], Tensor]],
+    slt_args: list[tuple[list[int], Tensor]],
     dim: int,
 ):
-    tensors = [SparseLatticedTensor(randn_(pshape), basis) for pshape, basis in sst_args]
+    tensors = [SparseLatticedTensor(randn_(pshape), basis) for pshape, basis in slt_args]
     res = aten.cat.default(tensors, dim)
     expected = aten.cat.default([t.to_dense() for t in tensors], dim)