Why is the being described as "mutually left recursive"?

[The-Futurist]

This is the definition of reference

reference
    :   (reference '->')? basic_reference arguments_list?  
    ;

This is the diagnostic message:

Here's the entire grammar FYI:

grammar nores;

prog: statement*  
    ;

statement
    :   assign_stmt 
    |   keyword_stmt 
    ;

assign_stmt
    :   reference '=' expression NEWLINE
    ;

reference
    :   (reference '->')? basic_reference arguments_list?  
    ;

arguments
    :   '(' subscript_commalist? ')'
    ;

arguments_list
    :   arguments+
    ;

basic_reference
    :   structure_qualification_list? IDENTIFIER 
    ;

structure_qualification
    :   IDENTIFIER arguments? '.'
    ;

structure_qualification_list
    :   structure_qualification+
    ;

subscript
    :   expression 
    ;

subscript_commalist
    :   subscript (',' subscript)*
    ;

    /*
unsubscripted_reference
    :   (unsubscripted_reference '.')? IDENTIFIER
    ;
    */

keyword_stmt
    :   GOTO IDENTIFIER NEWLINE
    |   CALL IDENTIFIER NEWLINE
    ;

expression
    :   expression ('*'|'/') expression
	|   expression ('+'|'-') expression
	|   INT
	|   '(' expression ')'
	;

WS:         (' ')+ -> skip ;
NEWLINE:    [\r\n]+ ;
INT:        [0-9]+ ; 
GOTO:       'goto' ;
CALL:       'call' ;
IDENTIFIER:       [a-zA-Z]+ ;

I'm using Antlr for the first time and fully expect this to be me being dumb! Also shouldn't the diagnostic message say "the following rule" rather than "the following sets of rules" since there is only one rule being reported? In fact the entire phrasing is confusing if this is a true error pertaining to a single rule...

[kaby76]

• Antlr eliminates direct left recursion using the usual algorithm (https://en.wikipedia.org/wiki/Left_recursion#Removing_direct_left_recursion). However, if the rule does not fit the pattern, Antlr can't refactor the grammar. In this case, the RHS of the rule begins with (reference '->')?, not reference. When Antlr cannot eliminate the left recursion, it calls it a "mutual left recursion", aka "indirect left recursion". If you read https://en.wikipedia.org/wiki/Left_recursion#Indirect_left_recursion, you'll see the exact definition for an indirect left recursion.

[KvanTTT]

Just try using the following rule instead:

reference
    :   reference '->' basic_reference arguments_list?
    |   basic_reference arguments_list?
    ;