Strip LinearBroadcasted types to minimal interface

Remove adjoint, transpose, permuteddims, conj, StridedViews methods
from LinearBroadcasted types and Mul. These were algebraic rewrite
rules carried over from the AbstractArray era. Will bring back as
needed when validating against NamedDimsArrays and GradedArrays PRs.

Each type now only defines: axes, eltype, ndims, similar, operation,
arguments. Plus the materialization chain (copy, copyto!, add!).

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: mtfishman

src/linearbroadcasted.jl

@@ -1,7 +1,5 @@
 import Base.Broadcast as BC
-import FunctionImplementations as FI
 import LinearAlgebra as LA
-import StridedViews as SV
 
 # TermInterface-like interface.
 iscall(x) = false
@@ -54,17 +52,6 @@ function Base.similar(a::ScaledBroadcasted, elt::Type, ax)
     return similar(unscaled(a), elt, ax)
 end
 
-function Base.adjoint(a::ScaledBroadcasted)
-    return ScaledBroadcasted(coeff(a), adjoint(unscaled(a)))
-end
-function Base.transpose(a::ScaledBroadcasted)
-    return ScaledBroadcasted(coeff(a), transpose(unscaled(a)))
-end
-
-function FI.permuteddims(a::ScaledBroadcasted, perm)
-    return ScaledBroadcasted(coeff(a), FI.permuteddims(unscaled(a), perm))
-end
-
 operation(::ScaledBroadcasted) = *
 arguments(a::ScaledBroadcasted) = (coeff(a), unscaled(a))
 
@@ -84,17 +71,6 @@ function Base.similar(a::ConjBroadcasted, elt::Type, ax)
     return similar(unconj(a), elt, ax)
 end
 
-Base.conj(a::ConjBroadcasted) = unconj(a)
-Base.adjoint(a::ConjBroadcasted) = transpose(unconj(a))
-Base.transpose(a::ConjBroadcasted) = adjoint(unconj(a))
-
-function FI.permuteddims(a::ConjBroadcasted, perm)
-    return ConjBroadcasted(FI.permuteddims(unconj(a), perm))
-end
-
-SV.isstrided(a::ConjBroadcasted) = SV.isstrided(unconj(a))
-SV.StridedView(a::ConjBroadcasted) = conj(SV.StridedView(unconj(a)))
-
 operation(::ConjBroadcasted) = conj
 arguments(a::ConjBroadcasted) = (unconj(a),)
 
@@ -120,17 +96,6 @@ function Base.similar(a::AddBroadcasted, elt::Type, ax)
     return similar(BC.Broadcasted(+, addends(a)), elt, ax)
 end
 
-function Base.adjoint(a::AddBroadcasted)
-    return AddBroadcasted(adjoint.(addends(a))...)
-end
-function Base.transpose(a::AddBroadcasted)
-    return AddBroadcasted(transpose.(addends(a))...)
-end
-
-function FI.permuteddims(a::AddBroadcasted, perm)
-    return AddBroadcasted(Base.Fix2(FI.permuteddims, perm).(addends(a))...)
-end
-
 operation(::AddBroadcasted) = +
 arguments(a::AddBroadcasted) = addends(a)
 
@@ -166,20 +131,6 @@ function Base.show(io::IO, a::Mul)
     return nothing
 end
 
-function Base.adjoint(a::Mul)
-    f = factors(a)
-    return Mul(adjoint(f[2]), adjoint(f[1]))
-end
-function Base.transpose(a::Mul)
-    f = factors(a)
-    return Mul(transpose(f[2]), transpose(f[1]))
-end
-
-function FI.permuteddims(a::Mul, perm)
-    perm == (1, 2) && return a
-    return transpose(a)
-end
-
 iscall(::Mul) = true
 operation(::Mul) = *
 arguments(a::Mul) = factors(a)

test/test_linearbroadcasted.jl

@@ -1,4 +1,3 @@
-import FunctionImplementations as FI
 using Base.Broadcast: Broadcast as BC
 using TensorAlgebra: TensorAlgebra as TA, linearbroadcasted
 using Test: @test, @test_throws, @testset
