ut3_concatenate_weights
=======================

.. py:function:: t3toolbox.backend.ut3_operations.ut3_concatenate_weights(weights_A, weights_B)

   .. code-block:: python

      def ut3_concatenate_weights(
              weights_A: UT3WeightsData,  # (tucker_weight_supercore, tt_weight_supercore, masks)
              weights_B: UT3WeightsData,  # (tucker_weight_supercore, tt_weight_supercore, masks)
      ) -> UT3WeightsData:                # per-edge concatenation: padded widths ADD, masks concatenate


   Per-edge concatenation of two uniform weights -- the ``+`` / direct-sum combine, where ranks add.
   Uniform twin of ``t3_concatenate_weights``, and the weight-side partner of ``ut3_add`` (which
   concatenates the *object's* rank masks in exactly the same way).

   Both the padded supercores and the masks concatenate on the last axis, so the output's padded width
   is ``nA + nB`` and its real rank is ``rank_A + rank_B``.

   **The output mask can go gappy, and that is correct** (``docs/uniform_masks_vs_ranks.md``): if ``A``'s
   mask has slack (real rank below its padded width), the concatenation leaves a hole between ``A``'s
   real slots and ``B``'s block. The data stays put -- no compaction -- and ``ut3weights_to_t3weights``
   gathers through the holes. Re-canonicalize with the SVD if a prefix form is wanted.

   Neither operand's real slots move, so no masking is needed: the supercores are copied, not reduced,
   and each output slot comes from exactly one input slot (garbage padding stays in the padding).