Rule rewriting used on LHS SetDelayed inside a Condition

[rocky]

Description

I am seeing rule section matching and evaluation performed on a left-hand-side pattern in a SetDelayed operation when the LHS contains a Condition.

This does not appear to be happening in WMA.

How to Reproduce and Output Given

In[1]:= dateQ[any___] := False (* fallthrough *)
In[2]:= dateQ[y_, m_, d_, Julian]/; 1 <= m <= 3 := 1 <= d <= {31, 28, 31}[[m]]]
SetDelayed::write: Tag False in False /; 1 ≤ m ≤ 3 is Protected.
Out[3]= $Failed

Expected behavior

No error

Additional context

I note that Condition has attribute HoldRest so dateQ[y_, m_, d_, Julian] is subject to rule replacement. But is it?

Should any expression with y_, m_ (or more generally any Pattern expression) get considered as a placeholder or a variable in substitutions?

This one bug prevents us from loading Calendar.m

[rocky]

@mmatera Before going too deep into code, I'd appreciate discussing what possible fixes are.

[mmatera]

Here, SetDelayed is evaluating the lhs, using the previous rule. Then, it tries to assign the RHS to False. We have to check why the LHS is evaluated in this case.

[mmatera]

Notice that if you run line 2 before line 1, it works without problems.

[rocky]

Notice that if you run line 2 before line 1, it works without problems.

Yes, I had noticed that.

But in WMA, no error is given in either order. And the standard Calendar.m program fails with that same evaluation tag message.

[rocky]

Here, SetDelayed is evaluating the lhs, using the previous rule. Then, it tries to assign the RHS to False. We have to check why the LHS is evaluated in this case.

The HOLD_REST attribute of Condition (/;) indicates dateQ[y_, m_, d_, Julian] should be evaluated. And this matches the first rule.

So what is it about that second line that tells WMA that it should not try a rewrite rule (edited:) variable value lookup on the LHS?

[mmatera]

In WMA,

In[2]:= ?? Condition                                                            

Out[2]= patt/;test is a pattern which matches only if the evaluation of test
         
        >     yields True. lhs :> rhs/;test

         
        >      represents a rule which applies only if the evaluation of test
         
        >       yields True. lhs := rhs/;test

         
        >        is a definition to be used only if test yields True. 


        Attributes[Condition]={HoldAll, Protected}

Should be HoldAll, no HoldRest

[rocky]

Thanks! I will revise #1790.

What's weird is I had a comment about not understanding why it wasn't HOLD_ALL. And I thought I had checked that, but I made a mistake.

[rocky]

Lots of assignment tests fail with this change. #1790

Having lots of tests with the same failure message like "Assignment to symbols." makes it hard to pinpoint when there is a failure.

[rocky]

I'm trying to understand the logic behind:

In[1]:= ClearAll[A,T,x];A=T;x=3; Condition[A[x_],x>2]:=x^2; {A[u], T[u], A[4], T[4]}
Out1]={T[u], T[u], 16, 16}

This is one of the many tests marked "Assignment to symbols." . Exactly what is it testing, and why does it give the results it gives?

[mmatera]

Lots of assignment tests fail with this change. #1790

Have lots of tests with the same failure message like "Assignment to symbols." make things hard to pinpoint when there is a failure.

I expected that: I remember we used HoldRest instead of HoldAll because

I'm trying to understand the logic behind:

In[1]:= ClearAll[A,T,x];A=T;x=3; Condition[A[x_],x>2]:=x^2; {A[u], T[u], A[4], T[4]}
Out1]={T[u], T[u], 16, 16}

This is one of the many tests marked "Assignment to symbols." . Exactly what is it testing, and why does it give the results it gives?

Yep, I was looking at the same test. This is the logic: First, A is set to T. Then, let's suppose that you evaluate

A[x_]:=x^2

In this case, WMA, evaluates the head and replaces the LHS to T[x_], so in the end, the assignment is to T:

In[1]:= ClearAll[A,T,x];A=T;A[x_]:=x^2

In[2]:= ?? A
Out[2]= Global`A
        
        A = T

In[3]:= ?? T
Out[3]= Global`T
        
        T[x_] = x^2

In Mathics we get the same result, because we evaluate the head of the expression. But if the LHS is wrapped in Condition,
this does not happend. So in WMA,

In[4]:= ClearAll[A,T,x];A=T;x=3; Condition[A[x_],x>2]:=x^2; {A[u], T[u], A[4], T[4]}                                                                                          

Out[4]= {T[u], T[u], 16, 16}

In[5]:= ?? A                                                                                                                                                                  

