Hmm... Veo demasiada similitud con el otro tema. Esto me da que pensar si será tan simple o hay alguna otra forma escondida. Le he dado muchas vueltas a ver si encontraba una alternativa como ir reduciendo la matriz por recursividad, pero no es posible (o eso me ha parecido, tengo un poco olvidado el trabajo directo con memoria...) al no ser una matriz como tal contigua en memoria.

Así que aprovecharé para sacarme la espinita que se me quedó con el otro tema...
Y tranquilo, ya no me olvidaré de las matrices de orden 1

int lowerTriangleDesc(const int **A, const int N){
    int i, j = N;
    for(i = 0; i < N-1 && j == N; ++i)
        for(j = i+1; j < N && !A[i][j]; ++j);
    return j == N;
} 

PD: Sigo pensando que hay alguna solución oculta sorprendente. No dormiré tranquilo hasta ver la solución.

Esto sí que promete. 
Después de darle unas cuantas vueltas creo que está cerca pero no consigo sacarlo así que dejo mi razonamiento por si alguien se anima a seguir mientras yo duermo... (Espero no soñar con esto )

La idea es tratarlo algo así como un array unidimensional, es decir, un único índice que se incrementa desde 1 hasta n siendo n el número de casillas a recorrer. Resulta que n = (N*(N-1)/2). Iremos incrementando el contador en 1 a no ser que una casilla no sea nula en cuyo caso podemos concluir que esa matriz no es triangular inferior.
Como se puede apreciar falta definir las funciones f() y g() que determinen la fila y columna del siguiente elemento en función de i.

Parece sencillo usando los operadores de división entera y módulo pero no es tan simple. Probando con matrices de orden N >= 2 (ya que de orden 1 sería triangular sin entrar por el bucle) he encontrado lo siguiente:
Y así sucesivamente. Yo creo que se ve perfectamente el patrón. El problema como ya he dicho es sacar la que sería la fórmula cerrada de f() y g().
Si alguien se quiere animar a intentar seguir o a exponer su razonamiento...

No es más complicado hacerlo en un solo bucle, tan solo es cuestión de precisar más cálculos (tampoco muchos más), que la simpleza de dos bucles ofrece...

(nota: Estoy tomando como ejemplo el triangulo de la otra ocasión ya que es trivial modificarlo a cualquiera de las esquinas.
Igualmente la nomenclatura de: (derecha izquierda, superior, inferior) no tiene más punto que ponerse de acuerdo. Personalmente entiendo que acomoda más denominarla conforme a la esquina que ocupa al vértice del triángulo que conecta solo con ceros, y que para el ejemplo a continuación es: inferior-iizquierda).

Para entender el mecanismo subyacente hay que estudiar un poquito la matriz.
...y  atribuir algunos estados que nos permitan dar flujo al cálculo

 Matriz: 0-35 ceros saltos  index ini
 5 6 0 8 2 3 - 0  - 6          00 - estado de escape
 0 4 3 9 0 0 - 1  - 5          06
 0 0 1 5 3 4 - 2  - 4          12
 0 0 0 5 2 0 - 3  - 3          18
 0 0 0 0 7 0 - 4  - 2          24
 0 0 0 0 0 6 - 5  - 1          30 - estado inicial
 x x x x x x                   xx - estados de cambio
                         ancho + 1: estado de avance


Explicando la tabla...
- Lo obvio es que los ceros aumentan en uno con cada fila... en la columna fila se ha puesto una columna que lleva dicha cuenta. Una funcion podría simplemente contar cuando son 0 y devolcerá TRUE cuando sea el sumatorio de dicha serie. Aunque claramente es más ineficiente que devolver false tan pronto un valor no cumple la restricción.
- La columna saltos, indica cuantos hay que omitir tras recorrer los 0. Algo tangible es que 'ceros + saltos = ancho, pués por algo son los elementos en una fila.
- He añadido una última columna que señala los índices (de un array unidimensional) que suponen el primer elemento de cada fila.

En el algoritmo a continuación se empieza por el vértice que da nombre al triángulo (ver nota arriba), y recorre en diagonal (en el ejemplo) hacia abajo y a la derecha... Así he añadido algunos estados para terminar de entender...
El estado inicial es pués 30 : index = (size- ancho)
En cada ciclo aumentará: index += (ancho +1)
Cuando se alcanza un valor de index en los 'estados de cambio', justamente el enésimo valor que ocupa en esa fila (fuera de la matriz), es lo mismo que señalar la fila siguiente a la que saltar (pués es simétrico, considerando justamente como vértice del triángulo la esquina antedicha en la nota superior).
El bucle termina cuando alcanza el estado de escape, que para este triángulo será el índice 0.

