Replace dag and dual stubs with Base.conj

`Base.conj` is the standard name for the bra-side involution (data
conj + per-axis arrow flip, no transpose) across the symmetric-tensor
ecosystem (TeNPy, YASTN, symmray, Google TensorNetwork). It also lets
graded matrices inherit `m'` and `m' * m` for free via Julia's
standard `AbstractMatrix` machinery (`Base.adjoint = conj ∘ transpose`).

Drops the local `dag(x) = x` and `dual(x) = x` stubs in
`src/tensoralgebra.jl` and replaces calls in `similar_operator`,
`normnetwork`, and `insert_trivial_link!`. For non-graded backings
the new behavior is the standard `Base.conj` default; graded
backends will overload `Base.conj` on their array and axis types
without needing to touch INN.

Author: mtfishman

src/abstracttensornetwork.jl

@@ -187,7 +187,7 @@ function insert_trivial_link!(tn, e)
     x = similar(tn[src(e)], (l,))
     x[1] = 1
     @preserve_graph tn[src(e)] = tn[src(e)] * x
-    @preserve_graph tn[dst(e)] = tn[dst(e)] * dag(x)
+    @preserve_graph tn[dst(e)] = tn[dst(e)] * conj(x)
     return tn
 end
 

src/beliefpropagation/normnetwork.jl

@@ -129,7 +129,7 @@ function normnetwork(tn)
     norm_tn = TensorNetwork(underlying_graph(tn)) do v
         t = tn[v]
         ket_to_bra = Dict(p for e in incident_edges(tn, v) for p in linknames_map[e])
-        return t * replacedimnames(n -> get(ket_to_bra, n, n), dag(t))
+        return t * replacedimnames(n -> get(ket_to_bra, n, n), conj(t))
     end
     return norm_tn, linknames_map
 end

src/tensoralgebra.jl

@@ -21,22 +21,19 @@ using TensorAlgebra: TensorAlgebra, AbstractBlockPermutation, FusionStyle, biper
 #     for the same piracy reason, plus to hide the workaround for the ITensor
 #     `eltype(::Type) === Any` issue (peeling to the concrete storage so the
 #     stdlib `randn!` / `rand!` sees the runtime eltype).
-#   - `dag`, `dual` — no-op stubs for the tensor and axis involutions.
-
-# Tensor-algebra interface no-op stubs. Currently identity; backends (graded sectors,
-# complex tensors, etc.) will overload these for their semantics.
 #
-# `dag` is the involution on TENSORS (conjugate-transpose, sector-direction flip, …).
-# `dual` is the involution on AXES (vector space → dual vector space).
-dag(x) = x
-dual(x) = x
+# `Base.conj` is the bra-side involution (op A: data conj + arrow flip on every leg,
+# no transpose) used at both the tensor and axis layer. For non-graded backings the
+# default `Base.conj` is correct (elementwise data conj on tensors; identity on plain
+# axes). Graded backends overload `Base.conj` on their array and axis types to flip
+# sector arrows in addition to the data conj.
 
 # Allocate a square operator with the given `codomain` named axes. Domain axes are
-# derived as `dual.(codomain)` with fresh `randname`-generated names; backend / device
+# derived as `conj.(codomain)` with fresh `randname`-generated names; backend / device
 # inherited from `prototype` via `Base.similar`.
 function similar_operator(prototype, ::Type{T}, codomain) where {T}
     domain_names = randname.(name.(codomain))
-    domain_axes = setname.(dual.(codomain), domain_names)
+    domain_axes = setname.(conj.(codomain), domain_names)
     raw = similar(prototype, T, (codomain..., domain_axes...))
     return operator(raw, name.(codomain), domain_names)
 end