Struct Df64Einsum 

pub struct Df64Einsum { /* private fields */ }

A matrix contraction in the external scalar, written in ordinary einsum notation.

#1793’s example is einsum("ik,kj->ij", A, B) evaluated in the external scalar, where the contraction of [1, 1] with [1, 2^-80] has to keep the low component an f64 accumulator would drop. The operation accepts exactly that pattern: two rank-2 inputs that share one contracted label, and an output of the two free labels. Any other pattern is refused with a typed error rather than approximated, because the general label cases need the diagonal, reduction, and permutation stages the ordinary lowering plans and this body does not execute.

Examples

use tenferro_ad::extension::ExtensionOp;
use tenferro_df64_proof::extension::Df64Einsum;

let op = Df64Einsum::new(&[0, 1], &[1, 2], &[0, 2]).expect("a matrix contraction");
assert_eq!(<Df64Einsum as ExtensionOp>::input_count(&op), 2);
assert_eq!(<Df64Einsum as ExtensionOp>::output_count(&op), 1);

Implementations

impl Df64Einsum

pub fn new(lhs: &[u32], rhs: &[u32], out: &[u32]) -> Result<Self>

Build the matrix-contraction pattern lhs,rhs->out.

The labels are the ones an ordinary einsum subscript string names, in order, so "ik,kj->ij" is (&[0, 1], &[1, 2], &[0, 2]).

Errors

Returns [tenferro_tensor::Error::InvalidArgument] when either input is not rank two, when a label repeats within one input, when the inputs do not share exactly one contracted label as the second and first label respectively, or when the output is not the two free labels in that order.

Examples

use tenferro_df64_proof::extension::Df64Einsum;

assert!(Df64Einsum::new(&[0, 1], &[1, 2], &[0, 2]).is_ok());
// A repeated label inside one input is a trace, which the body evaluates.
assert!(Df64Einsum::new(&[0, 0], &[0, 2], &[0, 2]).is_ok());

pub fn new_nary(inputs: &[&[u32]], out: &[u32]) -> Result<Self>

Build the pattern for any number of operands.

A label that two operands share and the output omits is contracted; a label the output omits is summed; a label that repeats inside one operand is a trace or a diagonal extraction. The operands are contracted from the left in the order given, and an intermediate keeps exactly the labels the remaining operands or the output still need.

Errors

Returns an error when fewer than two operands are given, when one carries no label, or when an output label appears in no operand.

Examples

use tenferro_df64_proof::extension::Df64Einsum;

assert!(Df64Einsum::new_nary(&[&[0, 1], &[1, 2], &[2, 3]], &[0, 3]).is_ok());
assert!(Df64Einsum::new_nary(&[&[0, 1]], &[0]).is_err());

pub fn labels(&self) -> Option<(&[u32], &[u32], &[u32])>

The pattern’s label lists, when it has exactly two operands.

The adjoint and tangent helpers are defined for the pairwise case, so they ask for this and refuse anything wider rather than guessing.

Examples

use tenferro_df64_proof::extension::Df64Einsum;

let op = Df64Einsum::new(&[0, 1], &[1, 2], &[0, 2]).expect("a contraction");
assert!(op.labels().is_some());
let wide = Df64Einsum::new_nary(&[&[0, 1], &[1, 2], &[2, 3]], &[0, 3]).expect("a contraction");
assert!(wide.labels().is_none());

pub fn input_labels(&self) -> &[Vec<u32>]

Every operand’s labels, in operand order.

Examples

use tenferro_df64_proof::extension::Df64Einsum;

let op = Df64Einsum::new(&[0, 1], &[1, 2], &[0, 2]).expect("a contraction");
assert_eq!(op.input_labels(), &[vec![0, 1], vec![1, 2]]);

pub fn out_labels(&self) -> &[u32]

The output’s labels, in the output’s axis order.

Examples

use tenferro_df64_proof::extension::Df64Einsum;

let op = Df64Einsum::new(&[0, 1], &[1, 2], &[0, 2]).expect("a contraction");
assert_eq!(op.out_labels(), &[0, 2]);

Trait Implementations

impl Clone for Df64Einsum

fn clone(&self) -> Df64Einsum

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Df64Einsum

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Eq for Df64Einsum

impl ExtensionOp for Df64Einsum

fn family_id(&self) -> &'static str

Stable, process-independent family identifier.

fn payload_hash(&self, hasher: &mut dyn Hasher)

Hash the payload (everything except family_id).

fn payload_eq(&self, other: &dyn ExtensionOp) -> bool

Structural equality against another extension value.

fn clone_arc(&self) -> Arc<dyn ExtensionOp>

Deep-clone the payload behind an Arc.

fn as_any(&self) -> &dyn Any

Upcast this extension to &dyn Any for downcasting in payload_eq.

fn input_count(&self) -> usize

Number of primal inputs. MUST be constant for any given Arc<dyn ExtensionOp> value.

fn output_count(&self) -> usize

Number of outputs. MUST match the length of the vector returned by a successful Self::infer_output_meta call.

fn semantic_effects(&self) -> ExtensionEffectDeclaration<'_>

Declare observable semantic effects for this extension payload.

fn semantic_aliases(&self) -> ExtensionAliasDeclaration<'_>

Declare semantic output aliasing for this extension payload.

fn scalar_identity(&self) -> Option<&'static str>

Canonical identity of an externally defined scalar this operation carries.

fn infer_output_meta( &self, ctx: &mut ExtensionShapeContext<'_>, ) -> Result<Vec<(DType, Vec<SymDim>)>>

Infer output dtypes and shapes for each output slot.

fn lower_to_standard_ops( &self, _builder: &mut GraphBuilder<StdTensorOp>, _inputs: &[ValueRef<StdTensorOp>], _input_dtypes: &[DType], _input_shapes: &[&[SymDim]], ) -> Result<ExtensionStandardLowering, ExtensionLoweringError>

Try to expand this extension into standard tensor graph operations.

fn prune_outputs(&self, _live_outputs: &[bool]) -> Option<Arc<dyn ExtensionOp>>

Optionally return an equivalent op that produces only live outputs.

impl PartialEq for Df64Einsum

fn eq(&self, other: &Df64Einsum) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl StructuralPartialEq for Df64Einsum