...y ahora el pseudocódigo (que cualquiera puede traducir a cualquier lenguaje, ya que el problema no es un problema restrictivo a ningún lenguaje específico, es decir no es un problema de ningún lenguaje si no de algoritmia)...
* Sí, también reconoce correctamente el caso de una matriz de 1x1

Bueno, ya va siendo hora que vaya dando una respuesta a este tema... ME VA A QUEDAR UN MENSAJE LARGO, pero a lo mejor a la posteridad le sirve de ayuda.
Recordemos que las condiciones para resolverlo eran

• sin cambiar la codificacion de los parametros, esto es, entra const int **A, no const int *A
• una sola variable de control, n, (aparte de los parametros, A, N)
• Un solo bucle. No he podido, me he cansado!! (Se puede, no obstante)

Ni mucho menos es tan simple. En https://en.wikipedia.org/wiki/Pairing_function y en http://szudzik.com/ElegantPairing.pdf se describen algunos esquemas de recorrido de una matriz, proyectando dos dimensiones en uno y viceversa. No viene la tuya, pero para otras mas sencillas quedan expresiones muy complejas que trascienden el uso basico de % y /.... Un horror, vamos porque nosotros queremos no pasar de % y /.

Yo sabia que se podía, porque un resultado clásico de computabilidad dice:


La contrapartida será, por supuesto,

• la legibilidad, No tiene interes pr'actico, pero si t'eorico, pues se puede hacer lo mismo con una variable que con N, (tesis de turing-Church)
  
• la eficiencia.Los programas consumen más tiempo de ejecución, aunque sin dejar de ser tratable polinomialmente (Tesis de Cook)  

Esta  es la estretegia:


Eso quiere decir que para codificar


Damos el valor a n de.

Que por el teorema de la Aritmetica, denota univocamente unico numero o valor para n. La forma para recuperar x, (y) será el  exponente de la mayor potencia de 2, (3) que todavia haga divisible a n entre ella.


Pero recordemos que no podemos usar m'as que una variable, luego es ilegal llamar a funciones f(n) g(n), porque estas har'ian uso de pilas y variables, y eso es trampa... Da la casualidad de que esas funciones SI SE PUEDEN COMPUTAR SOLO CON % Y /.

Este es el codigo que quier implementar de partida.

int lowerTriangleDesc(const int **A, const int N)
{
  int i, j ;
  for(i = 0, j=i+1; i < N-1 && !A[i][j]; )
    if (j==N-1) { i++; j = i + 1 ;}
    else j++;
  return i==N-1;
}

Fijemonos en como se realizan las instrucciones post decremento post incremento

#define DEC(id)         n/=id 
#define INC(id)         n*=id

Esto es asi, ya que sumar 1 a la n'esima variable equivalea multiplicar el numero por el n-esimo factor primo.

M'as dificil...
Como poder evaluar i < N - 1, cuando en nuestra unica variable solo esta almacenado n=2^i*3^j ?

La estrategia sera cargar en una variable auxiliar-virtual k,n=2^i*3^j*5^k el valor de N-1-i y ver si es mayor que cero

•   el exponente k(5) tiene que ser  igual a N, lo  que solo se puede llevar a cabo al multiplicar tantas veces por 5 como unidades tenga N
• Como esto solo se puede saber decrementando N una unidad hasta que queda 0...al punto que multiplicamos por 5, multiplicamos por 7 (otra variable virtual l) para no perder la referencia de N en posteriores computos (que rollo!)
• A continuacion, restauramos N, haciendo la operacion inversa, dividiendo por 7, hasta que no se pueda mas. esto es n%7==0,  ycada vez se suma 1  a N
• Despues restamos a k (5), 1, dividiendo por 5.
• Despues restamos i(2) a k(5), con cuidado de guardar copia en l(7) de lo que vale i  (Otra vez Un rollo!!!)
• Restauramos en i(2), previamente guardado en el exponente de l(7)
• Finalmente, vemos el resultado k(5) a ver si es mayor que cero. Esto ocurre si el numero n%5==0, en otro caso, k(5) es igual a 0. Convencete con n=(2^1)*(3^3)*5(^1). Ves que el resto entre 5(k) es 0, lo que no pasa con n=(2^1)*(3^3)*5(^0), cuyo resto entre 5(k) no es 0

