[AutoDiff] Remove '_Differentiable.zeroTangentVectorInitializer'. (#35329)

Remove `_Differentiable.zeroTangentVectorInitializer` to address the feedback on the [proposal thread](https://forums.swift.org/t/differentiable-programming-for-gradient-based-machine-learning/42147). The corresponding change has already been made in the [proposal](https://github.com/rxwei/swift-evolution/blob/autodiff/proposals/0000-differentiable-programming.md).

Removed components:
- `zeroTangentVectorInitializer` and `zeroTangentVector` in `Differentiable`, `Array`, `Optional`, `Float`, `Double`, `Float80`, and SIMD types.
- `zeroTangentVectorInitializer` synthesis logic in `Differentiable` derived conformances.

Author: rxwei

docs/DifferentiableProgramming.md

@@ -986,44 +986,6 @@ public protocol Differentiable {
     /// equivalent to exponential map, which moves `self` on the geodesic
     /// surface along the given tangent vector.
     mutating func move(along direction: TangentVector)
-    
-    /// A closure that produces a zero tangent vector and does not capture `self`.
-    ///
-    /// In some cases, the zero tangent vector of `self` is equal to
-    /// `TangentVector.zero`. In other cases, the zero tangent vector depends on
-    /// information in `self`, such as shape for an n-dimensional array type.
-    /// For differentiable programming, it is more memory-efficient to define a
-    /// custom `zeroTangentVectorInitializer` property which returns a closure
-    /// that captures and uses only the necessary information to create a zero
-    /// tangent vector. For example:
-    ///
-    /// ```swift
-    /// struct Vector {
-    ///     var scalars: [Float]
-    ///     var count: Int { scalars.count }
-    ///     init(repeating repeatedElement: Float, count: Int) { ... }
-    /// }
-    /// 
-    /// extension Vector: Differentiable {
-    ///     typealias TangentVector = Vector
-    ///
-    ///     @noDerivative
-    ///     var zeroTangentVectorInitializer: () -> TangentVector {
-    ///         let count = self.count
-    ///         return { TangentVector(repeating: 0, count: count) }
-    ///     }
-    /// }
-    /// ```
-    ///
-    @noDerivative
-    var zeroTangentVectorInitializer: () -> TangentVector { get }
-}
-
-extension Differentiable {
-    /// A tangent vector such that `move(along: zeroTangentVector)` will not modify
-    /// `self`.
-    @noDerivative
-    var zeroTangentVector: TangentVector { zeroTangentVectorInitializer() }
 }
 ```
 
@@ -1092,13 +1054,6 @@ public extension Differentiable where Self == TangentVector {
 }
 ```
 
-The `zeroTangentVector` property returns a tangent vector such that calling
-`move(along:)` on the vector will not modify `self`. A zero tangent vector is
-often used in the initialization of mathematical optimization, where tangent
-vectors are initially zero and modified iteratively. This property may be
-different from `TangentVector.zero` because some tangent vectors depend on
-instance properties of `self`, e.g. the `count` property in `Array`.
-
 #### `Differentiable` conformances
 
 Conforming a type to `Differentiable` tells Swift that changes in values of this
@@ -1146,13 +1101,6 @@ extension Array: Differentiable where Element: Differentiable {
             self[i].move(along: Element.TangentVector(direction.elements[i]))
         }
     }
-
-    @noDerivative
-    public var zeroTangentVectorInitializer: () -> TangentVector {
-        { [zeroInits = map(\.zeroTangentVectorInitializer)] in
-            TangentVector(zeroInits.map { $0() })
-        }
-    }
 }
 
 // struct Dictionary<Key: Hashable, Value>
@@ -1173,14 +1121,6 @@ extension Dictionary: Differentiable where Value: Differentiable {
             self[i].move(along: Value.TangentVector(direction.elements[i]))
         }
     }
-
-    @noDerivative
-    public var zeroTangentVectorInitializer: () -> TangentVector {
-        { [keys = self.keys] in
-            let pairs = zip(keys, sequence(first: .zero, next: {$0}))
-            return TangentVector(Dictionary(uniqueKeysWithValues: pairs))
-        }
-    }
 }
 
 // enum Optional<Wrapped>
