ut3svd
======

.. py:function:: t3toolbox.backend.ut3_svd.ut3svd(data, max_tucker_ranks = None, max_tt_ranks = None, assume_orthogonal = False)

   .. code-block:: python

      def ut3svd(
              data:             UT3Data,
              max_tucker_ranks: typ.Union[int, typ.Sequence[int], NDArray, None] = None,  # scalar / len=d / (d,)+stack
              max_tt_ranks:     typ.Union[int, typ.Sequence[int], NDArray, None] = None,  # scalar / len=d+1 / (d+1,)+stack
              assume_orthogonal: bool = False,
      ) -> typ.Tuple[
          UT3Data,  # new_x (left-orthogonal; the raw-sweep ranks -- NOT necessarily minimal under truncation)
          NDArray,  # Tucker singular values, shape=(d,)+stack+(n',)
          NDArray,  # TT singular values,     shape=(d+1,)+stack+(r',)
      ]:


   Mask-truncated T3-SVD of a uniform Tucker tensor train -- the basic algorithm, matching ragged
   ``t3svd`` on real parts. Always **left-orthogonal**; under truncation **not** necessarily minimal.

   Truncation is by **max rank only** (no rtol/atol -- those would make data-dependent shapes): a single
   left-to-right sweep, shrinking the padded supercore to the raw-sweep content ranks
   (`compute_raw_sweep_ranks`). It does **not** re-tune to minimal ranks -- use
   :py:func:`ut3_rank_adjustment_sweep`. Per-stack-element ``max_*_ranks`` arrays are allowed (the
   variety / rank sweep). ``assume_orthogonal=True`` skips the orthogonalization, asserting the input is
   already right-orthogonal (not enforced). See ``docs/t3svd_minimal_ranks.md``.