Remove DimensionBounds and EncodeBounds from Shape

These fields are only needed for DynamicReshape and DynamicBroadcastInDim
operations, which are being added in a separate follow-up PR.

Author: ajroetker

internal/shapeinference/shapeinference.go

@@ -210,32 +210,15 @@ func binaryOpImpl(opType optypes.OpType, lhsShape, rhsShape shapes.Shape) (outpu
 	}
 	output = lhsShape.Clone()
 
-	// Determine if we need to track bounds
-	needsBounds := len(lhsShape.DimensionBounds) > 0 || len(rhsShape.DimensionBounds) > 0
-
 	for axis := range output.Rank() {
 		lhsDim := lhsShape.Dimensions[axis]
 		rhsDim := rhsShape.Dimensions[axis]
 
-		// Get bounds for each side
-		lhsBound := 0
-		if axis < len(lhsShape.DimensionBounds) {
-			lhsBound = lhsShape.DimensionBounds[axis]
-		}
-		rhsBound := 0
-		if axis < len(rhsShape.DimensionBounds) {
-			rhsBound = rhsShape.DimensionBounds[axis]
-		}
-
 		// Handle dynamic dimensions (DimUnknown)
 		switch {
 		case lhsDim == shapes.DimUnknown && rhsDim == shapes.DimUnknown:
-			// Both dynamic - result is unknown, merge bounds
+			// Both dynamic - result is unknown
 			output.Dimensions[axis] = shapes.DimUnknown
-			if needsBounds && axis < len(output.DimensionBounds) {
-				// Use maximum of both bounds
-				output.DimensionBounds[axis] = max(lhsBound, rhsBound)
-			}
 		case lhsDim >= 0 && rhsDim >= 0:
 			// Both static (including zero-dimension tensors) - use existing max logic for broadcasting
 			if lhsDim != 1 && rhsDim != 1 && lhsDim != rhsDim {
@@ -244,43 +227,19 @@ func binaryOpImpl(opType optypes.OpType, lhsShape, rhsShape shapes.Shape) (outpu
 				return
 			}
 			output.Dimensions[axis] = max(lhsDim, rhsDim)
-			// Clear bounds for static dimensions
-			if len(output.DimensionBounds) > axis {
-				output.DimensionBounds[axis] = 0
-			}
 		case lhsDim < 0 && rhsDim > 1:
 			// Dynamic vs concrete > 1: use concrete (dynamic must be compatible)
 			output.Dimensions[axis] = rhsDim
-			// Clear bounds since we're now static
-			if len(output.DimensionBounds) > axis {
-				output.DimensionBounds[axis] = 0
-			}
 		case rhsDim < 0 && lhsDim > 1:
 			// Concrete > 1 vs dynamic: use concrete
 			output.Dimensions[axis] = lhsDim
-			// Clear bounds since we're now static
-			if len(output.DimensionBounds) > axis {
-				output.DimensionBounds[axis] = 0
-			}
 		default:
 			err = errors.Errorf("incompatible dynamic dimensions at axis %d: %d vs %d for BinaryOp (%s)",
 				axis, lhsDim, rhsDim, opType)
 			return
 		}
 	}
 
-	// Clean up DimensionBounds if all are zero
-	allZero := true
-	for _, b := range output.DimensionBounds {
-		if b != 0 {
-			allZero = false
-			break
-		}
-	}
-	if allZero {
-		output.DimensionBounds = nil
-	}
-
 	return
 }
 

pkg/types/shapes/shape.go

@@ -87,12 +87,10 @@ const DimUnknown = -1
 //
 // Use Make to create a new shape. See example in package shapes documentation.
 type Shape struct {
-	DType           dtypes.DType
-	Dimensions      []int
-	DimensionBounds []int         // Upper bounds for dynamic dimensions (when Dimensions[i] == DimUnknown). nil or len(DimensionBounds)==len(Dimensions). 0 means no bound.
-	TupleShapes     []Shape       // Shapes of the tuple, if this is a tuple.
-	Quantization    *Quantization // Quantization metadata for quantized types.
-	EncodeBounds    bool          // Whether to encode DimensionBounds in StableHLO output. Set to true for ops that require bounded dynamism (e.g., dynamic_reshape).
+	DType        dtypes.DType
+	Dimensions   []int
+	TupleShapes  []Shape       // Shapes of the tuple, if this is a tuple.
+	Quantization *Quantization // Quantization metadata for quantized types.
 }
 
 // Make returns a Shape structure filled with the values given.
@@ -136,20 +134,6 @@ func (s Shape) IsDynamic() bool {
 	return slices.Contains(s.Dimensions, DimUnknown)
 }
 
-// hasBoundedDynamism returns true if the shape has at least one dynamic dimension
-// with a known upper bound. This is used for StableHLO bounds encoding.
-func (s Shape) hasBoundedDynamism() bool {
-	if len(s.DimensionBounds) == 0 {
-		return false
-	}
-	for i, dim := range s.Dimensions {
-		if dim == DimUnknown && i < len(s.DimensionBounds) && s.DimensionBounds[i] > 0 {
-			return true
-		}
-	}
-	return false
-}
-
 // Dim returns the dimension of the given axis. axis can take negative numbers, in which
 // case it counts as starting from the end -- so axis=-1 refers to the last axis.
 // Like with a slice indexing, it panics for an out-of-bound axis.
@@ -284,15 +268,13 @@ func (s Shape) EqualDimensions(s2 Shape) bool {
 func (s Shape) Clone() (s2 Shape) {
 	s2.DType = s.DType
 	s2.Dimensions = slices.Clone(s.Dimensions)
-	s2.DimensionBounds = slices.Clone(s.DimensionBounds)
 	if s.TupleSize() > 0 {
 		s2.TupleShapes = make([]Shape, 0, len(s.TupleShapes))
 		for _, subShape := range s.TupleShapes {
 			s2.TupleShapes = append(s2.TupleShapes, subShape.Clone())
 		}
 	}
 	s2.Quantization = s.Quantization.Clone()
-	s2.EncodeBounds = s.EncodeBounds
 	return
 }
 

pkg/types/shapes/stablehlo.go

@@ -62,28 +62,6 @@ func (s Shape) WriteStableHLO(writer io.Writer) error {
 		w("%s", s.DType.ToStableHLO())
 	}
 
-	// Encode bounds only if explicitly requested via EncodeBounds flag.
-	// XLA requires bounded dynamic dimensions for compilation.
-	if s.EncodeBounds && s.hasBoundedDynamism() {
-		w(", #stablehlo.bounds<")
-		for i, dim := range s.Dimensions {
-			if i > 0 {
-				w(", ")
-			}
-			if dim == DimUnknown {
-				// Dynamic dimension - check if we have a bound
-				if i < len(s.DimensionBounds) && s.DimensionBounds[i] > 0 {
-					w("%d", s.DimensionBounds[i])
-				} else {
-					w("?")
-				}
-			} else {
-				// Static dimension - use ? (no bound needed, the dimension is already known)
-				w("?")
-			}
-		}
-		w(">")
-	}
 	w(">")
 	return err
 }