Ops properties

Native Aidge operators expose predefined static properties that describe their intrinsic mathematical behavior, characteristics, capabilities, or constraints. These properties enable generic heuristics that rely on operator attributes rather than operator types, such as PTQ or other graph optimization techniques.

Additional properties can also be defined by users.

Overview

Each operator is described using the following properties:

• scale_law: describes how outputs scale with inputs;

  Only for Homogeneous scale_law:

  • homogeneity_degree: exponent vector describing scaling behavior;

  • scale_composition: how scaling propagates across multiple inputs;

• parity: symmetry under input negation;

• commutative: whether input ordering affects result.

This taxonomy is designed for static analysis of deep learning graphs and quantization propagation.

Core Definitions

scale_law Property

Homogeneous

Operator satisfies:

\[f(\lambda x) = \lambda^d f(x)\]

or more generally the following scale-equivariance law:

\[f(\lambda_1 x_1, \lambda_2 x_2, ...) = \phi(\lambda_1^{d_1}, \lambda_2^{d_2}, ...) f(x_1, x_2, ...)\]

In this case, the homogeneity_degree property must be specified:

homogeneity_degree

Vector \((d_1, d_2, \ldots)\) such that scaling input \(i\) by \(\lambda_i\) contributes a factor \(\lambda_i^{d_i}\) to the output scale.

Examples:

• MatMul: (1, 1)

• Mul: (1, 1)

• Div: (1, -1)

• Reciprocal: (-1)

• Sqrt: (0.5)

• ArgMax: (0)

Affine

Linear transformation with bias terms breaking strict scaling.

GeneralNonlinear

No consistent scaling law exists.

scale_composition Property

Defines how scaling propagates across multiple inputs. This property must only be specified for multi-inputs operators with the Homogeneous scale_law property.

\[f(\lambda_1 x_1, \lambda_2 x_2, ...) = \phi(\lambda_1^{d_1}, \lambda_2^{d_2}, ...) f(x_1, x_2, ...)\]

We assume a scalar scale per tensor. The goal is to characterize the function \(\phi\).

Product

Scaling multiplies across inputs.

\[\phi(\lambda_1^{d_1}, \lambda_2^{d_2}, ...) = \lambda_1^{d_1} \lambda_2^{d_2} ...\]

MatMul Example:

\[Z = A B\]

Scaling:

\[ \begin{align}\begin{aligned}Z' = f(\lambda_1 A, \lambda_2 B) = \lambda_1 \lambda_2 f(A, B)\\Z' = \lambda_1 A \lambda_2 B = \lambda_1 \lambda_2 A B\end{aligned}\end{align} \]

Interpretation:

The output scale is exactly the product of the inputs scale.

Union

Output is formed by selecting, routing, or combining values without arithmetic accumulation.

\[\phi(\lambda_1^{d_1}, \lambda_2^{d_2}, ...) \leq max(\lambda_1^{d_1}, \lambda_2^{d_2}, ...)\]

Max Example:

\[Z = max(A, B)\]

The output magnitude is bounded by:

