Is this relation an IANA standard? Per RFC 8288, parsing of link relations is case insensitive.

@param relation must not be {@literal null}.
@return boolean
519626
public static boolean isIanaRel(String relation) {

		Assert.notNull(relation, "Link relation must not be null!");

		return LINK_RELATIONS.stream() //
				.anyMatch(it -> it.value().equalsIgnoreCase(relation));
	}
1167956
protected function getConditionStringFromBelongsTo(BelongsTo $relation)
    {
        $id = $this->getAttribute( $relation->getForeignKeyName() );

        // an empty foreign key will, as a null-scope, remove the item from any list
        if (null === $id) return null;

        return '`' . $relation->getForeignKeyName() . '` = ' . (int) $id;
    }
876186
protected function relationNeedsProxy($relation, $attributes)
    {
        if (in_array($relation, $this->entityMap->getRelationshipsWithoutProxy())) {
            return false;
        }

        $localKey = $this->entityMap->getLocalKeys($relation);

        if (is_null($localKey)) {
            return true;
        }

        if (is_array($localKey)) {
            $localKey = $localKey['id'];
        }

        if (!isset($attributes[$localKey]) || is_null($attributes[$localKey])) {
            return false;
        }

        return true;
    }
676197
@Override
	public Links findLinksWithRel(LinkRelation relation, InputStream representation) {

		return relation.isSameAs(IanaLinkRelations.SELF) //
				? addSelfLink(super.findLinksWithRel(relation, representation), representation) //
				: super.findLinksWithRel(relation, representation);

	}
894762
protected function nestedRelations( $relation )
	{
		$nested = [];

		// We are basically looking for any relationships that are nested deeper than
		// the given top-level relationship. We will just check for any relations
		// that start with the given top relations and adds them to our arrays.
		foreach ( $this->eagerLoad as $name => $constraints )
		{
			if ( $this->isNested( $name, $relation ) )
			{
				$nested[substr( $name, strlen( $relation . '.' ) )] = $constraints;
			}
		}

		return $nested;
	}
1042681
public function relation($relation)
    {
        list($name, $furtherRelations) = $this->factory->splitRelationName($relation);

        if (!isset($this->relations[$name])) {
            throw new QueryException(sprintf('Unable to retrieve relation "%s" query, relation does not exists in query "%s"', $name, $this->model()->entity()));
        }

        if ($furtherRelations) {
            return $this->relations[$name]->relation($furtherRelations);
        }

        return $this->relations[$name];
    }
41698
public function hasRelation($relation)
    {
        $cypher = $this->conn->getSchemaGrammar()->compileRelationExists($relation);

        return $this->getConnection()->select($cypher, [])->count() > 0;
    }
408167
public static function make($relation)
    {
        if (static::isSupported($relation)) {
            $className = static::$relations[get_class($relation)]['className'];

            return new $className($relation);
        }
        throw new \LogicException('Unsupported relation: '.get_type_class($relation));
    }
56156
def _check_relation(self, relation):
        
        selection = [val[0] for val in self.selection]
        if relation not in selection:
            raise ValueError(
                ("The value '{value}' supplied doesn't match with the possible"
                 " values '{selection}' for the '{field_name}' field").format(
                     value=relation,
                     selection=selection,
                     field_name=self.name,
                 ))
        return relation
544623
public function isRelationIgnored(IRelation $relation) : bool
    {
        if (empty($this->ignoreRelationStack)) {
            return false;
        }

        return in_array($relation, end($this->ignoreRelationStack), true);
    }
924917
protected static String buildLink(final String linkUri, final String relation) {
        return buildLink(URI.create(linkUri), relation);
    }
673484
public static function transformSuspendToNormal($relation)
    {
        if (!($relation instanceof static) || $relation->getIsNewRecord() ||
                $relation->relationType != static::$relationMutual) {
            return false;
        }
        $new = static::buildNormalRelation($relation->initiator, $relation->recipient);
        return $new->save() && $relation->refresh();
    }
1347427
public function has($relation)
    {
        $query = $this->make();
        return $query->has($relation)->get( $this->getParameters );
    }
325575
protected function parseForCommonValues($relation)
    {
        if (!$this->hasAttribute($relation)) {
            // If no attribute exists for this relationships
            // we'll make it a simple empty array. This will
            // save us from constantly checking for the attributes
            // actual existence.
            $this->relationships[$relation] = [];

            return false;
        }

        $value = $this->getRelationshipValue($relation);

        if (is_null($value)) {
            $this->relationships[$relation] = [];

            // If the relationship's content is the null value
            // and the Entity's exist in DB, we'll interpret this
            // as the need to detach all related Entities,
            // therefore a sync operation is needed.
            $this->needSync[] = $relation;

            return false;
        }

        return $value;
    }
1091524
@JsonCreator
	private static HalLinkRelation of(String relation) {

		String[] split = relation.split(":");

		String curie = split.length == 1 ? null : split[0];
		String localPart = split.length == 1 ? split[0] : split[1];

		return new HalLinkRelation(curie, localPart);
	}
235850
protected function parseHeader($relation, $default = false)
    {
        if (false !== $this->header)
        {
            $attributes = explode('.', $this->header);

            foreach ($attributes as $attribute)
            {
                if (isset($relation->{$attribute}))
                {
                    $relation = $relation->{$attribute};
                }
            }
        }

        if (!is_string($relation))
        {
            if ($default !== false)
            {
                return $default;
            }

            return $relation->primaryKey;
        }

        return $relation;
    }
1206488
protected function isNotEagerLoaded($relation)
    {
        return ! $relation
            || ! array_key_exists($relation, $this->query->getEagerLoads())
            || $relation === $this->query->getModel()->getTable();
    }