Out[5]= Global`A
        A = T
         

In[6]:= ?? T                                                                                                                                                                  

Out[6]= Global`T
        T[x_] /; x > 2 := x^2

but in Mathics,

In[4]:= ClearAll[A,T,x];A=T;x=3; Condition[A[x_],x>2]:=x^2; {A[u], T[u], A[4], T[4]}
Out[4]= {T[u], T[u], T[4], T[4]}

In[5]:= ?? A
Out[5]= Global`A
        
        A = T
        
        A[x_] /; x > 2 = x^2

In[6]:= ?? T
Out[6]= Global`T

[mmatera]

So what we are testing is this behavior. It seems that setting the HoldRest, we mimic partially what WMA does. Actually, what WMA does is to evaluate the head and the elements of the RHS, but not the whole expression. Except that the LHS is a Condition, in that case, evaluates what is inside the condition. I think we do the same, except we do not treat Condition in this special way.

Here is an example: in WMA,

In[10]:= ClearAll[A,T,z,x];A=T;x=3;z=7; Condition[A[x_,z, Sin[Pi]],x>2]:=x^2; {A[u], T[u], A[4], T[4]}                                                                        

Out[10]= {T[u], T[u], T[4], T[4]}

In[11]:= ?? T                                                                                                                                                                 

Out[11]= Global`T
         T[x_, 7, 0] /; x > 2 := x^2
          

Notice that in T, the rule includes the symbols z and the expression Sin[Pi] fully evaluated.

[mmatera]

Some extra remarks before trying to fix this:

• If T has attributes like HoldRest or HoldAll, evaluation of the elements in the inner expression is not done.
• The attributes of A are not taken into account for this.

[rocky]

Lots of assignment tests fail with this change. #1790
Have lots of tests with the same failure message like "Assignment to symbols." make things hard to pinpoint when there is a failure.

I expected that: I remember we used HoldRest instead of HoldAll because

I don't understand. You expected that using lots of tests with the same assert failure message would make it hard to pinpoint? Having all of the test "assert" with the same failure message is the same thing as having no test assertion messages at all. At a miminum putting a number like 1, 2, etc. to make these different would help.

I'm trying to understand the logic behind:
In[1]:= ClearAll[A,T,x];A=T;x=3; Condition[A[x_],x>2]:=x^2; {A[u], T[u], A[4], T[4]}
Out1]={T[u], T[u], 16, 16}
This is one of the many tests marked "Assignment to symbols." . Exactly what is it testing, and why does it give the results it gives?

Yep, I was looking at the same test. This is the logic: First, A is set to T. Then, let's suppose that you evaluate

A[x_]:=x^2

In this case, WMA, evaluates the head and replaces the LHS to T[x_], so in the end, the assignment is to T:

In[1]:= ClearAll[A,T,x];A=T;A[x_]:=x^2

In[2]:= ?? A
Out[2]= Global`A
        
        A = T

In[3]:= ?? T
Out[3]= Global`T
        
        T[x_] = x^2

In Mathics we get the same result, because we evaluate the head of the expression. But if the LHS is wrapped in Condition, this does not happend.

Gemini AI is suggesting that there is a distinction between rule rewriting and expression evaluation, which looks for values in a definitions table.

So in WMA,

In[4]:= ClearAll[A,T,x];A=T;x=3; Condition[A[x_],x>2]:=x^2; {A[u], T[u], A[4], T[4]}                                                                                          

Out[4]= {T[u], T[u], 16, 16}

In[5]:= ?? A                                                                                                                                                                  

Out[5]= Global`A
        A = T
         

In[6]:= ?? T                                                                                                                                                                  

Out[6]= Global`T
        T[x_] /; x > 2 := x^2

but in Mathics,

In[4]:= ClearAll[A,T,x];A=T;x=3; Condition[A[x_],x>2]:=x^2; {A[u], T[u], A[4], T[4]}
Out[4]= {T[u], T[u], T[4], T[4]}

In[5]:= ?? A
Out[5]= Global`A
        
        A = T
        
        A[x_] /; x > 2 = x^2

In[6]:= ?? T
Out[6]= Global`T

Does the above data support the Gemini suggestion that rule rewriting is not omitted when a function contains HOLD attributes?

[rocky]

Some extra remarks before trying to fix this:

It's not a good idea to fix before fully understanding what's wrong.

• If T has attributes like HoldRest or HoldAll, evaluation of the elements in the inner expression is not done.

"not done" is a little vague. Do you mean expression rewriting, symbol value lookup, or both?

• The attributes of A are not taken into account for this.

I am not 100% convinced that this statement is true.