The following behavior puzzles me: apparently Maple doesn’t consider a(1) as a diﬀerent name than a but is also giving an error when I try to reassign a(1) and not when I reassign a?!

> a(1):=1; a(1) := 1 > a:=12; a := 12 > a(1); 12 > a(1):=1; Error, invalid left hand side in assignment > a:=13; a := 13 > a(5); 13 > a(12):=1; Error, invalid left hand side in assignment > a(12); 13

> a(1):=1; a(1) := 1

Here you make an undeﬁned procedure a and place the value a(1) in its remember table:

> whattype(eval(a)); procedure > op(4,eval(a)); table([1 = 1]) > a:=12; a := 12

Now you assign to a the value 12:

> whattype(a); integer

... which may act as the constant function x -> 12:

> a(1); 12 > a(1):=1; Error, invalid left hand side in assignment

But, of course, a constant function doesn’t have a remember table, so you can not place a value in it.

My best advice is not to use functional forms (i.e. anything of the general form y(x)) as variables. Maple allows this, but it causes considerable confusion. a(1) IS diﬀerent from a. I will try to explain below what is happening in your example.

> a(1):=1; a(1) := 1

a is unbound and so a(1) is a valid functional form that can be used as a variable.

> a:=12; a := 12 > a(1); 12

Now a has the value 12, and Maple accepts 12 as a constant function, so that 12 applied to any argument(s) returns the value 12.

> a(1):=1; Error, invalid left hand side in assignment

But 12(1) is not a valid functional form for assignment. The above also explains the rest of your example.

If you want to deﬁne functions then use either the arrow syntax or the full procedure syntax.

[In fact, an assignment of the form `y(x) := z`

implicitly assigns a procedure to y (if
necessary) and then inserts an entry in its remember table, which can be very useful for
deﬁning "point" mappings, base cases for recursion, etc. The error above arises
because the integer 12 cannot be used as an identiﬁer and so cannot be assigned a
procedure.]

a(1) is not a valid name in Maple. But if a is unassigned or the name of a procedure, then
a(1) means a applied to 1 and you can assign to that, like `a(1):=37;`

which has the eﬀect of
putting that information in the remember table for a.

The command `a:=12;`

makes a the integer 12. Even the command `a:= x->12;`

is by Maple
simpliﬁed to the integer 12, thus also in this case making it impossible to assign to a
remember table. That in fact the command a(1); gives 12 is due to the fact that 12(1); by
Maple is simpliﬁed to 12. You could do like this:

a:=proc() 12 end proc;

This way a is not simpliﬁed to the integer 12 and so we can assign to its remember table:

a(1):=37;

To see the remember table, do this:

op(4,eval(a));

a(1) isn’t a name, it’s the value of the function "a" on the argument 1. At the start of your session, "a" was unassigned. When you entered

> a(1):= 1;

Maple actually assigned a value to "a", namely a function that returns unevaluated, but has a remember table containing the value you assigned:

> interface(verboseproc=3): eval(a); proc() option remember; 'procname(args)' end proc # (1) = 1

When you then said

> a:= 12;

you erased this deﬁnition, and gave "a" the number 12 as a value. A number can be used as a function with a constant value:

> 12(3); 12

But a number doesn’t have a remember table, so

> a(1):= 1;

is not allowed.