// Expressions
#define NON_ZERO(id)    !(n % id)
#define ZERO(id)        (n%id)

Con un poco de paciencia, se puede entender el razonamiento.

• Como es tan tedioso y proclve a errores me he creado una especie de "compilador" con las directivas de preprocesador C.
  
•  El monstruo ha quedado notablemente m'as complejo que el programa anterior, pero era lo esperado... ya que, como se puede ver, solo se usa UNA variable, n)
  

 
int debug(const char *s, int n, const int i)
{
#ifdef DEBUG  
  int c;
  for( c=0; !(n%i) ; n/=i) c++;
  printf("debug STATE %s : -> %d \n",s,c);
  return c;
#endif  
}
 
 
// N Constant
#define ASSIGN_N(id1,N,id2)  for( ;N;N--) n*=id1*id2 
#define RESTORE_N(N,id) for( ; !(n%id);n/=id) N++ 
 
// Restoring
#define RESTORE(id2,id3)    for( ; !(n%id3);n/=id3)  n*=id2 
 
// Ordinary vars.
#define DEC(id)         n/=id 
#define INC(id)         n*=id
#define SUBS(id1,id2,id3)   for( ; !(n%id2);n/=id2) { n/=id1; n*=id3 ;} 
#define RESET(id)      	for( ; !(n%id);n/=id)
#define ASSIGN(id1,id2,id3)   for( ; !(n%id2);n/=id2) n*=id1*id3 
#define NEG(id)           if (n%id) n*=id; else  for( ; !(n%id);n/=id)
 
// Expressions
#define NON_ZERO(id)    !(n % id)
#define ZERO(id)        (n%id)
 
// Indirect pointers;
#define INC_POINTER(A,id1,id2) for( ; !(n%id1); n/=id1 ) { A++; n*=id2 ; } 
#define INC_POINTER_POINTER(A,id1,id2) for( ; !(n%id1); n/=id1 ) { (*A)++; n*=id2;  }
 
#define DEC_POINTER_POINTER(A,id1,id2) for( ; !(n%id1); n/=id1 ) { (*A)--; n*=id2;  }
#define DEC_POINTER(A,id1,id2)    for( ; !(n%id1); n/=id1 ) { A--; n*=id2 ; } 
 
int lowerTriangleDesc(const int **A, int N)
{
  int n=1;
  // i,j,k : 2,3,5    l : 7
  n=3;  // i,j,k,l=0,1,0,0
  ASSIGN_N(5,N,7);
  RESTORE_N(N,7);
  DEC(5);
  SUBS(5,2,7);
  RESTORE(2,7);
  if (NON_ZERO(5))  // if (N-1-i>0), i.e i<N-1
    {
      INC_POINTER(A,2,7); // A[i]
      RESTORE(2,7) ; 
      INC_POINTER_POINTER(A,3,7); // A[i][j]
      RESTORE(3,7) ; 
      if (**A)
	RESET(5);
      DEC_POINTER_POINTER(A,3,7); // A[i][j]
      RESTORE(3,7) ;
      DEC_POINTER(A,2,7);
      RESTORE(2,7) ; 
    } // k = k && !A[i][j]
  debug("init i",n,2); debug("init j",n,3);
  debug("B: loop i < N-1 && !A[i][j]",n,5);
  for(; NON_ZERO(5); )
    {
      RESET(5);
      ASSIGN_N(5,N,7);
      RESTORE_N(N,7);
      DEC(5);
      SUBS(5,3,7); // N-1-j > 0 , j<N-1
      RESTORE(3,7);
      if (ZERO(5))
	{
	  INC(2); //i++
	  RESET(3);
	  ASSIGN(3,2,5);
	  RESTORE(2,5);
	  INC(3); //j++
	}
      else INC(3);
      debug("step i",n,2); debug("step j",n,3);
      ASSIGN_N(5,N,7);
      RESTORE_N(N,7);
      DEC(5);
      SUBS(5,2,7);
      RESTORE(2,7);
      if (NON_ZERO(5))  // if (N-1-i>0), i.e i<N-1
	{
	  INC_POINTER(A,2,7); // A[i]
	  RESTORE(2,7) ; 
	  INC_POINTER_POINTER(A,3,7); // A[i][j]
	  RESTORE(3,7) ; 
	  if (**A)
	    RESET(5);
	  DEC_POINTER_POINTER(A,3,7); // A[i][j]
	  RESTORE(3,7) ;
	  DEC_POINTER(A,2,7);
	  RESTORE(2,7) ; 
	} // k = k && !A[i][j]
      debug("B: loop i < N-1 && !A[i][j]",n,5);
    }
  ASSIGN_N(5,N,7);
  RESTORE_N(N,7);
  DEC(5);
  SUBS(5,2,7);
  RESTORE(2,7);
  NEG(5);
  debug("epilogue: i==N-1",n,5);
  return NON_ZERO(5);
}
 