\[Z' = max(\lambda_1 A, \lambda_2 B) \leq max(\lambda_1, \lambda_2) max(A, B)\]

Interpretation:

The output scale estimate is \(max(\lambda_1, \lambda_2)\). If the inputs scale are homogeneous, the scale composition \(\phi\) is exactly the maximum of the inputs scale.

SumBound

Output is formed by arithmetic accumulation of multiple inputs.

Add / Sum Example:

\[Z = sum(A, B)\]

The output magnitude is bounded by:

\[\|Z'\| \leq \lambda_1 \|A\| + \lambda_2 \|B\| \leq max(\lambda_1, \lambda_2) (\|A\| + \|B\|)\]

Therefore:

\[\phi(\lambda_1, \lambda_2) \le max(\lambda_1, \lambda_2)\]

Interpretation:

An output scale of \(max(\lambda_1, \lambda_2)\) is a conservative upper bound.

parity Property

Even

\(f(-x) = f(x)\)

Odd

\(f(-x) = -f(x)\)

Note: many operators are neither and should be treated as undefined parity.

commutative Property

Boolean flag indicating whether input ordering affects output.

• Present and True: \(f(a, b) = f(b, a)\)

• Absent or False: order matters

Commutativity applies only to input-value semantics (aidge_core.InputCategory.Data / aidge_core.InputCategory.OptionalData input category), not indexing or layout.

Operators taxonomy

Pre-defined operators properties

Operator	Scale law	Homogeneity degree	Scale composition	Parity	Commutative
Abs (aidge_core.Abs)	Homogeneous	[1.0]	—	Even	True
Add (aidge_core.Add)	Homogeneous	[1.0, 1.0]	SumBound	—	True
And (aidge_core.And)	GeneralNonlinear	—	—	—	True
ArgMax (aidge_core.ArgMax)	Homogeneous	[0.0]	—	—	—
Asin (aidge_core.Asin)	GeneralNonlinear	—	—	Odd	—
Atan (aidge_core.Atan)	GeneralNonlinear	—	—	Odd	—
AvgPooling1D (aidge_core.AvgPooling1D)	Homogeneous	[1.0]	—	Odd	—
AvgPooling2D (aidge_core.AvgPooling2D)	Homogeneous	[1.0]	—	Odd	—
AvgPooling3D (aidge_core.AvgPooling3D)	Homogeneous	[1.0]	—	Odd	—
BatchNorm2D (aidge_core.BatchNorm2D)	Affine	—	—	—	—
BitErrorRate (aidge_core.BitErrorRate)	GeneralNonlinear	—	—	—	—
BitShift (aidge_core.BitShift)	Homogeneous	[1.0]	—	Odd	—
CastLike (aidge_core.CastLike)	Homogeneous	[1.0]	—	Odd	—
Cast (aidge_core.Cast)	Homogeneous	[1.0]	—	Odd	—
Ceil (aidge_core.Ceil)	GeneralNonlinear	—	—	—	—
Clip (aidge_core.Clip)	GeneralNonlinear	—	—	—	—
ComplexToInnerPair (aidge_core.ComplexToInnerPair)	Homogeneous	[1.0]	—	Odd	—
Concat (aidge_core.Concat)	Homogeneous	[1.0]	Union	Odd	—
ConnectedComponentLabeling (aidge_core.ConnectedComponentLabeling)	GeneralNonlinear	—	—	—	—
ConstantOfShape (aidge_core.ConstantOfShape)	GeneralNonlinear	—	—	—	—
Conv1D (aidge_core.Conv1D)	Affine	—	—	—	—
Conv2D (aidge_core.Conv2D)	Affine	—	—	—	—
Conv3D (aidge_core.Conv3D)	Affine	—	—	—	—
ConvDepthWise1D (aidge_core.ConvDepthWise1D)	Affine	—	—	—	—
ConvDepthWise2D (aidge_core.ConvDepthWise2D)	Affine	—	—	—	—
ConvTranspose1D (aidge_core.ConvTranspose1D)	Affine	—	—	—	—
ConvTranspose2D (aidge_core.ConvTranspose2D)	Affine	—	—	—	—
ConvTranspose3D (aidge_core.ConvTranspose3D)	Affine	—	—	—	—
Cosh (aidge_core.Cosh)	GeneralNonlinear	—	—	Even	—
Cos (aidge_core.Cos)	GeneralNonlinear	—	—	Even	—
CryptoHash (aidge_core.CryptoHash)	GeneralNonlinear	—	—	—	—
DepthToSpace (aidge_core.DepthToSpace)	Homogeneous	[1.0]	—	Odd	—
DFT (aidge_core.DFT)	Homogeneous	[1.0]	—	Odd	—
Div (aidge_core.Div)	Homogeneous	[1.0, -1.0]	Product	—	—
DropBlock (aidge_core.DropBlock)	Homogeneous	[1.0]	—	Odd	—
Dropout (aidge_core.Dropout)	Homogeneous	[1.0]	—	Odd	—
Equal (aidge_core.Equal)	GeneralNonlinear	—	—	—	True
Erf (aidge_core.Erf)	GeneralNonlinear	—	—	Odd	—
Expand (aidge_core.Expand)	Homogeneous	[1.0]	—	Odd	—
Exp (aidge_core.Exp)	GeneralNonlinear	—	—	—	—
FC (aidge_core.FC)	Affine	—	—	—	—
FixedNBitFlip (aidge_core.FixedNBitFlip)	GeneralNonlinear	—	—	—	—
Flatten (aidge_core.Flatten)	Homogeneous	[1.0]	—	Odd	—
Floor (aidge_core.Floor)	GeneralNonlinear	—	—	—	—
Fold2D (aidge_core.Fold2D)	Homogeneous	[1.0]	—	Odd	—
GatherElements (aidge_core.GatherElements)	Homogeneous	[1.0]	—	Odd	—
Gather (aidge_core.Gather)	Homogeneous	[1.0]	—	Odd	—
GlobalAveragePooling (aidge_core.GlobalAveragePooling)	Homogeneous	[1.0]	—	Odd	—
Greater (aidge_core.Greater)	GeneralNonlinear	—	—	—	—
GridSample (aidge_core.GridSample)	Homogeneous	[1.0]	—	Odd	—
Hardmax (aidge_core.Hardmax)	Homogeneous	[0.0]	—	—	—
HardSigmoid (aidge_core.HardSigmoid)	GeneralNonlinear	—	—	—	—
Heaviside (aidge_core.Heaviside)	GeneralNonlinear	—	—	—	—
Identity (aidge_core.Identity)	Homogeneous	[1.0]	—	Odd	—
InnerPairToComplex (aidge_core.InnerPairToComplex)	Homogeneous	[1.0]	—	Odd	—
InstanceNorm (aidge_core.InstanceNorm)	Homogeneous	[0.0]	—	—	—
LayerNorm (aidge_core.LayerNorm)	Homogeneous	[0.0]	—	—	—
LeakyReLU (aidge_core.LeakyReLU)	Homogeneous	[1.0]	—	—	—
Less (aidge_core.Less)	GeneralNonlinear	—	—	—	—
Ln (aidge_core.Ln)	GeneralNonlinear	—	—	—	—
LogSoftmax (aidge_core.LogSoftmax)	GeneralNonlinear	—	—	—	—
LRN (aidge_core.LRN)	GeneralNonlinear	—	—	—	—
MatMul (aidge_core.MatMul)	Homogeneous	[1.0, 1.0]	Product	—	—
Max (aidge_core.Max)	Homogeneous	[1.0, 1.0]	Union	—	True
MaxPooling1D (aidge_core.MaxPooling1D)	Homogeneous	[1.0]	—	Odd	—
MaxPooling2D (aidge_core.MaxPooling2D)	Homogeneous	[1.0]	—	Odd	—
MaxPooling3D (aidge_core.MaxPooling3D)	Homogeneous	[1.0]	—	Odd	—
Memorize (aidge_core.Memorize)	Homogeneous	[1.0]	—	Odd	—
Min (aidge_core.Min)	Homogeneous	[1.0, 1.0]	Union	—	True
Mod (aidge_core.Mod)	GeneralNonlinear	—	—	—	—
Mul (aidge_core.Mul)	Homogeneous	[1.0, 1.0]	Product	Odd	True
NBitFlip (aidge_core.NBitFlip)	GeneralNonlinear	—	—	—	—
Neg (aidge_core.Neg)	Homogeneous	[1.0]	—	Odd	—
NonZero (aidge_core.NonZero)	GeneralNonlinear	—	—	—	—
Not (aidge_core.Not)	GeneralNonlinear	—	—	—	—
OneHot (aidge_core.OneHot)	GeneralNonlinear	—	—	—	—
Pad (aidge_core.Pad)	Homogeneous	[1.0]	—	Odd	—
Pop (aidge_core.Pop)	Homogeneous	[1.0]	—	Odd	—
Pow (aidge_core.Pow)	Homogeneous	—	—	—	—
RandomNormalLike (aidge_core.RandomNormalLike)	GeneralNonlinear	—	—	—	—
Range (aidge_core.Range)	GeneralNonlinear	—	—	—	—
Reciprocal (aidge_core.Reciprocal)	Homogeneous	[-1.0]	—	Odd	—
ReduceMax (aidge_core.ReduceMax)	Homogeneous	[1.0]	—	Odd	—
ReduceMean (aidge_core.ReduceMean)	Homogeneous	[1.0]	—	Odd	—
ReduceMin (aidge_core.ReduceMin)	Homogeneous	[1.0]	—	Odd	—
ReduceSum (aidge_core.ReduceSum)	Homogeneous	[1.0]	—	Odd	—
ReLU (aidge_core.ReLU)	Homogeneous	[1.0]	—	—	—
Reshape (aidge_core.Reshape)	Homogeneous	[1.0]	—	Odd	—
Resize (aidge_core.Resize)	Homogeneous	[1.0]	—	Odd	—
Round (aidge_core.Round)	GeneralNonlinear	—	—	—	—
Scatter (aidge_core.Scatter)	Homogeneous	[1.0]	—	Odd	—
Select (aidge_core.Select)	GeneralNonlinear	—	—	—	—
Shape (aidge_core.Shape)	GeneralNonlinear	—	—	—	—
Sigmoid (aidge_core.Sigmoid)	GeneralNonlinear	—	—	Odd	—
Sinh (aidge_core.Sinh)	GeneralNonlinear	—	—	Odd	—
Sin (aidge_core.Sin)	GeneralNonlinear	—	—	Odd	—
Slice (aidge_core.Slice)	Homogeneous	[1.0]	—	Odd	—
Softmax (aidge_core.Softmax)	GeneralNonlinear	—	—	—	—
Split (aidge_core.Split)	Homogeneous	[1.0]	—	Odd	—
Sqrt (aidge_core.Sqrt)	Homogeneous	[0.5]	—	—	—
Squeeze (aidge_core.Squeeze)	Homogeneous	[1.0]	—	Odd	—
Stack (aidge_core.Stack)	Homogeneous	[1.0]	—	Odd	—
STFT (aidge_core.STFT)	Homogeneous	[1.0]	—	Odd	—
Sub (aidge_core.Sub)	Homogeneous	[1.0, 1.0]	SumBound	—	—
Sum (aidge_core.Sum)	Homogeneous	[1.0, 1.0]	SumBound	—	True
SVMRegressor (aidge_core.SVMRegressor)	GeneralNonlinear	—	—	—	—
Tanh (aidge_core.Tanh)	GeneralNonlinear	—	—	Odd	—
Tan (aidge_core.Tan)	GeneralNonlinear	—	—	Odd	—
Tile (aidge_core.Tile)	Homogeneous	[1.0]	—	Odd	—
TopK (aidge_core.TopK)	Homogeneous	[1.0]	—	Odd	—
Transpose (aidge_core.Transpose)	Homogeneous	[1.0]	—	Odd	—
Unfold2D (aidge_core.Unfold2D)	Homogeneous	[1.0]	—	Odd	—
Unsqueeze (aidge_core.Unsqueeze)	Homogeneous	[1.0]	—	Odd	—
WeightInterleaving (aidge_core.WeightInterleaving)	Homogeneous	[1.0]	—	Odd	—
Where (aidge_core.Where)	GeneralNonlinear	—	—	—	—