<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
 def _represent_argument(directive_location, context, argument, inferred_type):
 """Return a two-element tuple that represents the argument to the directive being processed. Args: directive_location: Location where the directive is used. context: dict, various per-compilation data (e.g. declared tags, whether the current block is optional, etc.). May be mutated in-place in this function! argument: string, the name of the argument to the directive inferred_type: GraphQL type object specifying the inferred type of the argument Returns: (argument_expression, non_existence_expression) - argument_expression: an Expression object that captures the semantics of the argument - non_existence_expression: None or Expression object; If the current block is not optional, this is set to None. Otherwise, it is an expression that will evaluate to True if the argument is skipped as optional and therefore not present, and False otherwise. """

    # Regardless of what kind of variable we are dealing with,
    # we want to ensure its name is valid.
    argument_name = argument[1:]
    validate_safe_string(argument_name)

    if is_variable_argument(argument):
        existing_type = context['inputs'].get(argument_name, inferred_type)
        if not inferred_type.is_same_type(existing_type):
            raise GraphQLCompilationError(u'Incompatible types inferred for argument {}. '
                                          u'The argument cannot simultaneously be '
                                          u'{} and {}.'.format(argument, existing_type,
                                                               inferred_type))
        context['inputs'][argument_name] = inferred_type

        return (expressions.Variable(argument, inferred_type), None)
    elif is_tag_argument(argument):
        argument_context = context['tags'].get(argument_name, None)
        if argument_context is None:
            raise GraphQLCompilationError(u'Undeclared argument used: {}'.format(argument))

        location = argument_context['location']
        optional = argument_context['optional']
        tag_inferred_type = argument_context['type']

        if location is None:
            raise AssertionError(u'Argument declared without location: {}'.format(argument_name))

        if location.field is None:
            raise AssertionError(u'Argument location is not a property field: {}'.format(location))

        if not inferred_type.is_same_type(tag_inferred_type):
            raise GraphQLCompilationError(u'The inferred type of the matching @tag directive does '
                                          u'not match the inferred required type for this filter: '
                                          u'{} vs {}'.format(tag_inferred_type, inferred_type))

        # Check whether the argument is a field on the vertex on which the directive is applied.
        field_is_local = directive_location.at_vertex() == location.at_vertex()

        non_existence_expression = None
        if optional:
            if field_is_local:
                non_existence_expression = expressions.FalseLiteral
            else:
                non_existence_expression = expressions.BinaryComposition(
                    u'=',
                    expressions.ContextFieldExistence(location.at_vertex()),
                    expressions.FalseLiteral)

        if field_is_local:
            representation = expressions.LocalField(argument_name)
        else:
            representation = expressions.ContextField(location, tag_inferred_type)

        return (representation, non_existence_expression)
    else:
        # If we want to support literal arguments, add them here.
        raise GraphQLCompilationError(u'Non-argument type found: {}'.format(argument))