Los mensajes debug, por supuesto, son opcionales y no forman parte del codigo. Es para poder seguir mejor la codificacion de las variables en una sola.

Ah!, las pruebas de que va bien!

El codigo de IO esta en
https://foro.elhacker.net/programacion_cc/algebra_de_matrices_matriz_triangular_superior_desdendiente_en_c-t504451.0.html;msg2220794#msg2220794


P.D
Si aun no te convence que es una variable...  aplica la siguiente linea en el compilador
para observar que solo existe la varaible "n" en la rutina...

el resultado es.

int lowerTriangleDesc(const int **A, int N)
{
  int n=1;
 
  n=3;
  for( ;N;N--) n*=5*7;
  for( ; !(n%7);n/=7) N++;
  n/=5;
  for( ; !(n%2);n/=2) { n/=5; n*=7 ;};
  for( ; !(n%7);n/=7) n*=2;
  if (!(n % 5))
    {
      for( ; !(n%2); n/=2 ) { A++; n*=7 ; };
      for( ; !(n%7);n/=7) n*=2 ;
      for( ; !(n%3); n/=3 ) { (*A)++; n*=7; };
      for( ; !(n%7);n/=7) n*=3 ;
      if (**A)
	for( ; !(n%5);n/=5);
      for( ; !(n%3); n/=3 ) { (*A)--; n*=7; };
      for( ; !(n%7);n/=7) n*=3 ;
      for( ; !(n%2); n/=2 ) { A--; n*=7 ; };
      for( ; !(n%7);n/=7) n*=2 ;
    }
  debug("init i",n,2); debug("init j",n,3);
  debug("B: loop i < N-1 && !A[i][j]",n,5);
  for(; !(n % 5); )
    {
      for( ; !(n%5);n/=5);
      for( ;N;N--) n*=5*7;
      for( ; !(n%7);n/=7) N++;
      n/=5;
      for( ; !(n%3);n/=3) { n/=5; n*=7 ;};
      for( ; !(n%7);n/=7) n*=3;
      if ((n%5))
	{
	  n*=2;
	  for( ; !(n%3);n/=3);
	  for( ; !(n%2);n/=2) n*=3*5;
	  for( ; !(n%5);n/=5) n*=2;
	  n*=3;
	}
      else n*=3;
      debug("step i",n,2); debug("step j",n,3);
      for( ;N;N--) n*=5*7;
      for( ; !(n%7);n/=7) N++;
      n/=5;
      for( ; !(n%2);n/=2) { n/=5; n*=7 ;};
      for( ; !(n%7);n/=7) n*=2;
      if (!(n % 5))
	{
	  for( ; !(n%2); n/=2 ) { A++; n*=7 ; };
	  for( ; !(n%7);n/=7) n*=2 ;
	  for( ; !(n%3); n/=3 ) { (*A)++; n*=7; };
	  for( ; !(n%7);n/=7) n*=3 ;
	  if (**A)
	    for( ; !(n%5);n/=5);
	  for( ; !(n%3); n/=3 ) { (*A)--; n*=7; };
	  for( ; !(n%7);n/=7) n*=3 ;
	  for( ; !(n%2); n/=2 ) { A--; n*=7 ; };
	  for( ; !(n%7);n/=7) n*=2 ;
	}
      debug("B: loop i < N-1 && !A[i][j]",n,5);
    }
  for( ;N;N--) n*=5*7;
  for( ; !(n%7);n/=7) N++;
  n/=5;
  for( ; !(n%2);n/=2) { n/=5; n*=7 ;};
  for( ; !(n%7);n/=7) n*=2;
  if (n%5) n*=5; else for( ; !(n%5);n/=5);
  debug("epilogue: i==N-1",n,5);
  return !(n % 5);
}