Strange errors of exceeding RecursionLimit in a function with two arguments, one set delayed and one fixed

Question

INTRODUCTION

Hi. I feel a bit embarrased asking this question as the answer may be staring me in the face and there are at least two other stackexchange articles related to it.

MINIMAL WORKING EXAMPLE

In the minimal working example below I do the following:

• I define a matrix familhy a[n] where n is the dimension of the matrix;
• I define a matrix function DropM[M,r,c] which takes a matrix of size n and returns a matrix of size n-1 with row r and column c of the original matrix deleted (So it is good for studying minors in laplace expansions);
• I then define a doubly indexed family of matrices R[m,n_] where -- the first argument simply indexes the collection of matrix families and -- the second argument (set delayed) will be the size. -- R[1,n_]:=a[n] the original matrix family. -- Then R[2,n_] and R[3,n_] come from R[1,n_] and R[2,n_] by deleting "fixed" rows and columns.

PREVIOUS STACK EXCHANGE ARTICLES

I know from previous stackexchange articles that it is dangerous to define recursively with extra parameters. One article suggests making the parameters arguments and another article suggests using global variables. I can't do either here because in the actual project i is a counter controlling a loop(and varies). So I thought I would get around this by defining associations (without set delayed) so that no parameters appear in my function definition. Only the 2nd argument in R[m,n_] is set delayed. The first is fixed (So I am not sure what I am doing wrong).

THE PROBLEM

The code below runs fine. If I now print e.g. R[2,10] I get an error of "Exceeding the recursion limit". But if I print R[1,11],R[2,10] I get no such error. R[2,10] comes from R[1,11] by dropping a specified row and column. But why do I have to print it to avoid an error (perhaps the combination of set and non set "stores" the computed value). But R[1,n] = a[n] which is well defined for any n and there is no real recursion.

As an example of what is bothering me. Using R[1,11] I can then compute R[2,10] by dropping a row and column. Using R[2,10] I can then compute R[3,9] by dropping a row and column. But I dont see why I have to print (or store) these values to avoid 1000 recursions. The first argument is fixed.

The reason I need R[m,n_] is I want a collection of matrix families and I dont know beforehand how many I will need.

CONCLUDING REMARKS

Help, explanations (and encouragement) would be greatly appreciated.

MWE

a[n_] := Table[    
   If[i == j + 1 || j == i + 1, -1,      
   If[i == 1 && j == 1  || i == n && j == n, 1,     
    If[i == j && 2  <= i <=  n - 1, 2, 0]]],        
   {i, 1, n}, {j, 1, n}];  

 DropM[M1_, r1_, c1_] :=   
  Module[{M, r, c, b}, M = M1; r = r1; c = c1;  
    b = Delete[M, r]; 
   Return[Transpose[Delete[Transpose[b], c]]]];    

Clear[R, P, Q];   
ParentCount = 1    
R[ParentCount, n_] := R[ParentCount, n] = a[n];   
Print[R["Position #1", ParentCount, 4]];    

ChildCount = 2; ParentCount = 1; i = 2;
P = Association[ChildCount -> ParentCount];   
Q =  Association[ChildCount -> i];  
 
R[ChildCount, n_] :=   
  R[ChildCount, n] =   
   DropM[R[P[[Key[ChildCount]]], n + 1], 1, Q[[Key[ChildCount]]] ];  

Print["Position #2", R[ChildCount, 4]];  < 

ChildCount++; ParentCount++; i--;  <  
 AssociateTo[P, ChildCount -> ParentCount];    
AssociateTo[Q, ChildCount -> i];   

 R[ChildCount, n_] :=   
  R[ChildCount, n] =    
   DropM[R[P[[Key[ChildCount]]], n + 1], 1, Q[[Key[ChildCount]]] ];  

Print["Position #3", R[ChildCount, 3]]; 
```

Answer 1

Your style of code is very convoluted and procedural-like, which is not the common and best way to program in Mathematica.

Here are a few tips on how to write a more Mathematica-like code:

1. Generally, try to avoid capitalization of your symbols (functions etc.), because they may interfere with system symbols.
2. No need to reassign local symbols (M = M1; r = r1; c = c1 ...).
3. There is a simpler way to remove a row and a column from a matrix.
4. No need to wrap the result in Return inside your Module.
5. No need to use Key for accessing values inside Association; instead of Q[[Key[ChildCount]]], use Q[ChildCount].
6. There are more elegant ways to create specially structured matrices like yours by using SparseArray.

Here is a simpler code. I am not sure it is completely correct, because your description is not very clear; please check it yourself. Leave a comment, and I can try to fix the code according to your feedback :)

Clear["Global`*"];

a[n_] := Normal[SparseArray[{{1, 1} -> 1, {n, n} -> 1, Band[{1, 1}] -> 2, 
   Band[{2, 1}] -> -1, Band[{1, 2}] -> -1}, {n, n}]]

R[1, n_] := R[1, n] = a[n]
R[2, n_] := R[2, n] = Drop[R[1, 1 + n], {1}, {2}]
R[3, n_] := R[3, n] = Drop[R[2, 1 + n], {1}, {1}]