invariants 1 and 5 as crate boundaries, a metric as one datum, and the engine on the tensor

[luiswirth]

Invariants 1 and 5 are crate boundaries, and a metric is one datum.

multiindex → multialgebra → metric → { regge, glatt } → derham → formoniq → realize → studio
             (metric-free)  (metric)     ↑
             simplicial ───────────────────┘   (topology + atlas)
coorder ─────────────────────────────────────↗

Twenty-two commits, each passing fmt, clippy, test and doc. 473 tests.

The two boundaries

Invariant 5, multialgebra against metric. The wedge, the contraction, the
transfer and both pairings need no metric. The inner product, the Hodge star and
the musical isomorphisms need nothing else. So multialgebra is exactly the
metric-free algebra and metric is everything above it that needs one: the
induced metrics, the free inner, and a TensorExt carrying norm,
hodge_star, star, musical. An operation's crate says what it depends on.

Factor::induced_form takes a bare bilinear form and returns one, because an
induced form needs only a form; non-degeneracy and signature are properties the
algebra never asks about.

Invariant 1, simplicial against regge. A complex is combinatorics and a
geometry is a genuinely second input. simplicial holds the topology and the
atlas and has no notion of length. regge holds MeshLengthsSq as the
primitive, MeshCoords and CellGramians as sources, the per-simplex metrics
they derive, the meshers, and the mesh formats.

The split runs through the meshers. A Kuhn triangulation is combinatorics, which
simplices in which vertex order from the per-axis cell counts alone, and that
vertex order is what makes uniform refinement compose. CartesianTopology
belongs with the topology; CartesianGrid wraps it to place the vertices.

What reaches down does so as an extension: SimplexCoordsExt for the metric an
ambient realization induces, SubdivisionExt for the geometric half of a
refinement, BoundaryComplexExt for the geometry a boundary inherits. io::cbor
is format-agnostic and sits below; io::gmsh sits above, a mesh file being
coordinates as much as cells.

Both boundaries hold in Cargo.toml, which is the point of making them
structural: multialgebra depends on neither the metric nor a mesh, and
simplicial on neither the metric nor the algebra. A reference datum typed as a
metric would reintroduce the edge, so unit_bary_gramian hands back a bare
matrix.

simplicial also tests itself with no coordinate anywhere: a 2-sphere is the
boundary of a tetrahedron, and the annulus is a grid with its middle box removed
by index. That is what makes the boundary real rather than declared, and it is
load-bearing rather than tidy, because a dev-dependency cycle does not work here.
Cargo permits one, but the cfg(test) build of simplicial is a distinct crate
instance and its types do not unify with the one regge links.

One metric, and its dual

Metric is a non-degenerate symmetric bilinear form of any signature expressed
in a basis, carrying a variance beside its matrix. Covariant is the metric tensor
g, measuring vectors; contravariant is g⁻¹, measuring covectors.

g and g⁻¹ are one datum. dual is the exact passage between them, measuring
asks for the one that measures a given variance, and on_slot for the one that
measures a slot. Nothing chooses between them by hand and no stored pair can fall
out of step. Since each determines the other, either may be handed to an
operation and the answer is the same, so passing the wrong one is not a failure
mode, only an inversion.

Riemannian and Lorentzian are one signature-parameterized type. The
signature-sensitive operations, the volume factor and the causal trichotomy, read
the signature off the metric.

Metric::induced is one method over both families: Λᵏg measures multivectors
when g measures vectors, so the variance is inherited rather than chosen.
multiform_metric and multivector_metric are one line each on top of it,
naming the two sides.

A metric is the Sym² element it is

A symmetric bilinear form on V is an element of Sym²(V*), and one on V* an
element of Sym²(V). Metric::tensor and from_tensor are the two directions of
that identity.

The dense matrix stays the representation: det, dual and the pullback are
matrix operations with optimized implementations, and they run per cell. What the
identity buys is that the pullback exists once. Metric::pullback is
Tensor::pullback on the Sym² reading, stated as a law, so refining a geometry is
the same operation as transporting any other covariant tensor, and refinement
inherits it by going through Metric::pullback.

pullback preserves the variance. The dual and the pullback do not commute
unless the map is orthogonal, so the dual is taken after pulling back, never
before, and a law asserts the two orders genuinely differ.

Edge lengths are Sym² in the edge basis

unit_edge_squares is the symmetric square of each of a simplex's edge vectors:
a basis of Sym² indexed by the edges. An n-simplex has binom(n+1,2) = n(n+1)/2
edges and dim Sym²(Rⁿ) = n(n+1)/2, and the squares are independent.

So a squared edge length is a component of the metric in the dual of that basis,
s_e = ⟨g, u_e ⊙ u_e⟩, and SimplexLengthsSq::metric is that change of basis,
with the polarization identity as its written-out form.

This is why invariant 2's totality over grades is a property of a basis rather
than of the code. A face's edges are a subset of the simplex's, so restricting the
geometry to a face is selecting the components at that face's edge indices, with
nothing computed, where the cartesian frame needs a projection JᵀgJ. A law
asserts the two agree. The edge basis is the one adapted to the face lattice,
which is why geometry is defined on every simplex while a chart exists only on a
cell.

The stored basis is multiplicative, hence not self-dual

x^α x^β = x^(α+β) and e_I ∧ e_J = ±e_(I∪J) with unit coefficients, which is
what lets Λ and Sym be one construction. The price is ‖x^α‖² = α! on a
symmetric slot, so the basis is orthogonal but not self-dual.

