private final Identity identity;
        private final OriginMetadata originMetadata;

        public DefaultExecuteDeferredWorkProgressDetails(
            @Nullable String workType,
            Identity identity,
            OriginMetadata originMetadata
        ) {
            this.workType = workType;
            this.identity = identity;
            this.originMetadata = originMetadata;

    // Scalar identity is broadcastable to any operand shape, we only need to
    // check that operand has the same shape as a result.
    bool scalar_identity = identity_ty.hasRank() && identity_ty.getRank() == 0;
    if (scalar_identity) return operand_ty == result_ty;

    // If identity is not a scalar, we must verify that identity shape is

        }
    }

    private static void validateIdentity(@Nullable String identity) {
        if (identity == null || identity.isEmpty() || !identity.chars().allMatch(Character::isLetterOrDigit)) {
            throw new IllegalArgumentException("Identity may contain only letters and digits, received: " + identity);
        }
    }

        final Class<? extends DefaultTask> implType;
        if (identity.type == Task.class) {
            implType = DefaultTask.class;
        } else if (DefaultTask.class.isAssignableFrom(identity.type)) {
            implType = identity.type.asSubclass(DefaultTask.class);
        } else if (identity.type == org.gradle.api.internal.AbstractTask.class || identity.type == TaskInternal.class) {

// CHECK-LABEL: func @identity_at_head_expanded
func.func @identity_at_head_expanded(%arg0: tensor<?xi32>) {
  // CHECK: "tf_device.cluster"
  // CHECK-NEXT: "tf.Identity"
  // CHECK-SAME: _xla_outside_compilation = ""
  "tf_device.cluster"() ({
    %1 = "tf.Identity"(%arg0) : (tensor<?xi32>) -> (tensor<?xi32>)
    "tf.B"(%1) {_xla_outside_compilation = "cluster1"} : (tensor<?xi32>) -> ()
    "tf.C"() : () -> ()
    tf_device.return

    private final PlannedTransformStepIdentity identity;
    private final List<? extends NodeIdentity> dependencies;

    public DefaultPlannedTransformStep(
        PlannedTransformStepIdentity identity,
        List<? extends NodeIdentity> dependencies
    ) {
        this.identity = identity;
        this.dependencies = dependencies;
    }

    @Override

      %2 = "tf.Identity"(%arg0) : (tensor<f32>) -> tensor<f32> loc("identity@some_function")
      "tf_executor.yield"(%2) : (tensor<f32>) -> () loc("identity@some_function")
    }) : () -> (tensor<f32>, !tf_executor.control) loc("identity@some_function")
    "tf_executor.fetch"(%1#0) : (tensor<f32>) -> () loc(unknown)
  }) : () -> tensor<f32> loc(unknown)
  "func.return"(%0) : (tensor<f32>) -> () loc(unknown)
} loc(unknown)

    return %1 : tensor<*xbf16>
  }

// CHECK-LABEL: func @propagate_xladotv2_bf16
// CHECK: %[[IDENTITY:.*]] = "tf.Identity"(%cst) : (tensor<2x1024xi8>) -> tensor<2x1024xi8>
// CHECK: %[[MATMUL:.*]] = "tf.XlaDotV2"(%arg0, %[[IDENTITY]]) <{dimension_numbers = "\12\01\00\0A\01\03", precision_config = ""}> {device = ""} : (tensor<1x2x2x2xbf16>, tensor<2x1024xi8>) -> tensor<1x2x2x1024xbf16>

    private final ImmutableSortedMap<String, CurrentFileCollectionFingerprint> inputFileProperties;
    private final Identity identity;

    public IdentityContext(ExecutionRequestContext parent, ImmutableSortedMap<String, ValueSnapshot> inputProperties, ImmutableSortedMap<String, CurrentFileCollectionFingerprint> inputFileProperties, Identity identity) {
        super(parent);
        this.inputProperties = inputProperties;

plugins {
    java
    `ivy-publish`
}

// tag::customize-identity[]
publishing {
    // end::customize-identity[]
    repositories {
        ivy {
            url = uri(layout.buildDirectory.dir("repo"))
        }
    }
// tag::customize-identity[]
    publications {
        create<IvyPublication>("ivy") {
            organisation = "org.gradle.sample"
            module = "project1-sample"
            revision = "1.1"