@@ -1199,18 +1139,6 @@ extension Optional: Differentiable where Wrapped: Differentiable {
             self?.move(along: value)
         }
     }
-
-    @noDerivative
-    public var zeroTangentVectorInitializer: () -> TangentVector {
-        switch self {
-        case nil:
-            return { TangentVector(nil) }
-        case let x?:
-            return { [zeroTanInit = x.zeroTangentVectorInitializer] in
-                TangentVector(zeroTanInit())
-            }
-        }
-    }
 }
 ```
 
@@ -1261,13 +1189,12 @@ product manifold of the manifolds each differentiable variable's type
 represents. Differentiable variables' types are required to conform to
 `Differentiable` because the synthesized implementation needs to access each
 differentiable variable's type's `TangentVector` associated type and invoke each
-differentiable variable's implementation of `move(along:)` and
-`zeroTangentVectorInitializer`. Because the synthesized implementation needs to
-invoke `move(along:)` on each differentiable variable, the differentiable
-variables must have a `move(along:)` which satisfies the protocol requirement
-and can be invoked on the property. That is, the property must be either a
-variable (`var`) or a constant (`let`) with a non-`mutating` implementation of
-the `move(along:)` protocol requirement.
+differentiable variable's implementation of `move(along:)`. Because the
+synthesized implementation needs to invoke `move(along:)` on each differentiable
+variable, the differentiable variables must have a `move(along:)` which satisfies the
+protocol requirement and can be invoked on the property. That is, the property
+must be either a variable (`var`) or a constant (`let`) with a non-`mutating`
+implementation of the `move(along:)` protocol requirement.
 
 The synthesized `TangentVector` has the same effective access level as the
 original type declaration. Properties in the synthesized `TangentVector` have
@@ -1282,12 +1209,6 @@ example, synthesized `TangentVector`s always adopt the `AdditiveArithmetic` and
 The synthesized `move(along:)` method calls `move(along:)` for each pair of a
 differentiable variable and its corresponding property in `TangentVector`.
 
-The synthesized `zeroTangentVectorInitializer` property returns a closure that
-captures and calls each stored property's `zeroTangentVectorInitializer`
-closure. When memberwise derivation is not possible (e.g. for custom
-user-defined `TangentVector` types), `zeroTangentVectorInitializer` is
-synthesized as a `{ TangentVector.zero }` closure.
-
 ```swift
 struct Foo<T: Differentiable, U: Differentiable>: @memberwise Differentiable {
     // `x` and `y` are the "differentiable variables".
@@ -1306,13 +1227,6 @@ struct Foo<T: Differentiable, U: Differentiable>: @memberwise Differentiable {
     //         x.move(along: direction.x)
     //         y.move(along: direction.y)
     //     }
-    //
-    //     var zeroTangentVectorInitializer: () -> TangentVector {
-    //         { [xTanInit = x.zeroTangentVectorInitializer,
-    //            yTanInit = y.zeroTangentVectorInitializer] in
-    //             TangentVector(x: xTanInit(), y: yTanInit())
-    //         }
-    //     }
 }
 ```
 
@@ -1404,14 +1318,6 @@ struct Point<T: Real>: @memberwise Differentiable, @memberwise AdditiveArithmeti
     // The compiler synthesizes:
     //
     //     typealias TangentVector = Self
-    //
-    //     @noDerivative
-    //     var zeroTangentVectorInitializer: () -> TangentVector {
-    //         { [xTanInit = x.zeroTangentVectorInitializer,
-    //            yTanInit = y.zeroTangentVectorInitializer] in
-    //             TangentVector(x: xTanInit(), y: yTanInit())
-    //         }
-    //     }
 }
 ```
 

include/swift/AST/KnownIdentifiers.def

@@ -233,7 +233,6 @@ IDENTIFIER(move)
 IDENTIFIER(pullback)
 IDENTIFIER(TangentVector)
 IDENTIFIER(zero)
-IDENTIFIER(zeroTangentVectorInitializer)
 
 #undef IDENTIFIER
 #undef IDENTIFIER_