(4,0) y (12,3) son los únicos "primitivo y no-trivial de" soluciones de $(n,k)$ con $n\leq 10^5$.
Teniendo en cuenta las simetrías que están presentes tanto en su geometría de la pregunta y en la ecuación resultante, vamos un "primitivo y no-trivial de" solución de estar un par de $(n,k)$ con $n,k\in \mathbb{Z}$, $n\geq 3$, y $0\leq k \leq n/2 - 1$, satisfaciendo$$8\sin^2\left(\frac{(k+1)\pi}{n}\right)=n\sin\left(\frac{2\pi}{n}\right).$$
El hecho de que $k$ puede ser restringido a un número finito de intervalos para cada $n$ se abre el problema para un numérica directa de búsqueda. Aquí está mi aplicación en PARI/GP:
N_MIN=3;
N_MAX=100000;
N_BLOCKSIZE=100;
TOLERANCE=1e-20;
\\ We express the problem in terms of m,n, where m=k+1.
\\ We only call the (slow) sin function once for each computation of the LHS.
lhs(m,n)={sqrt_lhs=sin(m*Pi/n); sqrt_lhs*sqrt_lhs;}
rhs(n)=sin(2*Pi/n)*n/8;
\\ Check m,n for |LHS-RHS| < TOLERANCE
for(n=N_MIN,N_MAX,cur_rhs=rhs(n); if(n%N_BLOCKSIZE==0,printf("# Done checking all n<%u\n", n)); for(m=1,n/2,{
cur_lhs=lhs(m,n);
if(abs(cur_lhs-cur_rhs)<TOLERANCE, printf("%u\t%u\t%e\n", n, m-1, cur_lhs-cur_rhs))
}));
quit
Nota: Si no me equivoco, esto está garantizado para encontrar todas las soluciones de dólares(m,n)$ con $n<n_\max = 10^5$, aunque aritmética de punto flotante se utiliza (suponiendo que no existen errores en PARI/GP o mi pc). El punto es que PARI/GP de reclamaciones de una precisión predeterminada de 38 dígitos decimales, mientras que la tolerancia de la raíz encontrar en el código de arriba es la equivalencia a 20 dígitos decimales. Si se calcula la propagación de errores, asumiendo 38 dígitos de precisión para el pecado funciones, el error absoluto máximo después de los pocos operaciones aritméticas por $n,m$ par todavía está en el orden de $10^{-38}$. El código, en principio, puede dar falsos positivos si el lado derecho y el lado izquierdo no son iguales pero se encuentren dentro de la tolerancia de uno a otro, pero que no puede dar falsos negativos. (De hecho, para estos parámetros no hubo falsos positivos).
Actualización: Aquí es una implementación en C utilizando 128 bits aritmética de punto flotante:
#include <stdio.h>
#include <quadmath.h>
// To compile: gcc -O3 -std=c99 -lquadmath trig.c -o trig
#define M_2PIq 6.2831853071795864769252867665590058q
#define N_MIN 3
#define N_MAX 2000
#define N_BLOCKSIZE 100
#define TOLERANCE 1e-20q
#define DIGITS 35
int main(){
// We express the problem in terms of m,n, where m=k+1.
for(unsigned n=N_MIN; n<=N_MAX; n++){
// Print out a status update each N_BLOCKSIZE iterations.
if(n%N_BLOCKSIZE==0) printf("# Done checking all n<%u\n", n);
// Compute the RHS only once per n
__float128 cur_rhs = sinq(M_2PIq/n)*n/8.0q;
for(unsigned m=1; 2*m<=n; m++){
// We only call the (slow) sin function once for each computation of the LHS.
__float128 cur_lhs=sinq(m*M_PIq/n);
cur_lhs*=cur_lhs;
// Print out (n,k) if a solution is found
if( fabsq(cur_lhs-cur_rhs) < TOLERANCE ){
char str_difference[DIGITS];
quadmath_snprintf(str_difference, DIGITS, "%Qe", fabsq(cur_lhs-cur_rhs));
printf("%u\t%u\t%s\n", n, m-1, str_difference);
}
}
}
}