Everything that dualizes a slot therefore reads Tensor::reciprocal, the
components in the basis dual to the stored one, and lands through
Tensor::from_reciprocal. The duality pairing is one side's reciprocal
components dotted with the other's stored ones. A pullback is the adjoint of a
pushforward, hence a pairing in disguise, so it transports the reciprocal
components through the transpose of the functor and lands in the reciprocal basis
of the domain; on a symmetric slot that is the transpose conjugated by α! rather
than the bare transpose.

basis_multiplicity is private. The only ways to spend the weights say which
basis they mean, so they cannot be applied by hand.

Both bases are rational. Only an orthonormal basis would need √(α!), which would
put an irrational into a representation that is otherwise exact, and none is
used. The reciprocal basis is a metric's home: its components there are its
matrix entries, with no weight anywhere, which is what a bilinear form is, an
object that eats vectors.

Every α! is 1 on Λᵏ, where the two bases coincide. A law that dualizes is
therefore swept over both families, and to_free commutes with pullback and
pullback is adjoint to pushforward are swept over both, and over rectangular
maps. Each pins one half of the multiplicity and they check each other:
adjointness holds exactly because the α! the pairing adds cancels the α! the
pullback divides by.

Anything relying on the pairing or the pullback of a symmetric slot changes
numerically here, which is worth checking when #131 rebases, that being where
Sym is exercised (P⁻_r Λᵏ = Symʳ ⊗ Λᵏ).

Typed affine maps

AffineTransform<From, To> is tagged by its two coordinate spaces, so invariant 3
reaches the morphisms and not only the points. Composition demands a shared middle
space and pseudo_inverse returns the map the other way round, which is the
chart/parametrization distinction stated as a type rather than as a naming
convention. The linear part stays a bare matrix, deliberately: it maps
displacements, and the difference of two points of one space is a tangent vector
rather than a point.

Not made a Tensor. A mixed tensor over two spaces would carry the dimensions at
runtime where the type parameters carry the spaces at compile time, and compile
time is the whole content of invariant 3.

The engine speaks the tensor

With the algebra settled, the crates above it stop reaching past it. The rule is
that a tensorial computation runs on the tensor, and the storage may be whatever
it needs to be as long as it offers a conversion.

This is not tidiness. Because the stored basis is multiplicative, every
component-level shortcut is exactly right on Λ and silently off by α! on Sym, so
each one is correct until Sym arrives, which P⁻_r Λᵏ does, and fails as a
plausible wrong number rather than as a mismatch anything catches.

• Inner products. Seven element integrals picked a metric on Λᵏ by hand and
  paired raw coefficient vectors under it, fe_l2_error among them. They now go
  through metric::tensor::inner, which accounts for the multiplicity once,
  inside Factor::induced_form, by the permanent on a symmetric factor.
• Tensor::blade_of. The wedge of a frame's columns was built twice, in
  derham::project for a face of the reference cell and in formoniq::hx for a
  simplex in the ambient. One constructor now, functorial rather than a fold, with
  the law that it vanishes exactly on a dependent frame.
• Transport. Four places held a compound matrix and applied it to raw
  components: the face trace, the Whitney shape function and its differential, and
  a refinement child's Jacobian. Each was a pullback written out, and a pullback
  dualizes, so a bare transpose is right on Λ alone. Transport is that functor
  materialized for a fixed shape, and Tensor::pullback/pushforward are one-shot
  uses of it rather than a parallel implementation. It carries a variance rather
  than imposing one, which is what lets one stored functor serve both directions.
  Two of the sites also stop rebuilding the compound matrix at every quadrature
  node.
• A Kronecker product is never formed to be applied. The Gram matrix of a
  product is the product of the Gram matrices and the functor of a map is the
  product of the per-slot functors, so both are held as their factors and applied
  slot by slot. tensor_gramian and Transport::to_matrix remain for a caller
  that needs a matrix as a matrix. No measurable change on a single slot, which is
  every tensor in the engine today; the cost is latent until Symʳ ⊗ Λᵏ.

A Tensor is for the geometric space and never for the space of unknowns. It
models the tangent and cotangent space of a point and their powers, sized by the
manifold's dimension and fixed once that is, where a degree-of-freedom space is
sized by the mesh and the polynomial degree and has no grade, no variance and no
wedge. So cochains, load vectors, element matrices and assembled operators stay
linear algebra, however much a bilinear form on them resembles a tensor, and the
map between the two kinds is an ordinary matrix.

Two fixes fell out of the sweep. The glyph mark and the .vtu exporter pushed a
sharped field forward by multiplying its components with a cell's linear part,
which is the pushforward only at grade 1. And the solenoidal probe took the
Euclidean norm of a vector field's components in each cell's own frame, which is
its magnitude only where that cell's metric is the identity, so its normalization
drifted with cell shape.

Not in scope

• Generic scalars. components is f64; complex-valued forms are what
  time-harmonic problems need.
• Curvature above 2D. Lowest-order Regge has curvature, exactly the angle
  defect; the general case needs dihedral angles between facets around a hinge and
  the hinge bivector in Λ²(V).
• Metric keeps a dense matrix rather than packed Sym² storage, deliberately: at
  degree 2 the redundancy is 2× while det, dual and JᵀgJ are matrix
  operations with optimized implementations.