diff --git a/src/libraries/System.Numerics.Tensors/ref/System.Numerics.Tensors.netcore.cs b/src/libraries/System.Numerics.Tensors/ref/System.Numerics.Tensors.netcore.cs
index 540736a2df0553..9cfa839832edf4 100644
--- a/src/libraries/System.Numerics.Tensors/ref/System.Numerics.Tensors.netcore.cs
+++ b/src/libraries/System.Numerics.Tensors/ref/System.Numerics.Tensors.netcore.cs
@@ -55,44 +55,72 @@ namespace System.Buffers
 }
 namespace System.Numerics.Tensors
 {
-    public partial interface ITensor<TSelf, T> : System.Collections.Generic.IEnumerable<T>, System.Collections.IEnumerable, System.IEquatable<TSelf>, System.Numerics.IEqualityOperators<TSelf, TSelf, bool> where TSelf : System.Numerics.Tensors.ITensor<TSelf, T>
+    public partial interface IReadOnlyTensor<TSelf, T> : System.Collections.Generic.IEnumerable<T>, System.Collections.IEnumerable where TSelf : System.Numerics.Tensors.IReadOnlyTensor<TSelf, T>
     {
-        static TSelf? Empty { get { throw null; } }
+        static abstract TSelf? Empty { get; }
+        nint FlattenedLength { get; }
         bool IsEmpty { get; }
         bool IsPinned { get; }
-        ref T this[scoped System.ReadOnlySpan<nint> indices] { get; }
+        T this[scoped System.ReadOnlySpan<System.Buffers.NIndex> indexes] { get; }
+        TSelf this[scoped System.ReadOnlySpan<System.Buffers.NRange> ranges] { get; }
+        T this[scoped System.ReadOnlySpan<nint> indexes] { get; }
         int Rank { get; }
-        System.ReadOnlySpan<nint> Strides { get; }
-        System.Numerics.Tensors.ReadOnlyTensorSpan<T> AsReadOnlyTensorSpan(scoped System.ReadOnlySpan<System.Buffers.NRange> ranges);
-        System.Numerics.Tensors.TensorSpan<T> AsTensorSpan(scoped System.ReadOnlySpan<System.Buffers.NRange> ranges);
-        void Clear();
+        System.Numerics.Tensors.ReadOnlyTensorSpan<T> AsReadOnlyTensorSpan();
+        System.Numerics.Tensors.ReadOnlyTensorSpan<T> AsReadOnlyTensorSpan(scoped System.ReadOnlySpan<System.Buffers.NIndex> startIndex);
+        System.Numerics.Tensors.ReadOnlyTensorSpan<T> AsReadOnlyTensorSpan(scoped System.ReadOnlySpan<System.Buffers.NRange> range);
+        System.Numerics.Tensors.ReadOnlyTensorSpan<T> AsReadOnlyTensorSpan(scoped System.ReadOnlySpan<nint> start);
         void CopyTo(System.Numerics.Tensors.TensorSpan<T> destination);
-        void Fill(T value);
-        ref T GetPinnableReference();
-        static abstract bool operator ==(TSelf left, TSelf right);
-        static abstract bool operator ==(TSelf left, T right);
-        static abstract implicit operator System.Numerics.Tensors.ReadOnlyTensorSpan<T> (TSelf value);
-        static abstract implicit operator System.Numerics.Tensors.TensorSpan<T> (TSelf value);
-        static abstract bool operator !=(TSelf left, TSelf right);
-        static abstract bool operator !=(TSelf left, T right);
-        TSelf Slice(scoped System.ReadOnlySpan<System.Buffers.NRange> ranges);
+        void FlattenTo(System.Span<T> destination);
+        void GetLengths(System.Span<nint> destination);
+        ref readonly T GetPinnableReference();
+        void GetStrides(System.Span<nint> destination);
+        TSelf Slice(scoped System.ReadOnlySpan<System.Buffers.NIndex> startIndex);
+        TSelf Slice(scoped System.ReadOnlySpan<System.Buffers.NRange> range);
+        TSelf Slice(scoped System.ReadOnlySpan<nint> start);
         bool TryCopyTo(System.Numerics.Tensors.TensorSpan<T> destination);
+        bool TryFlattenTo(System.Span<T> destination);
+    }
+    public partial interface ITensor<TSelf, T> : System.Collections.Generic.IEnumerable<T>, System.Collections.IEnumerable, System.Numerics.Tensors.IReadOnlyTensor<TSelf, T> where TSelf : System.Numerics.Tensors.ITensor<TSelf, T>
+    {
+        bool IsReadOnly { get; }
+        new T this[scoped System.ReadOnlySpan<System.Buffers.NIndex> indexes] { get; set; }
+        new TSelf this[scoped System.ReadOnlySpan<System.Buffers.NRange> ranges] { get; set; }
+        new T this[scoped System.ReadOnlySpan<nint> indexes] { get; set; }
+        System.Numerics.Tensors.TensorSpan<T> AsTensorSpan();
+        System.Numerics.Tensors.TensorSpan<T> AsTensorSpan(scoped System.ReadOnlySpan<System.Buffers.NIndex> startIndex);
+        System.Numerics.Tensors.TensorSpan<T> AsTensorSpan(scoped System.ReadOnlySpan<System.Buffers.NRange> range);
+        System.Numerics.Tensors.TensorSpan<T> AsTensorSpan(scoped System.ReadOnlySpan<nint> start);
+        void Clear();
+        static abstract TSelf Create(System.ReadOnlySpan<nint> lengths, bool pinned = false);
+        static abstract TSelf Create(System.ReadOnlySpan<nint> lengths, System.ReadOnlySpan<nint> strides, bool pinned = false);
+        static abstract TSelf CreateUninitialized(System.ReadOnlySpan<nint> lengths, bool pinned = false);
+        static abstract TSelf CreateUninitialized(System.ReadOnlySpan<nint> lengths, System.ReadOnlySpan<nint> strides, bool pinned = false);
+        void Fill(T value);
+        new ref T GetPinnableReference();
     }
     public readonly ref partial struct ReadOnlyTensorSpan<T>
     {
         private readonly object _dummy;
         private readonly int _dummyPrimitive;
+        public ReadOnlyTensorSpan(System.Span<T> span) { throw null; }
+        public ReadOnlyTensorSpan(System.Span<T> span, scoped System.ReadOnlySpan<nint> lengths, scoped System.ReadOnlySpan<nint> strides) { throw null; }
+        [System.CLSCompliantAttribute(false)]
+        public unsafe ReadOnlyTensorSpan(T* data, nint dataLength) { throw null; }
         [System.CLSCompliantAttribute(false)]
-        public unsafe ReadOnlyTensorSpan(void* pointer, System.ReadOnlySpan<nint> lengths, System.ReadOnlySpan<nint> strides = default(System.ReadOnlySpan<nint>)) { throw null; }
-        public ReadOnlyTensorSpan(T[]? array, nint start, System.ReadOnlySpan<nint> lengths) { throw null; }
-        public ReadOnlyTensorSpan(T[]? array, System.ReadOnlySpan<nint> lengths) { throw null; }
+        public unsafe ReadOnlyTensorSpan(T* data, nint dataLength, scoped System.ReadOnlySpan<nint> lengths, scoped System.ReadOnlySpan<nint> strides) { throw null; }
+        public ReadOnlyTensorSpan(T[]? array) { throw null; }
+        public ReadOnlyTensorSpan(T[]? array, System.Index startIndex, System.ReadOnlySpan<nint> lengths, System.ReadOnlySpan<nint> strides) { throw null; }
+        public ReadOnlyTensorSpan(T[]? array, int start, System.ReadOnlySpan<nint> lengths, System.ReadOnlySpan<nint> strides) { throw null; }
         public static System.Numerics.Tensors.ReadOnlyTensorSpan<T> Empty { get { throw null; } }
+        public nint FlattenedLength { get { throw null; } }
         public bool IsEmpty { get { throw null; } }
-        public bool IsPinned { get { throw null; } }
-        public ref readonly T this[scoped System.ReadOnlySpan<nint> indices] { get { throw null; } }
-        public nint LinearLength { get { throw null; } }
+        public ref readonly T this[scoped System.ReadOnlySpan<System.Buffers.NIndex> indexes] { get { throw null; } }
+        public System.Numerics.Tensors.ReadOnlyTensorSpan<T> this[scoped System.ReadOnlySpan<System.Buffers.NRange> ranges] { get { throw null; } }
+        public ref readonly T this[scoped System.ReadOnlySpan<nint> indexes] { get { throw null; } }
+        [System.Diagnostics.CodeAnalysis.UnscopedRefAttribute]
+        public System.ReadOnlySpan<nint> Lengths { get { throw null; } }
         public int Rank { get { throw null; } }
-        public System.ReadOnlySpan<nint> Shape { get { throw null; } }
+        [System.Diagnostics.CodeAnalysis.UnscopedRefAttribute]
         public System.ReadOnlySpan<nint> Strides { get { throw null; } }
         public static System.Numerics.Tensors.ReadOnlyTensorSpan<T> CastUp<TDerived>(System.Numerics.Tensors.ReadOnlyTensorSpan<TDerived> items) where TDerived : class?, T? { throw null; }
         public void CopyTo(System.Numerics.Tensors.TensorSpan<T> destination) { }
@@ -103,18 +131,20 @@ public void CopyTo(System.Numerics.Tensors.TensorSpan<T> destination) { }
 #pragma warning restore CS0809 // Obsolete member overrides non-obsolete member
         public System.Numerics.Tensors.ReadOnlyTensorSpan<T>.Enumerator GetEnumerator() { throw null; }
         [System.ComponentModel.EditorBrowsableAttribute(System.ComponentModel.EditorBrowsableState.Never)]
-#pragma warning disable CS0809 // Obsolete member overrides non-obsolete member
         [System.ObsoleteAttribute("GetHashCode() on ReadOnlyTensorSpan will always throw an exception.")]
+#pragma warning disable CS0809 // Obsolete member overrides non-obsolete member
         public override int GetHashCode() { throw null; }
 #pragma warning restore CS0809 // Obsolete member overrides non-obsolete member
         [System.ComponentModel.EditorBrowsableAttribute(System.ComponentModel.EditorBrowsableState.Never)]
         public ref readonly T GetPinnableReference() { throw null; }
         public static bool operator ==(System.Numerics.Tensors.ReadOnlyTensorSpan<T> left, System.Numerics.Tensors.ReadOnlyTensorSpan<T> right) { throw null; }
+        public static implicit operator System.Numerics.Tensors.ReadOnlyTensorSpan<T> (T[]? array) { throw null; }
         public static bool operator !=(System.Numerics.Tensors.ReadOnlyTensorSpan<T> left, System.Numerics.Tensors.ReadOnlyTensorSpan<T> right) { throw null; }
+        public System.Numerics.Tensors.ReadOnlyTensorSpan<T> Slice(scoped System.ReadOnlySpan<System.Buffers.NIndex> indexes) { throw null; }
         public System.Numerics.Tensors.ReadOnlyTensorSpan<T> Slice(scoped System.ReadOnlySpan<System.Buffers.NRange> ranges) { throw null; }
-        public T[] ToArray() { throw null; }
         public override string ToString() { throw null; }
         public bool TryCopyTo(System.Numerics.Tensors.TensorSpan<T> destination) { throw null; }
+        public bool TryFlattenTo(System.Span<T> destination) { throw null; }
         public ref partial struct Enumerator
         {
             private object _dummy;
@@ -142,10 +172,10 @@ public static partial class Tensor
         public static System.Numerics.Tensors.Tensor<T> CreateAndFillGaussianNormalDistribution<T>(scoped System.ReadOnlySpan<nint> lengths) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.IFloatingPoint<T> { throw null; }
         public static System.Numerics.Tensors.Tensor<T> CreateAndFillUniformDistribution<T>(scoped System.ReadOnlySpan<nint> lengths) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.IFloatingPoint<T> { throw null; }
         public static System.Numerics.Tensors.Tensor<T> CreateFromEnumerable<T>(System.Collections.Generic.IEnumerable<T> data) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool> { throw null; }
-        public static System.Numerics.Tensors.Tensor<T> CreateUninitialized<T>(bool mustPin, System.ReadOnlySpan<nint> lengths) where T : System.IEquatable<T> { throw null; }
-        public static System.Numerics.Tensors.Tensor<T> CreateUninitialized<T>(bool mustPin, System.ReadOnlySpan<nint> lengths, System.ReadOnlySpan<nint> strides) where T : System.IEquatable<T> { throw null; }
-        public static System.Numerics.Tensors.Tensor<T> Create<T>(bool mustPin, System.ReadOnlySpan<nint> lengths) where T : System.IEquatable<T> { throw null; }
-        public static System.Numerics.Tensors.Tensor<T> Create<T>(bool mustPin, System.ReadOnlySpan<nint> lengths, System.ReadOnlySpan<nint> strides) where T : System.IEquatable<T> { throw null; }
+        public static System.Numerics.Tensors.Tensor<T> CreateUninitialized<T>(System.ReadOnlySpan<nint> lengths, bool pinned = false) where T : System.IEquatable<T> { throw null; }
+        public static System.Numerics.Tensors.Tensor<T> CreateUninitialized<T>(System.ReadOnlySpan<nint> lengths, System.ReadOnlySpan<nint> strides, bool pinned = false) where T : System.IEquatable<T> { throw null; }
+        public static System.Numerics.Tensors.Tensor<T> Create<T>(System.ReadOnlySpan<nint> lengths, bool pinned = false) where T : System.IEquatable<T> { throw null; }
+        public static System.Numerics.Tensors.Tensor<T> Create<T>(System.ReadOnlySpan<nint> lengths, System.ReadOnlySpan<nint> strides, bool pinned = false) where T : System.IEquatable<T> { throw null; }
         public static System.Numerics.Tensors.Tensor<T> Create<T>(T[] values, System.ReadOnlySpan<nint> lengths) where T : System.IEquatable<T> { throw null; }
         public static System.Numerics.Tensors.Tensor<T> Create<T>(T[] values, System.ReadOnlySpan<nint> lengths, System.ReadOnlySpan<nint> strides) where T : System.IEquatable<T> { throw null; }
         public static System.Numerics.Tensors.TensorSpan<T> DivideInPlace<T>(System.Numerics.Tensors.TensorSpan<T> left, System.Numerics.Tensors.TensorSpan<T> right) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.IDivisionOperators<T, T, T> { throw null; }
@@ -230,8 +260,8 @@ public static partial class Tensor
         public static System.Numerics.Tensors.Tensor<T> Subtract<T>(T val, System.Numerics.Tensors.Tensor<T> input) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.ISubtractionOperators<T, T, T> { throw null; }
         public static T Sum<T>(System.Numerics.Tensors.TensorSpan<T> input) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.IAdditionOperators<T, T, T>, System.Numerics.IAdditiveIdentity<T, T> { throw null; }
         public static T Sum<T>(System.Numerics.Tensors.Tensor<T> input) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool>, System.Numerics.IAdditionOperators<T, T, T>, System.Numerics.IAdditiveIdentity<T, T> { throw null; }
-        public static string ToString<T>(this System.Numerics.Tensors.ReadOnlyTensorSpan<T> span, int maxRows, int maxColumns) { throw null; }
-        public static string ToString<T>(this System.Numerics.Tensors.TensorSpan<T> span, int maxRows, int maxColumns) { throw null; }
+        public static string ToString<T>(this System.Numerics.Tensors.ReadOnlyTensorSpan<T> span, scoped System.ReadOnlySpan<nint> maximumLengths) { throw null; }
+        public static string ToString<T>(this System.Numerics.Tensors.TensorSpan<T> span, scoped System.ReadOnlySpan<nint> maximumLengths) { throw null; }
         public static System.Numerics.Tensors.Tensor<T> Transpose<T>(System.Numerics.Tensors.Tensor<T> input) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool> { throw null; }
         public static System.Numerics.Tensors.Tensor<T> Unsqueeze<T>(System.Numerics.Tensors.Tensor<T> input, int axis) where T : System.IEquatable<T>, System.Numerics.IEqualityOperators<T, T, bool> { throw null; }
     }
@@ -395,19 +425,25 @@ public readonly ref partial struct TensorSpan<T>
     {
         private readonly object _dummy;
         private readonly int _dummyPrimitive;
+        public TensorSpan(System.Span<T> span) { throw null; }
+        public TensorSpan(System.Span<T> span, scoped System.ReadOnlySpan<nint> lengths, scoped System.ReadOnlySpan<nint> strides) { throw null; }
         [System.CLSCompliantAttribute(false)]
-        public unsafe TensorSpan(void* pointer, System.ReadOnlySpan<nint> lengths, bool isPinned, System.ReadOnlySpan<nint> strides = default(System.ReadOnlySpan<nint>)) { throw null; }
-        public TensorSpan(T[]? array, nint start, System.ReadOnlySpan<nint> lengths) { throw null; }
-        public TensorSpan(T[]? array, System.ReadOnlySpan<nint> lengths) { throw null; }
-        public TensorSpan(T[]? array, System.ReadOnlySpan<nint> lengths, bool isPinned) { throw null; }
+        public unsafe TensorSpan(T* data, nint dataLength) { throw null; }
+        [System.CLSCompliantAttribute(false)]
+        public unsafe TensorSpan(T* data, nint dataLength, scoped System.ReadOnlySpan<nint> lengths, scoped System.ReadOnlySpan<nint> strides) { throw null; }
+        public TensorSpan(T[]? array) { throw null; }
+        public TensorSpan(T[]? array, System.Index startIndex, scoped System.ReadOnlySpan<nint> lengths, scoped System.ReadOnlySpan<nint> strides) { throw null; }
+        public TensorSpan(T[]? array, int start, scoped System.ReadOnlySpan<nint> lengths, scoped System.ReadOnlySpan<nint> strides) { throw null; }
         public static System.Numerics.Tensors.TensorSpan<T> Empty { get { throw null; } }
+        public nint FlattenedLength { get { throw null; } }
         public bool IsEmpty { get { throw null; } }
-        public bool IsPinned { get { throw null; } }
-        public System.Numerics.Tensors.TensorSpan<T> this[scoped System.ReadOnlySpan<System.Buffers.NRange> indices] { get { throw null; } set { } }
-        public ref T this[scoped System.ReadOnlySpan<nint> indices] { get { throw null; } }
-        public nint LinearLength { get { throw null; } }
+        public ref T this[scoped System.ReadOnlySpan<System.Buffers.NIndex> indexes] { get { throw null; } }
+        public System.Numerics.Tensors.TensorSpan<T> this[scoped System.ReadOnlySpan<System.Buffers.NRange> ranges] { get { throw null; } set { } }
+        public ref T this[scoped System.ReadOnlySpan<nint> indexes] { get { throw null; } }
+        [System.Diagnostics.CodeAnalysis.UnscopedRefAttribute]
+        public System.ReadOnlySpan<nint> Lengths { get { throw null; } }
         public int Rank { get { throw null; } }
-        public System.ReadOnlySpan<nint> Shape { get { throw null; } }
+        [System.Diagnostics.CodeAnalysis.UnscopedRefAttribute]
         public System.ReadOnlySpan<nint> Strides { get { throw null; } }
         public void Clear() { }
         public void CopyTo(System.Numerics.Tensors.TensorSpan<T> destination) { }
@@ -417,6 +453,7 @@ public void CopyTo(System.Numerics.Tensors.TensorSpan<T> destination) { }
         public override bool Equals(object? obj) { throw null; }
 #pragma warning restore CS0809 // Obsolete member overrides non-obsolete member
         public void Fill(T value) { }
+        public void FlattenTo(System.Span<T> destination) { }
         public System.Numerics.Tensors.TensorSpan<T>.Enumerator GetEnumerator() { throw null; }
         [System.ComponentModel.EditorBrowsableAttribute(System.ComponentModel.EditorBrowsableState.Never)]
         [System.ObsoleteAttribute("GetHashCode() on TensorSpan will always throw an exception.")]
@@ -427,11 +464,13 @@ public void Fill(T value) { }
         public ref T GetPinnableReference() { throw null; }
         public static bool operator ==(System.Numerics.Tensors.TensorSpan<T> left, System.Numerics.Tensors.TensorSpan<T> right) { throw null; }
         public static implicit operator System.Numerics.Tensors.ReadOnlyTensorSpan<T> (System.Numerics.Tensors.TensorSpan<T> span) { throw null; }
+        public static implicit operator System.Numerics.Tensors.TensorSpan<T> (T[]? array) { throw null; }
         public static bool operator !=(System.Numerics.Tensors.TensorSpan<T> left, System.Numerics.Tensors.TensorSpan<T> right) { throw null; }
+        public System.Numerics.Tensors.TensorSpan<T> Slice(scoped System.ReadOnlySpan<System.Buffers.NIndex> indexes) { throw null; }
         public System.Numerics.Tensors.TensorSpan<T> Slice(scoped System.ReadOnlySpan<System.Buffers.NRange> ranges) { throw null; }
-        public T[] ToArray() { throw null; }
         public override string ToString() { throw null; }
         public bool TryCopyTo(System.Numerics.Tensors.TensorSpan<T> destination) { throw null; }
+        public bool TryFlattenTo(System.Span<T> destination) { throw null; }
         public ref partial struct Enumerator
         {
             private object _dummy;
@@ -440,40 +479,64 @@ public ref partial struct Enumerator
             public bool MoveNext() { throw null; }
         }
     }
-    public sealed partial class Tensor<T> : System.Collections.Generic.IEnumerable<T>, System.Collections.IEnumerable, System.IEquatable<System.Numerics.Tensors.Tensor<T>>, System.Numerics.IEqualityOperators<System.Numerics.Tensors.Tensor<T>, System.Numerics.Tensors.Tensor<T>, bool>, System.Numerics.Tensors.ITensor<System.Numerics.Tensors.Tensor<T>, T>
+    public sealed partial class Tensor<T> : System.Collections.Generic.IEnumerable<T>, System.Collections.IEnumerable, System.Numerics.Tensors.IReadOnlyTensor<System.Numerics.Tensors.Tensor<T>, T>, System.Numerics.Tensors.ITensor<System.Numerics.Tensors.Tensor<T>, T>
     {
         internal Tensor() { }
         public static System.Numerics.Tensors.Tensor<T> Empty { get { throw null; } }
+        public nint FlattenedLength { get { throw null; } }
         public bool IsEmpty { get { throw null; } }
         public bool IsPinned { get { throw null; } }
+        public bool IsReadOnly { get { throw null; } }
         public System.Numerics.Tensors.Tensor<T> this[System.Numerics.Tensors.Tensor<bool> filter] { get { throw null; } }
-        public ref T this[scoped System.ReadOnlySpan<nint> indices] { get { throw null; } }
-        public nint LinearLength { get { throw null; } }
+        public ref T this[scoped System.ReadOnlySpan<System.Buffers.NIndex> indexes] { get { throw null; } }
+        public System.Numerics.Tensors.Tensor<T> this[scoped System.ReadOnlySpan<System.Buffers.NRange> ranges] { get { throw null; } set { } }
+        public ref T this[scoped System.ReadOnlySpan<nint> indexes] { get { throw null; } }
+        public System.ReadOnlySpan<nint> Lengths { get { throw null; } }
         public int Rank { get { throw null; } }
-        public System.ReadOnlySpan<nint> Shape { get { throw null; } }
         public System.ReadOnlySpan<nint> Strides { get { throw null; } }
+        T System.Numerics.Tensors.IReadOnlyTensor<System.Numerics.Tensors.Tensor<T>, T>.this[scoped System.ReadOnlySpan<System.Buffers.NIndex> indexes] { get { throw null; } }
+        System.Numerics.Tensors.Tensor<T> System.Numerics.Tensors.IReadOnlyTensor<System.Numerics.Tensors.Tensor<T>, T>.this[scoped System.ReadOnlySpan<System.Buffers.NRange> ranges] { get { throw null; } }
+        T System.Numerics.Tensors.IReadOnlyTensor<System.Numerics.Tensors.Tensor<T>, T>.this[scoped System.ReadOnlySpan<nint> indexes] { get { throw null; } }
+        T System.Numerics.Tensors.ITensor<System.Numerics.Tensors.Tensor<T>, T>.this[scoped System.ReadOnlySpan<System.Buffers.NIndex> indexes] { get { throw null; } set { } }
+        T System.Numerics.Tensors.ITensor<System.Numerics.Tensors.Tensor<T>, T>.this[scoped System.ReadOnlySpan<nint> indexes] { get { throw null; } set { } }
         public System.Numerics.Tensors.ReadOnlyTensorSpan<T> AsReadOnlyTensorSpan() { throw null; }
-        public System.Numerics.Tensors.ReadOnlyTensorSpan<T> AsReadOnlyTensorSpan(scoped System.ReadOnlySpan<System.Buffers.NRange> ranges) { throw null; }
+        public System.Numerics.Tensors.ReadOnlyTensorSpan<T> AsReadOnlyTensorSpan(scoped System.ReadOnlySpan<System.Buffers.NIndex> startIndex) { throw null; }
+        public System.Numerics.Tensors.ReadOnlyTensorSpan<T> AsReadOnlyTensorSpan(scoped System.ReadOnlySpan<System.Buffers.NRange> start) { throw null; }
+        public System.Numerics.Tensors.ReadOnlyTensorSpan<T> AsReadOnlyTensorSpan(scoped System.ReadOnlySpan<nint> start) { throw null; }
         public System.Numerics.Tensors.TensorSpan<T> AsTensorSpan() { throw null; }
-        public System.Numerics.Tensors.TensorSpan<T> AsTensorSpan(scoped System.ReadOnlySpan<System.Buffers.NRange> ranges) { throw null; }
+        public System.Numerics.Tensors.TensorSpan<T> AsTensorSpan(scoped System.ReadOnlySpan<System.Buffers.NIndex> startIndex) { throw null; }
+        public System.Numerics.Tensors.TensorSpan<T> AsTensorSpan(scoped System.ReadOnlySpan<System.Buffers.NRange> start) { throw null; }
+        public System.Numerics.Tensors.TensorSpan<T> AsTensorSpan(scoped System.ReadOnlySpan<nint> start) { throw null; }
         public void Clear() { }
         public void CopyTo(System.Numerics.Tensors.TensorSpan<T> destination) { }
+        public static System.Numerics.Tensors.Tensor<T> Create(System.ReadOnlySpan<nint> lengths, bool pinned = false) { throw null; }
+        public static System.Numerics.Tensors.Tensor<T> Create(System.ReadOnlySpan<nint> lengths, System.ReadOnlySpan<nint> strides, bool pinned = false) { throw null; }
+        public static System.Numerics.Tensors.Tensor<T> CreateUninitialized(System.ReadOnlySpan<nint> lengths, bool pinned = false) { throw null; }
+        public static System.Numerics.Tensors.Tensor<T> CreateUninitialized(System.ReadOnlySpan<nint> lengths, System.ReadOnlySpan<nint> strides, bool pinned = false) { throw null; }
         public bool Equals(System.Numerics.Tensors.Tensor<T>? other) { throw null; }
         public override bool Equals(object? obj) { throw null; }
         public void Fill(T value) { }
+        public void FlattenTo(System.Span<T> destination) { }
         public System.Collections.Generic.IEnumerator<T> GetEnumerator() { throw null; }
         public override int GetHashCode() { throw null; }
+        public void GetLengths(System.Span<nint> destination) { }
         [System.ComponentModel.EditorBrowsableAttribute(System.ComponentModel.EditorBrowsableState.Never)]
         public ref T GetPinnableReference() { throw null; }
+        public void GetStrides(System.Span<nint> destination) { }
         public static bool operator ==(System.Numerics.Tensors.Tensor<T>? left, System.Numerics.Tensors.Tensor<T>? right) { throw null; }
         public static bool operator ==(System.Numerics.Tensors.Tensor<T> left, T right) { throw null; }
         public static implicit operator System.Numerics.Tensors.ReadOnlyTensorSpan<T> (System.Numerics.Tensors.Tensor<T> value) { throw null; }
         public static implicit operator System.Numerics.Tensors.TensorSpan<T> (System.Numerics.Tensors.Tensor<T> value) { throw null; }
         public static bool operator !=(System.Numerics.Tensors.Tensor<T>? left, System.Numerics.Tensors.Tensor<T>? right) { throw null; }
         public static bool operator !=(System.Numerics.Tensors.Tensor<T> left, T right) { throw null; }
-        public System.Numerics.Tensors.Tensor<T> Slice(scoped System.ReadOnlySpan<System.Buffers.NRange> ranges) { throw null; }
+        public System.Numerics.Tensors.Tensor<T> Slice(scoped System.ReadOnlySpan<System.Buffers.NIndex> startIndex) { throw null; }
+        public System.Numerics.Tensors.Tensor<T> Slice(scoped System.ReadOnlySpan<System.Buffers.NRange> start) { throw null; }
+        public System.Numerics.Tensors.Tensor<T> Slice(scoped System.ReadOnlySpan<nint> start) { throw null; }
         System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator() { throw null; }
-        public string ToString(int maxRows, int maxColumns) { throw null; }
+        [System.ComponentModel.EditorBrowsableAttribute(System.ComponentModel.EditorBrowsableState.Never)]
+        ref readonly T System.Numerics.Tensors.IReadOnlyTensor<System.Numerics.Tensors.Tensor<T>, T>.GetPinnableReference() { throw null; }
+        public string ToString(scoped System.ReadOnlySpan<nint> maximumLengths) { throw null; }
         public bool TryCopyTo(System.Numerics.Tensors.TensorSpan<T> destination) { throw null; }
+        public bool TryFlattenTo(System.Span<T> destination) { throw null; }
     }
 }
diff --git a/src/libraries/System.Numerics.Tensors/src/System.Numerics.Tensors.csproj b/src/libraries/System.Numerics.Tensors/src/System.Numerics.Tensors.csproj
index bb3af1c3b83f1b..b40960a24e4b09 100644
--- a/src/libraries/System.Numerics.Tensors/src/System.Numerics.Tensors.csproj
+++ b/src/libraries/System.Numerics.Tensors/src/System.Numerics.Tensors.csproj
@@ -16,6 +16,7 @@
   </ItemGroup>
 
   <ItemGroup Condition="'$(TargetFrameworkIdentifier)' == '.NETCoreApp'">
+    <Compile Include="System\Numerics\Tensors\netcore\Common\IReadOnlyTensor.cs" />
     <Compile Include="System\Numerics\Tensors\netcore\TensorHelpers.cs" />
     <Compile Include="System\Numerics\Tensors\netcore\TensorExtensions.cs" />
     <Compile Include="System\Numerics\Tensors\netcore\Tensor.Factory.cs" />
diff --git a/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/Common/IReadOnlyTensor.cs b/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/Common/IReadOnlyTensor.cs
new file mode 100644
index 00000000000000..94059476a57b46
--- /dev/null
+++ b/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/Common/IReadOnlyTensor.cs
@@ -0,0 +1,46 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System;
+using System.Buffers;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace System.Numerics.Tensors
+{
+    public interface IReadOnlyTensor<TSelf, T> : IEnumerable<T>
+        where TSelf : IReadOnlyTensor<TSelf, T>
+    {
+        static abstract TSelf? Empty { get; }
+
+        bool IsEmpty { get; }
+        bool IsPinned { get; }
+        nint FlattenedLength { get; }
+        int Rank { get; }
+
+        T this[params ReadOnlySpan<nint> indexes] { get; }
+        T this[params ReadOnlySpan<NIndex> indexes] { get; }
+        TSelf this[params scoped ReadOnlySpan<NRange> ranges] { get; }
+
+        ReadOnlyTensorSpan<T> AsReadOnlyTensorSpan();
+        ReadOnlyTensorSpan<T> AsReadOnlyTensorSpan(params scoped ReadOnlySpan<nint> start);
+        ReadOnlyTensorSpan<T> AsReadOnlyTensorSpan(params scoped ReadOnlySpan<NIndex> startIndex);
+        ReadOnlyTensorSpan<T> AsReadOnlyTensorSpan(params scoped ReadOnlySpan<NRange> range);
+
+        void CopyTo(TensorSpan<T> destination);
+        void FlattenTo(Span<T> destination);
+
+        // These are not properties so that structs can implement the interface without allocating:
+        void GetLengths(Span<nint> destination);
+        void GetStrides(Span<nint> destination);
+
+        ref readonly T GetPinnableReference();
+        TSelf Slice(params scoped ReadOnlySpan<nint> start);
+        TSelf Slice(params scoped ReadOnlySpan<NIndex> startIndex);
+        TSelf Slice(params scoped ReadOnlySpan<NRange> range);
+        bool TryCopyTo(TensorSpan<T> destination);
+        bool TryFlattenTo(Span<T> destination);
+    }
+}
diff --git a/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/ITensor.cs b/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/ITensor.cs
index 5ba15d0e9516ab..49199a1b98f501 100644
--- a/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/ITensor.cs
+++ b/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/ITensor.cs
@@ -11,35 +11,32 @@
 namespace System.Numerics.Tensors
 {
     public interface ITensor<TSelf, T>
-        : IEnumerable<T>
+        : IReadOnlyTensor<TSelf, T>
         where TSelf : ITensor<TSelf, T>
     {
         // TODO: Determine if we can implement `IEqualityOperators<TSelf, T, bool>`.
         // It looks like C#/.NET currently hits limitations here as it believes TSelf and T could be the same type
         // Ideally we could annotate it such that they cannot be the same type and no conflicts would exist
 
-        static abstract TSelf? Empty { get; }
+        static abstract TSelf Create(ReadOnlySpan<nint> lengths, bool pinned = false);
+        static abstract TSelf Create(ReadOnlySpan<nint> lengths, ReadOnlySpan<nint> strides, bool pinned = false);
 
-        bool IsEmpty { get; }
-        bool IsPinned { get; }
-        int Rank { get; }
-        nint FlattenedLength { get; }
-        // THIS IS GOING TO PEND A DISCUSSION WITH THE LANGUAGE TEAM
-        void GetStrides(Span<nint> destination);
-        void GetLengths(Span<nint> destination);
+        static abstract TSelf CreateUninitialized(ReadOnlySpan<nint> lengths, bool pinned = false);
+        static abstract TSelf CreateUninitialized(ReadOnlySpan<nint> lengths, ReadOnlySpan<nint> strides, bool pinned = false);
 
-        T this[params scoped ReadOnlySpan<nint> indexes] { get; }
-        T this[params scoped ReadOnlySpan<NIndex> indexes] { get; set; }
-        TSelf this[params scoped ReadOnlySpan<NRange> ranges] { get; set; }
+        bool IsReadOnly { get; }
 
-        TensorSpan<T> AsTensorSpan(params scoped ReadOnlySpan<NRange> ranges);
-        ReadOnlyTensorSpan<T> AsReadOnlyTensorSpan(params scoped ReadOnlySpan<NRange> ranges);
-        ref T GetPinnableReference();
-        TSelf Slice(params scoped ReadOnlySpan<NRange> ranges);
+        new T this[params ReadOnlySpan<nint> indexes] { get; set; }
+        new T this[params ReadOnlySpan<NIndex> indexes] { get; set; }
+        new TSelf this[params scoped ReadOnlySpan<NRange> ranges] { get; set; }
+
+        TensorSpan<T> AsTensorSpan();
+        TensorSpan<T> AsTensorSpan(params scoped ReadOnlySpan<nint> start);
+        TensorSpan<T> AsTensorSpan(params scoped ReadOnlySpan<NIndex> startIndex);
+        TensorSpan<T> AsTensorSpan(params scoped ReadOnlySpan<NRange> range);
 
         void Clear();
-        void CopyTo(TensorSpan<T> destination);
         void Fill(T value);
-        bool TryCopyTo(TensorSpan<T> destination);
+        new ref T GetPinnableReference();
     }
 }
diff --git a/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/ReadOnlyTensorSpan.cs b/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/ReadOnlyTensorSpan.cs
index 7c6fc043700b91..3e5541dd66b5d9 100644
--- a/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/ReadOnlyTensorSpan.cs
+++ b/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/ReadOnlyTensorSpan.cs
@@ -56,7 +56,7 @@ public ReadOnlyTensorSpan(T[]? array) : this(array, 0, default, default)
         /// <remarks>Returns default when <paramref name="array"/> is null.</remarks>
         /// <exception cref="ArrayTypeMismatchException">Thrown when <paramref name="array"/> is covariant and array's type is not exactly T[].</exception>
         /// <exception cref="ArgumentOutOfRangeException">
-        /// Thrown when the specified <paramref name="startIndex"/> or end index is not in the range (&lt;0 or &gt;Length).
+        /// Thrown when the specified <paramref name="startIndex"/> or end index is not in the range (&lt;0 or &gt;FlattenedLength).
         /// </exception>
         public ReadOnlyTensorSpan(T[]? array, Index startIndex, ReadOnlySpan<nint> lengths, ReadOnlySpan<nint> strides)
             : this(array, startIndex.GetOffset(array?.Length ?? 0), lengths, strides)
@@ -74,7 +74,7 @@ public ReadOnlyTensorSpan(T[]? array, Index startIndex, ReadOnlySpan<nint> lengt
         /// <remarks>Returns default when <paramref name="array"/> is null.</remarks>
         /// <exception cref="ArrayTypeMismatchException">Thrown when <paramref name="array"/> is covariant and array's type is not exactly T[].</exception>
         /// <exception cref="ArgumentOutOfRangeException">
-        /// Thrown when the specified <paramref name="start"/> or end index is not in the range (&lt;0 or &gt;Length).
+        /// Thrown when the specified <paramref name="start"/> or end index is not in the range (&lt;0 or &gt;FlattenedLength).
         /// </exception>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public ReadOnlyTensorSpan(T[]? array, int start, ReadOnlySpan<nint> lengths, ReadOnlySpan<nint> strides)
@@ -205,7 +205,7 @@ internal ReadOnlyTensorSpan(ref T reference, scoped ReadOnlySpan<nint> lengths,
         /// <param name="indexes"></param>
         /// <returns></returns>
         /// <exception cref="IndexOutOfRangeException">
-        /// Thrown when any index is less than 0 or any index is greater than or equal to Length
+        /// Thrown when any index is less than 0 or any index is greater than or equal to FlattenedLength
         /// </exception>
         public ref readonly T this[params scoped ReadOnlySpan<nint> indexes]
         {
@@ -229,7 +229,7 @@ public ref readonly T this[params scoped ReadOnlySpan<nint> indexes]
         /// <param name="indexes"></param>
         /// <returns></returns>
         /// <exception cref="IndexOutOfRangeException">
-        /// Thrown when any index is less than 0 or any index is greater than or equal to Length
+        /// Thrown when any index is less than 0 or any index is greater than or equal to FlattenedLength
         /// </exception>
         public ref readonly T this[params scoped ReadOnlySpan<NIndex> indexes]
         {
@@ -252,7 +252,7 @@ public ref readonly T this[params scoped ReadOnlySpan<NIndex> indexes]
         /// <param name="ranges"></param>
         /// <returns></returns>
         /// <exception cref="IndexOutOfRangeException">
-        /// Thrown when any index is less than 0 or any index is greater than or equal to Length
+        /// Thrown when any index is less than 0 or any index is greater than or equal to FlattenedLength
         /// </exception>
         public ReadOnlyTensorSpan<T> this[params scoped ReadOnlySpan<NRange> ranges]
         {
@@ -515,7 +515,7 @@ public bool TryCopyTo(TensorSpan<T> destination)
         /// <param name="indexes">The indexes for the slice.</param>
         /// <returns></returns>
         /// <exception cref="IndexOutOfRangeException">
-        /// Thrown when any index is less than 0 or any index is greater than or equal to Length
+        /// Thrown when any index is less than 0 or any index is greater than or equal to FlattenedLength
         /// </exception>
         public ReadOnlyTensorSpan<T> Slice(params scoped ReadOnlySpan<NIndex> indexes)
         {
diff --git a/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/Tensor.Factory.cs b/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/Tensor.Factory.cs
index cadcd28f2d2579..552398f097727a 100644
--- a/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/Tensor.Factory.cs
+++ b/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/Tensor.Factory.cs
@@ -13,30 +13,30 @@ namespace System.Numerics.Tensors
     public static partial class Tensor
     {
         /// <summary>
-        /// Creates a <see cref="Tensor{T}"/> and initializes it with the default value of T. If <paramref name="mustPin"/> is true, the memory will be pinned.
+        /// Creates a <see cref="Tensor{T}"/> and initializes it with the default value of T. If <paramref name="pinned"/> is true, the memory will be pinned.
         /// </summary>
-        /// <param name="mustPin">A <see cref="bool"/> whether the underlying data should be pinned or not.</param>
         /// <param name="lengths">A <see cref="ReadOnlySpan{T}"/> indicating the lengths of each dimension.</param>
-        public static Tensor<T> Create<T>(bool mustPin, ReadOnlySpan<nint> lengths)
+        /// <param name="pinned">A <see cref="bool"/> whether the underlying data should be pinned or not.</param>
+        public static Tensor<T> Create<T>(ReadOnlySpan<nint> lengths, bool pinned = false)
             where T : IEquatable<T>
         {
             nint linearLength = TensorSpanHelpers.CalculateTotalLength(lengths);
-            T[] values = mustPin ? GC.AllocateArray<T>((int)linearLength, mustPin) : (new T[linearLength]);
-            return new Tensor<T>(values, lengths.ToArray(), mustPin);
+            T[] values = pinned ? GC.AllocateArray<T>((int)linearLength, pinned) : (new T[linearLength]);
+            return new Tensor<T>(values, lengths.ToArray(), pinned);
         }
 
         /// <summary>
-        /// Creates a <see cref="Tensor{T}"/> and initializes it with the default value of T. If <paramref name="mustPin"/> is true, the memory will be pinned.
+        /// Creates a <see cref="Tensor{T}"/> and initializes it with the default value of T. If <paramref name="pinned"/> is true, the memory will be pinned.
         /// </summary>
-        /// <param name="mustPin">A <see cref="bool"/> whether the underlying data should be pinned or not.</param>
         /// <param name="lengths">A <see cref="ReadOnlySpan{T}"/> indicating the lengths of each dimension.</param>
         /// <param name="strides">A <see cref="ReadOnlySpan{T}"/> indicating the strides of each dimension.</param>
-        public static Tensor<T> Create<T>(bool mustPin, ReadOnlySpan<nint> lengths, ReadOnlySpan<nint> strides)
+        /// <param name="pinned">A <see cref="bool"/> whether the underlying data should be pinned or not.</param>
+        public static Tensor<T> Create<T>(ReadOnlySpan<nint> lengths, ReadOnlySpan<nint> strides, bool pinned = false)
             where T : IEquatable<T>
         {
             nint linearLength = TensorSpanHelpers.CalculateTotalLength(lengths);
-            T[] values = mustPin ? GC.AllocateArray<T>((int)linearLength, mustPin) : (new T[linearLength]);
-            return new Tensor<T>(values, lengths.ToArray(), strides.ToArray(), mustPin);
+            T[] values = pinned ? GC.AllocateArray<T>((int)linearLength, pinned) : (new T[linearLength]);
+            return new Tensor<T>(values, lengths.ToArray(), strides.ToArray(), pinned);
         }
 
         /// <summary>
@@ -75,30 +75,30 @@ public static Tensor<T> Create<T>(T[] values, ReadOnlySpan<nint> lengths, ReadOn
         }
 
         /// <summary>
-        /// Creates a <see cref="Tensor{T}"/> and does not initialize it. If <paramref name="mustPin"/> is true, the memory will be pinned.
+        /// Creates a <see cref="Tensor{T}"/> and does not initialize it. If <paramref name="pinned"/> is true, the memory will be pinned.
         /// </summary>
-        /// <param name="mustPin">A <see cref="bool"/> whether the underlying data should be pinned or not.</param>
         /// <param name="lengths">A <see cref="ReadOnlySpan{T}"/> indicating the lengths of each dimension.</param>
-        public static Tensor<T> CreateUninitialized<T>(bool mustPin, ReadOnlySpan<nint> lengths)
+        /// <param name="pinned">A <see cref="bool"/> whether the underlying data should be pinned or not.</param>
+        public static Tensor<T> CreateUninitialized<T>(ReadOnlySpan<nint> lengths, bool pinned = false)
             where T : IEquatable<T>
         {
             nint linearLength = TensorSpanHelpers.CalculateTotalLength(lengths);
-            T[] values = GC.AllocateUninitializedArray<T>((int)linearLength, mustPin);
-            return new Tensor<T>(values, lengths.ToArray(), mustPin);
+            T[] values = GC.AllocateUninitializedArray<T>((int)linearLength, pinned);
+            return new Tensor<T>(values, lengths.ToArray(), pinned);
         }
 
         /// <summary>
-        /// Creates a <see cref="Tensor{T}"/> and does not initialize it. If <paramref name="mustPin"/> is true, the memory will be pinned.
+        /// Creates a <see cref="Tensor{T}"/> and does not initialize it. If <paramref name="pinned"/> is true, the memory will be pinned.
         /// </summary>
-        /// <param name="mustPin">A <see cref="bool"/> whether the underlying data should be pinned or not.</param>
         /// <param name="lengths">A <see cref="ReadOnlySpan{T}"/> indicating the lengths of each dimension.</param>
         /// <param name="strides">A <see cref="ReadOnlySpan{T}"/> indicating the strides of each dimension.</param>
-        public static Tensor<T> CreateUninitialized<T>(bool mustPin, ReadOnlySpan<nint> lengths, ReadOnlySpan<nint> strides)
+        /// <param name="pinned">A <see cref="bool"/> whether the underlying data should be pinned or not.</param>
+        public static Tensor<T> CreateUninitialized<T>(ReadOnlySpan<nint> lengths, ReadOnlySpan<nint> strides, bool pinned = false )
             where T : IEquatable<T>
         {
             nint linearLength = TensorSpanHelpers.CalculateTotalLength(lengths);
-            T[] values = GC.AllocateUninitializedArray<T>((int)linearLength, mustPin);
-            return new Tensor<T>(values, lengths.ToArray(), strides.ToArray(), mustPin);
+            T[] values = GC.AllocateUninitializedArray<T>((int)linearLength, pinned);
+            return new Tensor<T>(values, lengths.ToArray(), strides.ToArray(), pinned);
         }
 
         /// <summary>
diff --git a/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/Tensor.cs b/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/Tensor.cs
index 17d3c5c7428de8..795e8585dbe3b9 100644
--- a/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/Tensor.cs
+++ b/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/Tensor.cs
@@ -76,8 +76,57 @@ internal Tensor(T[] values, scoped ReadOnlySpan<nint> lengths, ReadOnlySpan<nint
 
         }
 
-        // ITensor
+        /// <summary>
+        /// Creates a <see cref="Tensor{T}"/> and initializes it with the default value of T. If <paramref name="pinned"/> is true, the memory will be pinned.
+        /// </summary>
+        /// <param name="lengths">A <see cref="ReadOnlySpan{T}"/> indicating the lengths of each dimension.</param>
+        /// <param name="pinned">A <see cref="bool"/> whether the underlying data should be pinned or not.</param>
+        public static Tensor<T> Create(ReadOnlySpan<nint> lengths, bool pinned = false)
+        {
+            nint linearLength = TensorSpanHelpers.CalculateTotalLength(lengths);
+            T[] values = pinned ? GC.AllocateArray<T>((int)linearLength, pinned) : (new T[linearLength]);
+            return new Tensor<T>(values, lengths.ToArray(), pinned);
+        }
+
+        /// <summary>
+        /// Creates a <see cref="Tensor{T}"/> and initializes it with the default value of T. If <paramref name="pinned"/> is true, the memory will be pinned.
+        /// </summary>
+        /// <param name="lengths">A <see cref="ReadOnlySpan{T}"/> indicating the lengths of each dimension.</param>
+        /// <param name="strides">A <see cref="ReadOnlySpan{T}"/> indicating the strides of each dimension.</param>
+        /// <param name="pinned">A <see cref="bool"/> whether the underlying data should be pinned or not.</param>
+        public static Tensor<T> Create(ReadOnlySpan<nint> lengths, ReadOnlySpan<nint> strides, bool pinned = false)
+        {
+            nint linearLength = TensorSpanHelpers.CalculateTotalLength(lengths);
+            T[] values = pinned ? GC.AllocateArray<T>((int)linearLength, pinned) : (new T[linearLength]);
+            return new Tensor<T>(values, lengths.ToArray(), strides.ToArray(), pinned);
+        }
+
+        /// <summary>
+        /// Creates a <see cref="Tensor{T}"/> and does not initialize it. If <paramref name="pinned"/> is true, the memory will be pinned.
+        /// </summary>
+        /// <param name="lengths">A <see cref="ReadOnlySpan{T}"/> indicating the lengths of each dimension.</param>
+        /// <param name="pinned">A <see cref="bool"/> whether the underlying data should be pinned or not.</param>
+        public static Tensor<T> CreateUninitialized(ReadOnlySpan<nint> lengths, bool pinned = false)
+        {
+            nint linearLength = TensorSpanHelpers.CalculateTotalLength(lengths);
+            T[] values = GC.AllocateUninitializedArray<T>((int)linearLength, pinned);
+            return new Tensor<T>(values, lengths.ToArray(), pinned);
+        }
+
+        /// <summary>
+        /// Creates a <see cref="Tensor{T}"/> and does not initialize it. If <paramref name="pinned"/> is true, the memory will be pinned.
+        /// </summary>
+        /// <param name="lengths">A <see cref="ReadOnlySpan{T}"/> indicating the lengths of each dimension.</param>
+        /// <param name="strides">A <see cref="ReadOnlySpan{T}"/> indicating the strides of each dimension.</param>
+        /// <param name="pinned">A <see cref="bool"/> whether the underlying data should be pinned or not.</param>
+        public static Tensor<T> CreateUninitialized(ReadOnlySpan<nint> lengths, ReadOnlySpan<nint> strides, bool pinned = false)
+        {
+            nint linearLength = TensorSpanHelpers.CalculateTotalLength(lengths);
+            T[] values = GC.AllocateUninitializedArray<T>((int)linearLength, pinned);
+            return new Tensor<T>(values, lengths.ToArray(), strides.ToArray(), pinned);
+        }
 
+        // ITensor
         /// <summary>
         /// The Empty Tensor.
         /// </summary>
@@ -113,26 +162,148 @@ internal Tensor(T[] values, scoped ReadOnlySpan<nint> lengths, ReadOnlySpan<nint
         /// <value><see cref="ReadOnlySpan{T}"/> with the lengths of each dimension.</value>
         public ReadOnlySpan<nint> Lengths => _lengths;
 
+        /// <summary>
+        /// Gets the length of each dimension in this <see cref="Tensor{T}"/>.
+        /// </summary>
+        /// <value><see cref="ReadOnlySpan{T}"/> with the lengths of each dimension.</value>
+        public void GetLengths(Span<nint> destination) => _lengths.CopyTo(destination);
+
+
         /// <summary>
         /// Gets the strides of each dimension in this <see cref="Tensor{T}"/>.
         /// </summary>
         /// <value><see cref="ReadOnlySpan{T}"/> with the strides of each dimension.</value>
         public ReadOnlySpan<nint> Strides => _strides;
 
-        public Tensor<T> this[params ReadOnlySpan<NRange> ranges] { get => throw new NotImplementedException(); set => throw new NotImplementedException(); }
-        public T this[params ReadOnlySpan<NIndex> indexes] { get => throw new NotImplementedException(); set => throw new NotImplementedException(); }
+        /// <summary>
+        /// Gets the strides of each dimension in this <see cref="Tensor{T}"/>.
+        /// </summary>
+        /// <value><see cref="ReadOnlySpan{T}"/> with the strides of each dimension.</value>
+        public void GetStrides(Span<nint> destination) => _strides.CopyTo(destination);
+
+        public bool IsReadOnly => false;
+
+        /// <summary>
+        /// Returns a reference to specified element of the Tensor.
+        /// </summary>
+        /// <param name="indexes"></param>
+        /// <returns></returns>
+        /// <exception cref="IndexOutOfRangeException">
+        /// Thrown when index less than 0 or index greater than or equal to FlattenedLength
+        /// </exception>
+        public ref T this[params ReadOnlySpan<nint> indexes] => ref AsTensorSpan()[indexes];
+
+        /// <summary>
+        /// Returns a reference to specified element of the Tensor.
+        /// </summary>
+        /// <param name="indexes"></param>
+        /// <returns></returns>
+        /// <exception cref="IndexOutOfRangeException">
+        /// Thrown when index less than 0 or index greater than or equal to FlattenedLength
+        /// </exception>
+        public ref T this[params ReadOnlySpan<NIndex> indexes] => ref AsTensorSpan()[indexes];
+
+        /// <summary>
+        /// Returns a slice of the Tensor.
+        /// </summary>
+        /// <param name="ranges"></param>
+        /// <returns></returns>
+        /// <exception cref="IndexOutOfRangeException">
+        /// Thrown when any index is less than 0 or any index is greater than or equal to FlattenedLength
+        /// </exception>
+        public Tensor<T> this[params ReadOnlySpan<NRange> ranges]
+        {
+            get
+            {
+                if (ranges.Length != Rank)
+                    ThrowHelper.ThrowIndexOutOfRangeException();
+
+                return Slice(ranges);
+            }
+            set
+            {
+
+            }
+        }
+
+        /// <summary>
+        /// Returns the specified element of the Tensor.
+        /// </summary>
+        /// <param name="indexes"></param>
+        /// <returns></returns>
+        /// <exception cref="IndexOutOfRangeException">
+        /// Thrown when index less than 0 or index greater than or equal to FlattenedLength
+        /// </exception>
+        T ITensor<Tensor<T>, T>.this[params scoped ReadOnlySpan<nint> indexes]
+        {
+            get
+            {
+                return this[indexes];
+            }
+            set
+            {
+                this[indexes] = value;
+            }
+        }
+
+        /// <summary>
+        /// Returns the specified element of the Tensor.
+        /// </summary>
+        /// <param name="indexes"></param>
+        /// <returns></returns>
+        /// <exception cref="IndexOutOfRangeException">
+        /// Thrown when index less than 0 or index greater than or equal to FlattenedLength
+        /// </exception>
+        T ITensor<Tensor<T>, T>.this[params scoped ReadOnlySpan<NIndex> indexes]
+        {
+            get
+            {
+                return this[indexes];
+            }
+            set
+            {
+                this[indexes] = value;
+            }
+        }
+
+        /// <summary>
+        /// Returns the specified element of the ReadOnlyTensor.
+        /// </summary>
+        /// <param name="indexes"></param>
+        /// <returns></returns>
+        /// <exception cref="IndexOutOfRangeException">
+        /// Thrown when index less than 0 or index greater than or equal to FlattenedLength
+        /// </exception>
+        T IReadOnlyTensor<Tensor<T>, T>.this[params ReadOnlySpan<nint> indexes] => AsReadOnlyTensorSpan()[indexes];
 
-        T ITensor<Tensor<T>, T>.this[params ReadOnlySpan<nint> indexes] => throw new NotImplementedException();
+        /// <summary>
+        /// Returns the specified element of the ReadOnlyTensor.
+        /// </summary>
+        /// <param name="indexes"></param>
+        /// <returns></returns>
+        /// <exception cref="IndexOutOfRangeException">
+        /// Thrown when index less than 0 or index greater than or equal to FlattenedLength
+        /// </exception>
+        T IReadOnlyTensor<Tensor<T>, T>.this[params ReadOnlySpan<NIndex> indexes] => AsReadOnlyTensorSpan()[indexes];
 
         /// <summary>
-        /// Returns a reference to specified element of the Span.
+        /// Returns a slice of the ReadOnlyTensor.
         /// </summary>
-        /// <param name="indices"></param>
+        /// <param name="ranges"></param>
         /// <returns></returns>
         /// <exception cref="IndexOutOfRangeException">
-        /// Thrown when index less than 0 or index greater than or equal to Length
+        /// Thrown when any index is less than 0 or any index is greater than or equal to FlattenedLength
         /// </exception>
-        public ref T this[params ReadOnlySpan<nint> indices] => ref AsTensorSpan()[indices];
+        Tensor<T> IReadOnlyTensor<Tensor<T>, T>.this[params ReadOnlySpan<NRange> ranges]
+        {
+            get
+            {
+                if (ranges.Length != Rank)
+                    ThrowHelper.ThrowIndexOutOfRangeException();
+
+                return Slice(ranges);
+            }
+        }
 
         // REVIEW: WE WILL WANT THIS CHANGED FROM A BOOL TO SOME FILTER EXPRESSION.
         /// <summary>
@@ -183,6 +354,27 @@ public Tensor<T> this[Tensor<bool> filter]
         /// <returns><see cref="TensorSpan{T}"/></returns>
         public TensorSpan<T> AsTensorSpan() => new TensorSpan<T>(ref MemoryMarshal.GetArrayDataReference(_values), _lengths, _strides);
 
+        /// <summary>
+        /// Converts this <see cref="Tensor{T}"/> to a <see cref="TensorSpan{T}"/> pointing to the same backing memory based on the provided ranges."/>
+        /// </summary>
+        /// <param name="start">The ranges you want in the <see cref="TensorSpan{T}"/>.</param>
+        /// <returns><see cref="TensorSpan{T}"/> based on the provided ranges.</returns>
+        public TensorSpan<T> AsTensorSpan(params ReadOnlySpan<NRange> start) => AsTensorSpan().Slice(start);
+
+        /// <summary>
+        /// Converts this <see cref="Tensor{T}"/> to a <see cref="TensorSpan{T}"/> pointing to the same backing memory based on the provided start locations."/>
+        /// </summary>
+        /// <param name="start">The start location you want in the <see cref="TensorSpan{T}"/>.</param>
+        /// <returns><see cref="TensorSpan{T}"/> based on the provided ranges.</returns>
+        public TensorSpan<T> AsTensorSpan(params ReadOnlySpan<nint> start) => Slice(start);
+
+        /// <summary>
+        /// Converts this <see cref="Tensor{T}"/> to a <see cref="TensorSpan{T}"/> pointing to the same backing memory based on the provided start indexes."/>
+        /// </summary>
+        /// <param name="startIndex">The ranges you want in the <see cref="TensorSpan{T}"/>.</param>
+        /// <returns><see cref="TensorSpan{T}"/> based on the provided ranges.</returns>
+        public TensorSpan<T> AsTensorSpan(params ReadOnlySpan<NIndex> startIndex) => AsTensorSpan().Slice(startIndex);
+
         /// <summary>
         /// Converts this <see cref="Tensor{T}"/> to a <see cref="ReadOnlyTensorSpan{T}"/> pointing to the same backing memory."/>
         /// </summary>
@@ -190,18 +382,25 @@ public Tensor<T> this[Tensor<bool> filter]
         public ReadOnlyTensorSpan<T> AsReadOnlyTensorSpan() => new ReadOnlyTensorSpan<T>(ref MemoryMarshal.GetArrayDataReference(_values), _lengths, _strides);
 
         /// <summary>
-        /// Converts this <see cref="Tensor{T}"/> to a <see cref="TensorSpan{T}"/> pointing to the same backing memory based on the provided ranges."/>
+        /// Converts this <see cref="Tensor{T}"/> to a <see cref="ReadOnlyTensorSpan{T}"/> pointing to the same backing memory based on the provided ranges."/>
         /// </summary>
-        /// <param name="ranges">The ranges you want in the <see cref="TensorSpan{T}"/>.</param>
-        /// <returns><see cref="TensorSpan{T}"/> based on the provided ranges.</returns>
-        public TensorSpan<T> AsTensorSpan(params ReadOnlySpan<NRange> ranges) => AsTensorSpan().Slice(ranges);
+        /// <param name="start">The ranges you want in the <see cref="ReadOnlyTensorSpan{T}"/></param>
+        /// <returns></returns>
+        public ReadOnlyTensorSpan<T> AsReadOnlyTensorSpan(params ReadOnlySpan<NRange> start) => AsTensorSpan().Slice(start);
 
         /// <summary>
-        /// Converts this <see cref="Tensor{T}"/> to a <see cref="ReadOnlyTensorSpan{T}"/> pointing to the same backing memory based on the provided ranges."/>
+        /// Converts this <see cref="Tensor{T}"/> to a <see cref="ReadOnlyTensorSpan{T}"/> pointing to the same backing memory based on the provided start locations."/>
         /// </summary>
-        /// <param name="ranges">The ranges you want in the <see cref="ReadOnlyTensorSpan{T}"/></param>
+        /// <param name="start">The start locations you want in the <see cref="ReadOnlyTensorSpan{T}"/></param>
         /// <returns></returns>
-        public ReadOnlyTensorSpan<T> AsReadOnlyTensorSpan(params ReadOnlySpan<NRange> ranges) => AsTensorSpan().Slice(ranges);
+        public ReadOnlyTensorSpan<T> AsReadOnlyTensorSpan(params ReadOnlySpan<nint> start) => Slice(start);
+
+        /// <summary>
+        /// Converts this <see cref="Tensor{T}"/> to a <see cref="ReadOnlyTensorSpan{T}"/> pointing to the same backing memory based on the provided start indexes."/>
+        /// </summary>
+        /// <param name="startIndex">The start indexes you want in the <see cref="ReadOnlyTensorSpan{T}"/></param>
+        /// <returns></returns>
+        public ReadOnlyTensorSpan<T> AsReadOnlyTensorSpan(params ReadOnlySpan<NIndex> startIndex) => AsTensorSpan().Slice(startIndex);
 
         /// <summary>
         /// Returns a reference to the 0th element of the Tensor. If the Tensor is empty, returns null reference.
@@ -210,25 +409,63 @@ public Tensor<T> this[Tensor<bool> filter]
         [EditorBrowsable(EditorBrowsableState.Never)]
         public ref T GetPinnableReference() => ref AsTensorSpan().GetPinnableReference();
 
+        /// <summary>
+        /// Returns a reference to the 0th element of the ReadOnlyTensor. If the ReadOnlyTensor is empty, returns null reference.
+        /// It can be used for pinning and is required to support the use of ReadOnlyTensor within a fixed statement.
+        /// </summary>
+        [EditorBrowsable(EditorBrowsableState.Never)]
+        ref readonly T IReadOnlyTensor<Tensor<T>, T>.GetPinnableReference() => ref AsReadOnlyTensorSpan().GetPinnableReference();
+
         /// <summary>
         /// Forms a slice out of the given tensor
         /// </summary>
-        /// <param name="ranges">The ranges for the slice</param>
+        /// <param name="start">The ranges for the slice</param>
         /// <returns><see cref="Tensor{T}"/> as a copy of the provided ranges.</returns>
         // REVIEW: CURRENTLY DOES A COPY.
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public Tensor<T> Slice(params ReadOnlySpan<NRange> ranges)
+        public Tensor<T> Slice(params ReadOnlySpan<NRange> start)
         {
-            if (ranges.Length != Lengths.Length)
-                throw new ArgumentOutOfRangeException(nameof(ranges), "Number of dimensions to slice does not equal the number of dimensions in the span");
+            if (start.Length != Lengths.Length)
+                throw new ArgumentOutOfRangeException(nameof(start), "Number of dimensions to slice does not equal the number of dimensions in the span");
 
-            TensorSpan<T> s = AsTensorSpan(ranges);
+            TensorSpan<T> s = AsTensorSpan(start);
             T[] values = _isPinned ? GC.AllocateArray<T>(checked((int)s.FlattenedLength), _isPinned) : (new T[s.FlattenedLength]);
             var outTensor = new Tensor<T>(values, s.Lengths.ToArray(), _isPinned);
             s.CopyTo(outTensor);
             return outTensor;
         }
 
+        /// <summary>
+        /// Forms a slice out of the given tensor
+        /// </summary>
+        /// <param name="start">The start indexes for the slice</param>
+        /// <returns><see cref="Tensor{T}"/> as a copy of the provided ranges.</returns>
+        // REVIEW: CURRENTLY DOES A COPY.
+        public Tensor<T> Slice(params ReadOnlySpan<nint> start)
+        {
+            NRange[] ranges = new NRange[start.Length];
+            for (int i = 0; i < start.Length; i++)
+            {
+                ranges[i] = new NRange(start[i], new NIndex(0, fromEnd: true));
+            }
+            return Slice(ranges);
+        }
+
+        /// <summary>
+        /// Forms a slice out of the given tensor
+        /// </summary>
+        /// <param name="startIndex">The start indexes for the slice</param>
+        /// <returns><see cref="Tensor{T}"/> as a copy of the provided ranges.</returns>
+        // REVIEW: CURRENTLY DOES A COPY.
+        public Tensor<T> Slice(params ReadOnlySpan<NIndex> startIndex)
+        {
+            NRange[] ranges = new NRange[startIndex.Length];
+            for (int i = 0; i < startIndex.Length; i++)
+            {
+                ranges[i] = new NRange(startIndex[i], new NIndex(0, fromEnd: true));
+            }
+            return Slice(ranges);
+        }
+
         /// <summary>
         /// Clears the contents of this tensor.
         /// </summary>
@@ -263,6 +500,18 @@ public Tensor<T> Slice(params ReadOnlySpan<NRange> ranges)
         /// return false and no data is written to the destination.</returns>
         public bool TryCopyTo(TensorSpan<T> destination) => AsTensorSpan().TryCopyTo(destination);
 
+        /// <summary>
+        /// Flattens the contents of this Tensor into the provided <see cref="Span{T}"/>.
+        /// </summary>
+        /// <param name="destination">The span to copy items into.</param>
+        public void FlattenTo(Span<T> destination) => AsTensorSpan().FlattenTo(destination);
+
+        /// <summary>
+        /// Flattens the contents of this Tensor into the provided <see cref="Span{T}"/>.
+        /// </summary>
+        /// <param name="destination">The span to copy items into.</param>
+        public bool TryFlattenTo(Span<T> destination) => AsTensorSpan().TryFlattenTo(destination);
+
         // IEnumerable
         /// <summary>
         /// Gets an <see cref="IEnumerator{T}"/> for the <see cref="Tensor{T}"/>.
@@ -442,7 +691,12 @@ private string ToMetadataString()
             return sb.ToString();
         }
 
-        public string ToString(int maxRows, int maxColumns)
+        /// <summary>
+        /// Creates a <see cref="string"/> representation of the <see cref="TensorSpan{T}"/>."/>
+        /// </summary>
+        /// <param name="maximumLengths">Maximum Length of each dimension</param>
+        /// <returns>A <see cref="string"/> representation of the <see cref="Tensor{T}"/></returns>
+        public string ToString(params ReadOnlySpan<nint> maximumLengths)
         {
             var sb = new StringBuilder();
             sb.AppendLine(ToMetadataString());
@@ -451,8 +705,5 @@ public string ToString(int maxRows, int maxColumns)
             sb.AppendLine("}");
             return sb.ToString();
         }
-
-        public void GetStrides(Span<nint> destination) => throw new NotImplementedException();
-        public void GetLengths(Span<nint> destination) => throw new NotImplementedException();
     }
 }
diff --git a/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/TensorExtensions.cs b/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/TensorExtensions.cs
index 8a0802c325b3ed..d35cdc639347ce 100644
--- a/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/TensorExtensions.cs
+++ b/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/TensorExtensions.cs
@@ -26,19 +26,17 @@ public static partial class Tensor
         /// Creates a <see cref="string"/> representation of the <see cref="TensorSpan{T}"/>."/>
         /// </summary>
         /// <param name="span">The <see cref="TensorSpan{T}"/> you want to represent as a string.</param>
-        /// <param name="maxRows">Max rows to show.</param>
-        /// <param name="maxColumns">Max columns to show.</param>
+        /// <param name="maximumLengths">Maximum Length of each dimension</param>
         /// <returns>A <see cref="string"/> representation of the <paramref name="span"/></returns>
-        public static string ToString<T>(this TensorSpan<T> span, int maxRows, int maxColumns) => ((ReadOnlyTensorSpan<T>)span).ToString(maxRows, maxColumns);
+        public static string ToString<T>(this TensorSpan<T> span, params ReadOnlySpan<nint> maximumLengths) => ((ReadOnlyTensorSpan<T>)span).ToString(maximumLengths);
 
         /// <summary>
         /// Creates a <see cref="string"/> representation of the <see cref="ReadOnlyTensorSpan{T}"/>."/>
         /// </summary>
         /// <typeparam name="T"></typeparam>
         /// <param name="span">The <see cref="ReadOnlyTensorSpan{T}"/> you want to represent as a string.</param>
-        /// <param name="maxRows">Max rows to show.</param>
-        /// <param name="maxColumns">Max columns to show.</param>
-        public static string ToString<T>(this ReadOnlyTensorSpan<T> span, int maxRows, int maxColumns)
+        /// <param name="maximumLengths">Maximum Length of each dimension</param>
+        public static string ToString<T>(this ReadOnlyTensorSpan<T> span, params ReadOnlySpan<nint> maximumLengths)
         {
             var sb = new StringBuilder();
             scoped Span<nint> curIndexes;
@@ -557,7 +555,7 @@ public static Tensor<bool> SequenceEqual<T>(Tensor<T> left, Tensor<T> right)
             Tensor<bool> result;
             if (TensorHelpers.AreShapesTheSame(left, right))
             {
-                result = Tensor.Create<bool>(false, left.Lengths);
+                result = Tensor.Create<bool>(left.Lengths, false);
 
                 for (int i = 0; i < left.FlattenedLength; i++)
                 {
@@ -567,7 +565,7 @@ public static Tensor<bool> SequenceEqual<T>(Tensor<T> left, Tensor<T> right)
             else
             {
                 nint[] newSize = TensorHelpers.GetSmallestBroadcastableSize(left.Lengths, right.Lengths);
-                result = Tensor.Create<bool>(false, newSize);
+                result = Tensor.Create<bool>(newSize, false);
                 Tensor<T> broadcastedLeft = BroadcastTo(left, newSize);
                 Tensor<T> broadcastedRight = BroadcastTo(right, newSize);
 
@@ -616,7 +614,7 @@ public static Tensor<bool> LessThan<T>(Tensor<T> left, Tensor<T> right)
             Tensor<bool> result;
             if (TensorHelpers.AreShapesTheSame(left, right))
             {
-                result = Tensor.Create<bool>(false, left.Lengths);
+                result = Tensor.Create<bool>(left.Lengths, false);
 
                 for (int i = 0; i < left.FlattenedLength; i++)
                 {
@@ -626,7 +624,7 @@ public static Tensor<bool> LessThan<T>(Tensor<T> left, Tensor<T> right)
             else
             {
                 nint[] newSize = TensorHelpers.GetSmallestBroadcastableSize(left.Lengths, right.Lengths);
-                result = Tensor.Create<bool>(false, newSize);
+                result = Tensor.Create<bool>(newSize, false);
                 Tensor<T> broadcastedLeft = BroadcastTo(left, newSize);
                 Tensor<T> broadcastedRight = BroadcastTo(right, newSize);
 
@@ -669,7 +667,7 @@ public static Tensor<bool> LessThan<T>(Tensor<T> left, Tensor<T> right)
         public static Tensor<bool> LessThan<T>(Tensor<T> left, T right)
             where T : IEquatable<T>, IEqualityOperators<T, T, bool>, IComparisonOperators<T, T, bool>
         {
-            Tensor<bool> result = Tensor.Create<bool>(false, left.Lengths);
+            Tensor<bool> result = Tensor.Create<bool>(left.Lengths, false);
 
             for (int i = 0; i < left.FlattenedLength; i++)
             {
@@ -801,7 +799,7 @@ public static Tensor<bool> GreaterThan<T>(Tensor<T> left, Tensor<T> right)
             Tensor<bool> result;
             if (TensorHelpers.AreShapesTheSame(left, right))
             {
-                result = Tensor.Create<bool>(false, left.Lengths);
+                result = Tensor.Create<bool>(left.Lengths, false);
 
                 for (int i = 0; i < left.FlattenedLength; i++)
                 {
@@ -811,7 +809,7 @@ public static Tensor<bool> GreaterThan<T>(Tensor<T> left, Tensor<T> right)
             else
             {
                 nint[] newSize = TensorHelpers.GetSmallestBroadcastableSize(left.Lengths, right.Lengths);
-                result = Tensor.Create<bool>(false, newSize);
+                result = Tensor.Create<bool>(newSize, false);
                 Tensor<T> broadcastedLeft = BroadcastTo(left, newSize);
                 Tensor<T> broadcastedRight = BroadcastTo(right, newSize);
 
@@ -854,7 +852,7 @@ public static Tensor<bool> GreaterThan<T>(Tensor<T> left, Tensor<T> right)
         public static Tensor<bool> GreaterThan<T>(Tensor<T> left, T right)
             where T : IEquatable<T>, IEqualityOperators<T, T, bool>, IComparisonOperators<T, T, bool>
         {
-            Tensor<bool> result = Tensor.Create<bool>(false, left.Lengths);
+            Tensor<bool> result = Tensor.Create<bool>(left.Lengths, false);
 
             for (int i = 0; i < left.FlattenedLength; i++)
             {
@@ -1422,7 +1420,7 @@ public static Tensor<T> Multiply<T>(Tensor<T> input, T val)
             where T : IEquatable<T>, IEqualityOperators<T, T, bool>, IMultiplyOperators<T, T, T>, IMultiplicativeIdentity<T, T>
         {
             ReadOnlySpan<T> span = MemoryMarshal.CreateSpan(ref input._values[0], (int)input._flattenedLength);
-            Tensor<T> output = Create<T>(input.IsPinned, input.Lengths);
+            Tensor<T> output = Create<T>(input.Lengths, input.IsPinned);
             Span<T> ospan = MemoryMarshal.CreateSpan(ref output._values[0], (int)output._flattenedLength);
             TensorPrimitives.Multiply(span, val, ospan);
             return output;
@@ -1533,7 +1531,7 @@ public static Tensor<T> Divide<T>(Tensor<T> input, T val)
             where T : IEquatable<T>, IEqualityOperators<T, T, bool>, IDivisionOperators<T, T, T>
         {
             ReadOnlySpan<T> span = MemoryMarshal.CreateSpan(ref input._values[0], (int)input._flattenedLength);
-            Tensor<T> output = Create<T>(input.IsPinned, input.Lengths);
+            Tensor<T> output = Create<T>(input.Lengths, input.IsPinned);
             Span<T> ospan = MemoryMarshal.CreateSpan(ref output._values[0], (int)output._flattenedLength);
             TensorPrimitives.Divide(span, val, ospan);
             return output;
@@ -1563,7 +1561,7 @@ public static Tensor<T> Divide<T>(T val, Tensor<T> input)
             where T : IEquatable<T>, IEqualityOperators<T, T, bool>, IDivisionOperators<T, T, T>
         {
             ReadOnlySpan<T> span = MemoryMarshal.CreateSpan(ref input._values[0], (int)input._flattenedLength);
-            Tensor<T> output = Create<T>(input.IsPinned, input.Lengths);
+            Tensor<T> output = Create<T>(input.Lengths, input.IsPinned);
             Span<T> ospan = MemoryMarshal.CreateSpan(ref output._values[0], (int)output._flattenedLength);
             TensorPrimitives.Divide(val, span, ospan);
             return output;
@@ -1704,7 +1702,7 @@ public static Tensor<T> Subtract<T>(Tensor<T> input, T val)
             where T : IEquatable<T>, IEqualityOperators<T, T, bool>, ISubtractionOperators<T, T, T>
         {
             ReadOnlySpan<T> span = MemoryMarshal.CreateSpan(ref input._values[0], (int)input._flattenedLength);
-            Tensor<T> output = Create<T>(input.IsPinned, input.Lengths);
+            Tensor<T> output = Create<T>(input.Lengths, input.IsPinned);
             Span<T> ospan = MemoryMarshal.CreateSpan(ref output._values[0], (int)output._flattenedLength);
             TensorPrimitives.Subtract(span, val, ospan);
             return output;
@@ -1734,7 +1732,7 @@ public static Tensor<T> Subtract<T>(T val, Tensor<T> input)
             where T : IEquatable<T>, IEqualityOperators<T, T, bool>, ISubtractionOperators<T, T, T>
         {
             ReadOnlySpan<T> span = MemoryMarshal.CreateSpan(ref input._values[0], (int)input._flattenedLength);
-            Tensor<T> output = Create<T>(input.IsPinned, input.Lengths);
+            Tensor<T> output = Create<T>(input.Lengths, input.IsPinned);
             Span<T> ospan = MemoryMarshal.CreateSpan(ref output._values[0], (int)output._flattenedLength);
             TensorPrimitives.Subtract(val, span, ospan);
             return output;
@@ -1921,7 +1919,7 @@ public static Tensor<T> Add<T>(Tensor<T> input, T val)
             where T : IEquatable<T>, IEqualityOperators<T, T, bool>, IAdditionOperators<T, T, T>, IAdditiveIdentity<T, T>
         {
             ReadOnlySpan<T> span = MemoryMarshal.CreateSpan(ref input._values[0], (int)input._flattenedLength);
-            Tensor<T> output = Create<T>(input.IsPinned, input.Lengths);
+            Tensor<T> output = Create<T>(input.Lengths, input.IsPinned);
             Span<T> ospan = MemoryMarshal.CreateSpan(ref output._values[0], (int)output._flattenedLength);
             TensorPrimitives.Add(span, val, ospan);
             return output;
@@ -2290,7 +2288,7 @@ private static Tensor<T> TensorPrimitivesHelperT1<T>(Tensor<T> input, PerformCal
             where T : IEquatable<T>, IEqualityOperators<T, T, bool>
         {
             ReadOnlySpan<T> span = MemoryMarshal.CreateSpan(ref input._values[0], (int)input._flattenedLength);
-            Tensor<T> output = inPlace ? input : Create<T>(input.IsPinned, input.Lengths);
+            Tensor<T> output = inPlace ? input : Create<T>(input.Lengths, input.IsPinned);
             Span<T> ospan = MemoryMarshal.CreateSpan(ref output._values[0], (int)output._flattenedLength);
             performCalculation(span, ospan);
             return output;
@@ -2327,7 +2325,7 @@ private static Tensor<T> TensorPrimitivesHelperT1T2<T>(Tensor<T> left, Tensor<T>
             {
                 ReadOnlySpan<T> span = MemoryMarshal.CreateSpan(ref left.AsTensorSpan()._reference, (int)left.FlattenedLength);
                 ReadOnlySpan<T> rspan = MemoryMarshal.CreateSpan(ref right.AsTensorSpan()._reference, (int)right.FlattenedLength);
-                output = Create<T>(left.IsPinned, left.Lengths);
+                output = Create<T>(left.Lengths, left.IsPinned);
                 Span<T> ospan = MemoryMarshal.CreateSpan(ref output.AsTensorSpan()._reference, (int)output.FlattenedLength);
                 performCalculation(span, rspan, ospan);
                 return output;
@@ -2344,7 +2342,7 @@ private static Tensor<T> TensorPrimitivesHelperT1T2<T>(Tensor<T> left, Tensor<T>
                 var broadcastedLeft = Tensor.BroadcastTo(left, newSize);
                 var broadcastedRight = Tensor.BroadcastTo(right, newSize);
 
-                output = Create<T>(left.IsPinned, newSize);
+                output = Create<T>(newSize, left.IsPinned);
                 nint rowLength = newSize[^1];
                 Span<T> ospan;
                 Span<T> ispan;
diff --git a/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/TensorSpan.cs b/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/TensorSpan.cs
index bf79dd34bcf0aa..20da07b537ee1c 100644
--- a/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/TensorSpan.cs
+++ b/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/TensorSpan.cs
@@ -59,7 +59,7 @@ public TensorSpan(T[]? array) : this(array, 0, default, default)
         /// <remarks>Returns default when <paramref name="array"/> is null.</remarks>
         /// <exception cref="ArrayTypeMismatchException">Thrown when <paramref name="array"/> is covariant and array's type is not exactly T[].</exception>
         /// <exception cref="ArgumentOutOfRangeException">
-        /// Thrown when the specified <paramref name="startIndex"/> or end index is not in the range (&lt;0 or &gt;Length).
+        /// Thrown when the specified <paramref name="startIndex"/> or end index is not in the range (&lt;0 or &gt;FlattenedLength).
         /// </exception>
         public TensorSpan(T[]? array, Index startIndex, scoped ReadOnlySpan<nint> lengths, scoped ReadOnlySpan<nint> strides)
             : this(array, startIndex.GetOffset(array?.Length ?? 0), lengths, strides)
@@ -77,7 +77,7 @@ public TensorSpan(T[]? array, Index startIndex, scoped ReadOnlySpan<nint> length
         /// <remarks>Returns default when <paramref name="array"/> is null.</remarks>
         /// <exception cref="ArrayTypeMismatchException">Thrown when <paramref name="array"/> is covariant and array's type is not exactly T[].</exception>
         /// <exception cref="ArgumentOutOfRangeException">
-        /// Thrown when the specified <paramref name="start"/> or end index is not in the range (&lt;0 or &gt;Length).
+        /// Thrown when the specified <paramref name="start"/> or end index is not in the range (&lt;0 or &gt;FlattenedLength).
         /// </exception>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public TensorSpan(T[]? array, int start, scoped ReadOnlySpan<nint> lengths, scoped ReadOnlySpan<nint> strides)
@@ -208,7 +208,7 @@ internal TensorSpan(ref T reference, scoped ReadOnlySpan<nint> lengths, scoped R
         /// <param name="indexes"></param>
         /// <returns></returns>
         /// <exception cref="IndexOutOfRangeException">
-        /// Thrown when any index is less than 0 or any index is greater than or equal to Length
+        /// Thrown when any index is less than 0 or any index is greater than or equal to FlattenedLength
         /// </exception>
         public ref T this[params scoped ReadOnlySpan<nint> indexes]
         {
@@ -232,7 +232,7 @@ public ref T this[params scoped ReadOnlySpan<nint> indexes]
         /// <param name="indexes"></param>
         /// <returns></returns>
         /// <exception cref="IndexOutOfRangeException">
-        /// Thrown when any index is less than 0 or any index is greater than or equal to Length
+        /// Thrown when any index is less than 0 or any index is greater than or equal to FlattenedLength
         /// </exception>
         public ref T this[params scoped ReadOnlySpan<NIndex> indexes]
         {
@@ -257,7 +257,7 @@ public ref T this[params scoped ReadOnlySpan<NIndex> indexes]
         /// <param name="ranges"></param>
         /// <returns></returns>
         /// <exception cref="IndexOutOfRangeException">
-        /// Thrown when any index is less than 0 or any index is greater than or equal to Length
+        /// Thrown when any index is less than 0 or any index is greater than or equal to FlattenedLength
         /// </exception>
         public TensorSpan<T> this[params scoped ReadOnlySpan<NRange> ranges]
         {
@@ -441,7 +441,7 @@ public void Fill(T value)
         {
             Span<nint> curIndexes = stackalloc nint[Rank];
             nint filledValues = 0;
-            // REVIEW: If we track the actual length of the backing data, because Length doesn't always equal the actual length, we could use that here to not need to loop.
+            // REVIEW: If we track the actual length of the backing data, because FlattenedLength doesn't always equal the actual length, we could use that here to not need to loop.
             while (filledValues < _flattenedLength)
             {
                 TensorSpanHelpers.Fill(ref Unsafe.Add(ref _reference, TensorSpanHelpers.ComputeLinearIndex(curIndexes, Strides, Lengths)), (nuint)Lengths[Rank - 1], value);
@@ -564,7 +564,7 @@ public static implicit operator ReadOnlyTensorSpan<T>(TensorSpan<T> span) =>
         /// <param name="indexes">The indexes for the slice.</param>
         /// <returns></returns>
         /// <exception cref="IndexOutOfRangeException">
-        /// Thrown when any index is less than 0 or any index is greater than or equal to Length
+        /// Thrown when any index is less than 0 or any index is greater than or equal to FlattenedLength
         /// </exception>
         public TensorSpan<T> Slice(params scoped ReadOnlySpan<NIndex> indexes)
         {
diff --git a/src/libraries/System.Numerics.Tensors/tests/NRangeTests.cs b/src/libraries/System.Numerics.Tensors/tests/NRangeTests.cs
index 0dd4156c7c4194..eb5d7ba88ae45e 100644
--- a/src/libraries/System.Numerics.Tensors/tests/NRangeTests.cs
+++ b/src/libraries/System.Numerics.Tensors/tests/NRangeTests.cs
@@ -128,7 +128,7 @@ public static void CustomTypeTest()
             }
         }
 
-        // CustomNativeRangeTester is a custom class which containing the members Length, Slice and int NativeIndexer.
+        // CustomNativeRangeTester is a custom class which containing the members FlattenedLength, Slice and int NativeIndexer.
         // Having these members allow the C# compiler to support
         //      this[NIndex]
         //      this[NRange]
diff --git a/src/libraries/System.Numerics.Tensors/tests/TensorTests.cs b/src/libraries/System.Numerics.Tensors/tests/TensorTests.cs
index 54486908f13d66..a8eae72369ecfb 100644
--- a/src/libraries/System.Numerics.Tensors/tests/TensorTests.cs
+++ b/src/libraries/System.Numerics.Tensors/tests/TensorTests.cs
@@ -825,7 +825,7 @@ public static void IntArrayAsTensor()
             int[] a = [91, 92, -93, 94];
             TensorSpan<int> spanInt = a.AsTensorSpan(4);
             nint[] dims = [4];
-            var tensor = Tensor.CreateUninitialized<int>(false, dims.AsSpan());
+            var tensor = Tensor.CreateUninitialized<int>(dims.AsSpan(), false);
             spanInt.CopyTo(tensor);
             Assert.Equal(1, tensor.Rank);
 
@@ -854,11 +854,11 @@ public static void IntArrayAsTensor()
             a[3] = 94;
             spanInt = a.AsTensorSpan(2, 2);
             dims = [2, 2];
-            tensor = Tensor.CreateUninitialized<int>(false, dims.AsSpan());
+            tensor = Tensor.CreateUninitialized<int>(dims.AsSpan(), false);
             spanInt.CopyTo(tensor);
             Assert.Equal(a, tensor.ToArray());
             Assert.Equal(2, tensor.Rank);
-            //Assert.Equal(4, spanInt.Length);
+            //Assert.Equal(4, spanInt.FlattenedLength);
             Assert.Equal(2, tensor.Lengths.Length);
             Assert.Equal(2, tensor.Lengths[0]);
             Assert.Equal(2, tensor.Lengths[1]);
@@ -885,7 +885,7 @@ public static void IntArrayAsTensor()
         public static void TensorFillTest()
         {
             nint[] dims = [3, 3];
-            var tensor = Tensor.CreateUninitialized<int>(false, dims.AsSpan());
+            var tensor = Tensor.CreateUninitialized<int>(dims.AsSpan(), false);
             tensor.Fill(-1);
             var enumerator = tensor.GetEnumerator();
             while (enumerator.MoveNext())
@@ -908,7 +908,7 @@ public static void TensorFillTest()
             }
 
             dims = [9];
-            tensor = Tensor.CreateUninitialized<int>(false, dims.AsSpan());
+            tensor = Tensor.CreateUninitialized<int>(dims.AsSpan(), false);
             tensor.Fill(-1);
             enumerator = tensor.GetEnumerator();
             while (enumerator.MoveNext())
@@ -917,7 +917,7 @@ public static void TensorFillTest()
             }
 
             dims = [3, 3, 3];
-            tensor = Tensor.CreateUninitialized<int>(false, dims.AsSpan());
+            tensor = Tensor.CreateUninitialized<int>(dims.AsSpan(), false);
             tensor.Fill(-1);
             enumerator = tensor.GetEnumerator();
             while (enumerator.MoveNext())
@@ -926,7 +926,7 @@ public static void TensorFillTest()
             }
 
             dims = [3, 2, 2];
-            tensor = Tensor.CreateUninitialized<int>(false, dims.AsSpan());
+            tensor = Tensor.CreateUninitialized<int>(dims.AsSpan(), false);
             tensor.Fill(-1);
             enumerator = tensor.GetEnumerator();
             while (enumerator.MoveNext())
@@ -935,7 +935,7 @@ public static void TensorFillTest()
             }
 
             dims = [2, 2, 2, 2];
-            tensor = Tensor.CreateUninitialized<int>(false , dims.AsSpan());
+            tensor = Tensor.CreateUninitialized<int>(dims.AsSpan(), false);
             tensor.Fill(-1);
             enumerator = tensor.GetEnumerator();
             while (enumerator.MoveNext())
@@ -944,7 +944,7 @@ public static void TensorFillTest()
             }
 
             dims = [3, 2, 2, 2];
-            tensor = Tensor.CreateUninitialized<int>(false, dims.AsSpan());
+            tensor = Tensor.CreateUninitialized<int>(dims.AsSpan(), false);
             tensor.Fill(-1);
             enumerator = tensor.GetEnumerator();
             while (enumerator.MoveNext())
@@ -958,7 +958,7 @@ public static void TensorClearTest()
         {
             int[] a = [1, 2, 3, 4, 5, 6, 7, 8, 9];
             TensorSpan<int> spanInt = a.AsTensorSpan(3, 3);
-            var tensor = Tensor.CreateUninitialized<int>(false, [3, 3]);
+            var tensor = Tensor.CreateUninitialized<int>([3, 3], false);
             spanInt.CopyTo(tensor);
             var slice = tensor.Slice(0..2, 0..2);
             slice.Clear();
@@ -988,7 +988,7 @@ public static void TensorClearTest()
 
             a = [1, 2, 3, 4, 5, 6, 7, 8, 9];
             spanInt = a.AsTensorSpan(9);
-            tensor = Tensor.CreateUninitialized<int>(false, [9]);
+            tensor = Tensor.CreateUninitialized<int>([9], false);
             spanInt.CopyTo(tensor);
             slice = tensor.Slice(0..1);
             slice.Clear();
@@ -1015,7 +1015,7 @@ public static void TensorClearTest()
 
             a = [.. Enumerable.Range(0, 27)];
             spanInt = a.AsTensorSpan(3, 3, 3);
-            tensor = Tensor.CreateUninitialized<int>(false, [3, 3, 3]);
+            tensor = Tensor.CreateUninitialized<int>([3, 3, 3], false);
             spanInt.CopyTo(tensor);
             tensor.Clear();
             enumerator = tensor.GetEnumerator();
@@ -1026,7 +1026,7 @@ public static void TensorClearTest()
 
             a = [.. Enumerable.Range(0, 12)];
             spanInt = a.AsTensorSpan(3, 2, 2);
-            tensor = Tensor.CreateUninitialized<int>(false, [3, 2, 2]);
+            tensor = Tensor.CreateUninitialized<int>([3, 2, 2], false);
             spanInt.CopyTo(tensor);
             tensor.Clear();
             enumerator = tensor.GetEnumerator();
@@ -1037,7 +1037,7 @@ public static void TensorClearTest()
 
             a = [.. Enumerable.Range(0, 16)];
             spanInt = a.AsTensorSpan(2, 2, 2, 2);
-            tensor = Tensor.CreateUninitialized<int>(false, [2, 2, 2, 2]);
+            tensor = Tensor.CreateUninitialized<int>([2, 2, 2, 2], false);
             spanInt.CopyTo(tensor);
             tensor.Clear();
             enumerator = tensor.GetEnumerator();
@@ -1048,7 +1048,7 @@ public static void TensorClearTest()
 
             a = [.. Enumerable.Range(0, 24)];
             spanInt = a.AsTensorSpan(3, 2, 2, 2);
-            tensor = Tensor.CreateUninitialized<int>(false, [3, 2, 2, 2]);
+            tensor = Tensor.CreateUninitialized<int>([3, 2, 2, 2], false);
             spanInt.CopyTo(tensor);
             tensor.Clear();
             enumerator = tensor.GetEnumerator();
@@ -1202,7 +1202,7 @@ public static void TensorCopyTest()
             int[] rightData = new int[9];
             nint[] dims = [3, 3];
             TensorSpan<int> leftSpan = leftData.AsTensorSpan(3, 3);
-            var tensor = Tensor.CreateUninitialized<int>(false, dims.AsSpan());
+            var tensor = Tensor.CreateUninitialized<int>(dims.AsSpan(), false);
             TensorSpan<int> rightSpan = rightData.AsTensorSpan(3, 3);
             leftSpan.CopyTo(tensor);
             var leftEnum = leftSpan.GetEnumerator();
@@ -1227,7 +1227,7 @@ public static void TensorCopyTest()
             leftData = [1, 2, 3, 4, 5, 6, 7, 8, 9];
             dims = [15];
             leftSpan = leftData.AsTensorSpan(9);
-            tensor = Tensor.Create<int>(false, dims.AsSpan());
+            tensor = Tensor.Create<int>(dims.AsSpan(), false);
             leftSpan.CopyTo(tensor);
             leftEnum = leftSpan.GetEnumerator();
             tensorEnum = tensor.GetEnumerator();
@@ -1257,7 +1257,7 @@ public static void TensorTryCopyTest()
             int[] rightData = new int[9];
             TensorSpan<int> leftSpan = leftData.AsTensorSpan(3, 3);
             nint[] dims = [3, 3];
-            var tensor = Tensor.CreateUninitialized<int>(false, dims.AsSpan());
+            var tensor = Tensor.CreateUninitialized<int>(dims.AsSpan(), false);
             TensorSpan<int> rightSpan = rightData.AsTensorSpan(3, 3);
             var success = leftSpan.TryCopyTo(tensor);
             Assert.True(success);
@@ -1279,7 +1279,7 @@ public static void TensorTryCopyTest()
             leftData = [1, 2, 3, 4, 5, 6, 7, 8, 9];
             dims = [15];
             leftSpan = leftData.AsTensorSpan(9);
-            tensor = Tensor.Create<int>(false, dims.AsSpan());
+            tensor = Tensor.Create<int>(dims.AsSpan(), false);
             success = leftSpan.TryCopyTo(tensor);
             leftEnum = leftSpan.GetEnumerator();
             tensorEnum = tensor.GetEnumerator();
@@ -1298,7 +1298,7 @@ public static void TensorTryCopyTest()
             leftData = [.. Enumerable.Range(0, 27)];
             var l = leftData.AsTensorSpan(3, 3, 3);
             dims = [2, 2];
-            tensor = Tensor.Create<int>(false, dims.AsSpan());
+            tensor = Tensor.Create<int>(dims.AsSpan(), false);
             var r = new TensorSpan<int>();
             success = l.TryCopyTo(tensor);
             Assert.False(success);
@@ -1310,7 +1310,7 @@ public static void TensorTryCopyTest()
         public static void TensorSliceTest()
         {
             int[] a = [1, 2, 3, 4, 5, 6, 7, 8, 9];
-            var tensor = Tensor.CreateUninitialized<int>(false, [3, 3]);
+            var tensor = Tensor.CreateUninitialized<int>([3, 3], false);
 
             //Assert.Throws<ArgumentOutOfRangeException>(() => tensor.Slice(0..1));
             //Assert.Throws<ArgumentOutOfRangeException>(() => tensor.Slice(1..2));
@@ -1378,7 +1378,7 @@ public static void TensorSliceTest()
 
             int[] numbers = [.. Enumerable.Range(0, 27)];
             intSpan = numbers.AsTensorSpan(3, 3, 3);
-            tensor = Tensor.CreateUninitialized<int>(false, [3, 3, 3]);
+            tensor = Tensor.CreateUninitialized<int>([3, 3, 3], false);
             intSpan.CopyTo(tensor.AsTensorSpan());
             sp = tensor.Slice(1..2, 1..2, 1..2);
             Assert.Equal(13, sp[0, 0, 0]);
@@ -1411,7 +1411,7 @@ public static void TensorSliceTest()
 
             numbers = [.. Enumerable.Range(0, 16)];
             intSpan = numbers.AsTensorSpan(2, 2, 2, 2);
-            tensor = Tensor.CreateUninitialized<int>(false, [2, 2, 2, 2]);
+            tensor = Tensor.CreateUninitialized<int>([2, 2, 2, 2], false);
             intSpan.CopyTo(tensor.AsTensorSpan());
             sp = tensor.Slice(1..2, 0..2, 1..2, 0..2);
             Assert.Equal(10, sp[0, 0, 0, 0]);
@@ -1433,7 +1433,7 @@ public static void TensorReshapeTest()
         {
             int[] a = [1, 2, 3, 4, 5, 6, 7, 8, 9];
             nint[] dims = [9];
-            var tensor = Tensor.CreateUninitialized<int>(false, dims.AsSpan());
+            var tensor = Tensor.CreateUninitialized<int>(dims.AsSpan(), false);
             var span = a.AsTensorSpan(dims);
             span.CopyTo(tensor);
 
@@ -1476,7 +1476,7 @@ public static void TensorReshapeTest()
         public static void TensorSqueezeTest()
         {
             nint[] dims = [1, 2];
-            var tensor = Tensor.Create<int>(false, dims.AsSpan());
+            var tensor = Tensor.Create<int>(dims.AsSpan(), false);
             Assert.Equal(2, tensor.Rank);
             Assert.Equal(1, tensor.Lengths[0]);
             Assert.Equal(2, tensor.Lengths[1]);
@@ -1486,7 +1486,7 @@ public static void TensorSqueezeTest()
             Assert.Equal(2, tensor.Lengths[0]);
 
             dims = [1, 2, 1];
-            tensor = Tensor.Create<int>(false, dims.AsSpan());
+            tensor = Tensor.Create<int>(dims.AsSpan(), false);
             Assert.Equal(3, tensor.Rank);
             Assert.Equal(1, tensor.Lengths[0]);
             Assert.Equal(2, tensor.Lengths[1]);
@@ -1497,7 +1497,7 @@ public static void TensorSqueezeTest()
             Assert.Equal(2, tensor.Lengths[0]);
 
             dims = [1, 2, 1];
-            tensor = Tensor.Create<int>(false, dims.AsSpan());
+            tensor = Tensor.Create<int>(dims.AsSpan(), false);
             Assert.Equal(3, tensor.Rank);
             Assert.Equal(1, tensor.Lengths[0]);
             Assert.Equal(2, tensor.Lengths[1]);
@@ -1509,7 +1509,7 @@ public static void TensorSqueezeTest()
             Assert.Equal(1, tensor.Lengths[1]);
 
             dims = [1, 2, 1];
-            tensor = Tensor.Create<int>(false, dims.AsSpan());
+            tensor = Tensor.Create<int>(dims.AsSpan(), false);
             Assert.Equal(3, tensor.Rank);
             Assert.Equal(1, tensor.Lengths[0]);
             Assert.Equal(2, tensor.Lengths[1]);
@@ -1521,7 +1521,7 @@ public static void TensorSqueezeTest()
             Assert.Equal(2, tensor.Lengths[1]);
 
             dims = [1, 2, 1];
-            tensor = Tensor.Create<int>(false, dims.AsSpan());
+            tensor = Tensor.Create<int>(dims.AsSpan(), false);
             Assert.Equal(3, tensor.Rank);
             Assert.Equal(1, tensor.Lengths[0]);
             Assert.Equal(2, tensor.Lengths[1]);
@@ -1534,7 +1534,7 @@ public static void TensorSqueezeTest()
         [Fact]
         public static void TensorUnsqueezeTest()
         {
-            var tensor = Tensor.Create<int>(false, [2]);
+            var tensor = Tensor.Create<int>([2], false);
             Assert.Equal(1, tensor.Rank);
             Assert.Equal(2, tensor.Lengths[0]);
 
@@ -1543,7 +1543,7 @@ public static void TensorUnsqueezeTest()
             Assert.Equal(1, tensor.Lengths[0]);
             Assert.Equal(2, tensor.Lengths[1]);
 
-            tensor = Tensor.Create<int>(false, [2]);
+            tensor = Tensor.Create<int>([2], false);
             Assert.Equal(1, tensor.Rank);
             Assert.Equal(2, tensor.Lengths[0]);
 
@@ -1552,7 +1552,7 @@ public static void TensorUnsqueezeTest()
             Assert.Equal(2, tensor.Lengths[0]);
             Assert.Equal(1, tensor.Lengths[1]);
 
-            tensor = Tensor.Create<int>(false, [2]);
+            tensor = Tensor.Create<int>([2], false);
             Assert.Equal(1, tensor.Rank);
             Assert.Equal(2, tensor.Lengths[0]);