ContractReduce: fall back to value-returning conj when a tile has no conj_to

[evaleev]

Closes #585.

Problem

TiledArray::conj and TiledArray::conj_to are independent ADL customization points, and the default conj_to in tile_op/tile_interface.h is SFINAE-constrained on a conj_to() member. A custom tile that implements only the value-returning conj is a legal partial implementation of the tile interface — the pattern AGENTS.md blesses, with tests/sparse_tile.h's EigenSparseTile omitting subt as precedent — but it could not be used in a conjugated contraction.

The two CPOs have exactly one call site each in the whole library, and it is the same function: ContractReduce's ComplexConjugate finalization, choosing between them on whether a result permutation is present. So for such a tile:

c("k,i") = conj(a("i,j") * b("j,k"));   // compiles   (permuted   -> conj)
c("i,k") = conj(a("i,j") * b("j,k"));   // hard error (unpermuted -> conj_to)

On master (84cc198) instantiating that finalization is
contract_reduce.h:574: no matching function for call to 'conj_to', and
:581 for the scaled specialization.

Unary conj(a("i,j")) was never affected — it is a Scal expression with a ComplexConjugate factor and goes through scale/scale_to.

Change

• TiledArray::has_conj_to_v<T...> in tile_op/tile_interface.h, next to the CPOs it describes: whether the ADL call conj_to(args...) is viable.
• detail::conj_finalize(temp, factor...) in contract_reduce.h: in place through conj_to when that is viable, otherwise through the value-returning conj. Both unpermuted branches of the finalization route through it; the permuted branches already used conj and are untouched.

The detection is on the ADL call, not on a conj_to() member. btas::Tensor has no such member — only free functions in namespace btas — so detail::has_member_function_conj_to_anyreturn_v reports false for it, and a member-based test would silently demote BTAS from in-place conjugation to an allocate/copy/free per tile. That is a performance regression that would pass every existing test, so tile_op_contract_reduce.cpp carries a static_assert pinning the distinction.

No behavior change for any tile in the tree: Tensor, TensorInterface, ArenaTensor, Tile, btas::Tensor and the nested Tensor<ArenaTensor<...>> / Tensor<Tensor<...>> forms all satisfy has_conj_to_v and keep the in-place path.

Tests

Three cases in tile_op_contract_reduce_suite:

• conj_to_detection — has_conj_to_v is true for Tensor<complex>, btas::Tensor<complex>, Tensor<ArenaTensor<complex>> and Tensor<Tensor<complex>>, with and without a scale; false for the fallback tile. Plus the static_assert recording that BTAS has no conj_to member.
• conj_finalize_in_place_when_supported — the Tensor path conjugates the argument itself, i.e. no copy is made.
• conj_finalization_without_conj_to — the regression: builds ContractReduce<ConjOnlyTile, …, ComplexConjugate<void>> and <…, ComplexConjugate<double>> and runs the finalization. ConjOnlyTile supplies the four value-returning conj overloads and no conj_to, member or free.

tile_op_contract_reduce 24/24 and tot_expressions (which exercises this finalization heavily on owning, arena and BTAS cells) pass under ASan. Verified that the regression bites: the same ContractReduce instantiation written against pre-existing API fails on master with the conj_to error above and compiles here.

[evaleev]

Added the tile-requirement contract as documentation on the finalization (6955f11).

I tried it first as a static_assert with a has_conj_v trait mirroring has_conj_to_v, and that does not work — worth recording, because the asymmetry is not obvious:

• conj_to's default CPO is constrained on the member existing (has_member_function_conj_to_anyreturn_v), like neg_to's. A tile without it is a clean substitution failure, so has_conj_to_v correctly yields false. That is what makes the fallback in this PR sound.
• the four conj CPOs are constrained only on Perm being a permutation, and have a deduced return type. So decltype(conj(arg, perm)) must instantiate the body — detecting a tile that lacks the member is a hard error, not false. A has_conj_v built that way is a footgun: it hard-errors where callers expect it to answer, and the negative test showed the confusing tile_interface.h: too many arguments diagnostic still arriving first, with the static_assert only piling on after.

So the requirement is prose for now, and the note says what it would take to make it enforceable: constrain the four conj overloads the way conj_to and neg_to already are. That is a change to a public header's overload set and deserves its own PR rather than riding along here.

Verified: the sweep over every TU that instantiates this finalization — expressions{,_sparse,_complex,_btas,_mixed}, tot_dist_array_part{1,2}, einsum, tot_construction, tot_expressions, tile_op_contract_reduce — is clean, and tile_op_contract_reduce 24/24 passes under ASan.

[Copilot]

🟢 Approval recommended

No unresolved blocking issues were identified, and regression coverage is included.

Pull request overview

Adds ADL-based conj_to detection and falls back to value-returning conj during ContractReduce finalization.

Changes:

• Adds has_conj_to_v.
• Selects in-place or fallback conjugation.
• Adds regression and detection tests.

File summaries

File	Summary
tests/tile_op_contract_reduce.cpp	Tests detection and fallback behavior.
src/TiledArray/tile_op/tile_interface.h	Adds ADL-based conj_to detection.
src/TiledArray/tile_op/contract_reduce.h	Implements in-place or value-returning finalization.

Review details

• Files reviewed: 3/3 changed files
• Comments generated: 0
• Review effort level: Lite

---

💡 Add a code-review agent skill or configure MCP servers for context-aware, tailored reviews. Learn more in the docs.