Tensor::permute returns an owning tile for arena nested outers

For a Tensor<ArenaTensor<...>> outer tile, permute() rebuilt the outer
cell array in permuted order but rebound the 8-byte cell views onto the
source's slab (arena_permute_shallow), keeping the source alive through
the new tile's deleter. The permuted tile therefore aliased the source.
The expression layer consumes a permuted operand temporary in place
(BinaryWrapper with a consumable left/right: `x(perm) - y` becomes
subt_to on the permuted tile), so the subtraction wrote through into x:
after `z("i,j,q,k;a") = x("q,k,i,j;a") - y("i,j,q,k;a")` the array x was
left corrupted (its norm dropped from 2.5e5 to 1.2e2 in the reproducer,
to 0 in another run). A permute-copy (`y(perm) = x(...)`) and owning
Tensor<Tensor> inners were unaffected.

permute() now copies every cell into a fresh single-page slab in
permuted order (arena_permute_deep), the same ownership rule the generic
Tensor(other, perm) constructor and owning_copy_of() already follow, so a
permuted tile may be consumed without touching its source. The shallow
helper stays for callers that only read the permuted view.

Cost: one slab copy per outer permute of an arena tile. On a mixed
nested-times-flat product whose result the engine permutes this is
visible in isolation (0.13 s -> 0.19 s on the tests' benchmark product);
on an MPQC CSV-CCSD water-8-mer iteration it is within noise (9.4 s ->
9.7 s DF+occupied batched, 3.3 s -> 3.4 s DF batched), with energies
and residual norms unchanged to 12 digits. An rvalue permute for the
engine's own result temporaries could restore the zero-copy path there.

tests/arena_mixed_product_order.cpp: the second case (the reproducer)
now passes; its note is updated.

Author: evaleev

src/TiledArray/tensor/arena_kernels.h

@@ -625,6 +625,50 @@ OuterTensor arena_permute_shallow(const SrcOuterTensor& src, const Perm& perm) {
   return result;
 }
 
+/// Deep outer permute of a slab-backed ToT outer tile: a fresh single-page
+/// slab holding a copy of every cell, laid out in permuted order. The owning
+/// counterpart of arena_permute_shallow(): the result shares nothing with
+/// `src`, so it may be consumed in place -- the expression layer consumes a
+/// permuted operand tile (`x(perm) - y`) -- without touching `src`; the
+/// shallow form aliased the source cells, and such a consume wrote through
+/// them. Inner cells keep their ranges (an inner permutation is a separate
+/// pass, arena_inner_permute()). Null cells stay null.
+template <typename OuterTensor, typename SrcOuterTensor, typename Perm>
+OuterTensor arena_permute_deep(const SrcOuterTensor& src, const Perm& perm) {
+  using inner_t = typename OuterTensor::value_type;
+  using elem_t = typename inner_t::value_type;
+  using inner_range_t = typename inner_t::range_type;
+  TA_ASSERT(perm);
+  TA_ASSERT(perm.size() == src.range().rank());
+  auto perm_range = perm * src.range();
+  const std::size_t N_cells = src.range().volume();
+  const std::size_t batch_sz = src.nbatch();
+  // target cell ordinal -> source cell ordinal (within one batch)
+  std::vector<std::size_t> src_of(N_cells);
+  for (std::size_t s = 0; s < N_cells; ++s) {
+    auto src_idx = src.range().idx(s);
+    src_of[perm_range.ordinal(perm * src_idx)] = s;
+  }
+  auto range_fn = [&](std::size_t t_off) -> inner_range_t {
+    const std::size_t b = t_off / N_cells, t = t_off % N_cells;
+    const inner_t& c = src.data()[b * N_cells + src_of[t]];
+    return c.empty() ? inner_range_t{} : c.range();
+  };
+  // every element of every live cell is written below; no zero-init
+  OuterTensor result = arena_outer_init<OuterTensor>(
+      perm_range, batch_sz, range_fn, alignof(elem_t), /*zero_init=*/false);
+  for (std::size_t b = 0; b < batch_sz; ++b) {
+    for (std::size_t t = 0; t < N_cells; ++t) {
+      inner_t& dst = result.data()[b * N_cells + t];
+      if (dst.empty()) continue;
+      const inner_t& s = src.data()[b * N_cells + src_of[t]];
+      TA_ASSERT(dst.size() == s.size());
+      std::copy_n(s.data(), s.size(), dst.data());
+    }
+  }
+  return result;
+}
+
 /// Permute the inner modes of every cell of a slab-backed ToT outer tile.
 ///
 /// Produces a fresh slab-backed tile with the same outer layout as `src`,

src/TiledArray/tensor/tensor.h

@@ -1710,15 +1710,20 @@ class Tensor {
   Tensor permute(const Perm& perm) const {
     if constexpr (is_arena_tensor_v<value_type>) {
       // View inner cells cannot be permuted in place; the owning tile
-      // rewrites its slab(s). The outer cells reorder shallowly (the 8-byte
-      // views are reindexed, the slab is shared via keep-alive); a
-      // non-trivial inner permutation rewrites every cell into a fresh slab.
-      // The generic Tensor(other, perm) ctor's allocate-then-fill shape does
-      // not fit the arena slab model, so route around it.
+      // rewrites its slab(s). The outer permutation copies every cell into a
+      // fresh slab in permuted order (arena_permute_deep): like the generic
+      // Tensor(other, perm) ctor, permute() returns an OWNING tile, which the
+      // expression layer may consume in place. (The earlier shallow form
+      // reindexed the 8-byte views over the shared source slab, and an
+      // in-place op on the permuted operand -- e.g. `x(perm) - y` -- wrote
+      // through into the source.) A non-trivial inner permutation rewrites
+      // every cell into a fresh slab as before. The generic ctor's
+      // allocate-then-fill shape does not fit the arena slab model, so route
+      // around it.
       const auto outer_perm = outer(perm);
       Tensor result =
           (outer_perm && !outer_perm.is_identity())
-              ? detail::arena_permute_shallow<Tensor>(*this, outer_perm)
+              ? detail::arena_permute_deep<Tensor>(*this, outer_perm)
               : *this;
       if constexpr (detail::is_bipartite_permutation_v<Perm>) {
         const auto inner_perm = inner(perm);

tests/arena_mixed_product_order.cpp

@@ -21,11 +21,13 @@
 //
 //  2. permuted operand in a binary op: reading an arena ToT through a
 //     PERMUTED annotation inside a binary expression (e.g. `x(perm) - y`)
-//     destroyed the source: the permuted operand tile is a SHALLOW permute
-//     (cells alias the source slab) and the in-place binary op wrote through
-//     it. A permute-COPY (`y(perm) = x(...)`) was unaffected, and owning
-//     (Tensor<Tensor>) inners were unaffected. The test asserts the source's
-//     norm is unchanged after such a read.
+//     destroyed the source: Tensor::permute() returned a SHALLOW permute
+//     (cells aliasing the source slab) and the in-place binary op, which
+//     consumes a permuted operand temporary, wrote through it. A
+//     permute-COPY (`y(perm) = x(...)`) was unaffected, and owning
+//     (Tensor<Tensor>) inners were unaffected. permute() now returns an
+//     owning tile (arena_permute_deep); the test asserts the source's norm
+//     is unchanged after such a read.
 
 #include "TiledArray/tensor/arena_einsum.h"
 #include "TiledArray/tensor/arena_tensor.h"