@@ -16,7 +15,6 @@ using Test: @test, @test_throws, @testset
         x = linearbroadcasted(conj, a)
         @test x ≡ TA.ConjBroadcasted(a)
         @test copy(x) ≈ conj(a)
-        @test conj(x) ≈ a
 
         x = linearbroadcasted(+, a, b)
         @test x ≡ TA.AddBroadcasted(a, b)
@@ -39,67 +37,6 @@ using Test: @test, @test_throws, @testset
         )
         @test copy(x) ≈ 2 * a * b + 3 * c
     end
-    @testset "adjoint" begin
-        a = randn(ComplexF64, 2, 2)
-        b = randn(ComplexF64, 2, 2)
-
-        x = linearbroadcasted(*, 2, a)'
-        @test x ≡ linearbroadcasted(*, 2, a')
-        @test copy(x) ≈ 2a'
-
-        x = linearbroadcasted(conj, a)'
-        @test x ≡ transpose(a)
-        @test copy(x) ≈ permutedims(a)
-
-        x = linearbroadcasted(+, a, b)'
-        @test x ≡ linearbroadcasted(+, a', b')
-        @test copy(x) ≈ a' + b'
-
-        x = TA.Mul(a, b)'
-        @test x ≡ TA.Mul(b', a')
-        @test copy(x) ≈ b' * a'
-    end
-    @testset "transpose" begin
-        a = randn(ComplexF64, 2, 2)
-        b = randn(ComplexF64, 2, 2)
-
-        x = transpose(linearbroadcasted(*, 2, a))
-        @test x ≡ linearbroadcasted(*, 2, transpose(a))
-        @test copy(x) ≈ 2transpose(a)
-
-        x = transpose(linearbroadcasted(conj, a))
-        @test x ≡ adjoint(a)
-        @test copy(x) ≈ permutedims(conj(a))
-
-        x = transpose(linearbroadcasted(+, a, b))
-        @test x ≡ linearbroadcasted(+, transpose(a), transpose(b))
-        @test copy(x) ≈ transpose(a) + transpose(b)
-
-        x = transpose(TA.Mul(a, b))
-        @test x ≡ TA.Mul(transpose(b), transpose(a))
-        @test copy(x) ≈ transpose(b) * transpose(a)
-    end
-    @testset "permuteddims" begin
-        a = randn(ComplexF64, 2, 2)
-        b = randn(ComplexF64, 2, 2)
-        perm = (2, 1)
-
-        x = FI.permuteddims(linearbroadcasted(*, 2, a), perm)
-        @test x ≡ linearbroadcasted(*, 2, FI.permuteddims(a, perm))
-        @test copy(x) ≈ 2permutedims(a, perm)
-
-        x = FI.permuteddims(linearbroadcasted(conj, a), perm)
-        @test x ≡ linearbroadcasted(conj, FI.permuteddims(a, perm))
-        @test copy(x) ≈ conj(permutedims(a, perm))
-
-        x = FI.permuteddims(linearbroadcasted(+, a, b), perm)
-        @test x ≡
-            linearbroadcasted(+, FI.permuteddims(a, perm), FI.permuteddims(b, perm))
-        @test copy(x) ≈ permutedims(a, perm) + permutedims(b, perm)
-
-        x = FI.permuteddims(TA.Mul(a, b), perm)
-        @test copy(x) ≈ permutedims(a * b, perm)
-    end
     @testset "linear broadcast lowering" begin
         a = randn(ComplexF64, 2, 2)
         style = BC.DefaultArrayStyle{2}()
@@ -118,7 +55,7 @@ using Test: @test, @test_throws, @testset
         @test TA.broadcasted_linear(style, conj, a) ≡ linearbroadcasted(conj, a)
         @test_throws ArgumentError TA.broadcasted_linear(style, exp, a)
     end
-    @testset "LinearBroadcastFunction algebra" begin
+    @testset "linearbroadcasted algebra" begin
         a = randn(ComplexF64, 3, 3)
 
         # Scaling absorbs coefficients