Totiente de Jordan J_k(n) a partir dos fatores primos
Com ordem 1, a totiente de Jordan de 36 é 12, igual à totiente de Euler. Escolha uma ordem k maior e a calculadora aplica n^k vezes o produto de (1 − p^−k) sobre os primos de n, mostrando a fatoração usada. Grátis no seu navegador.
- Grátis
- Funciona no seu navegador
- Sem cadastro
- Seus dados não saem do seu aparelho
Executar grátis
Exemplo resolvido
- N
- 36
- K
- 1
- Função de Jordan
- 12
A função totiente de Jordan J_k(n) generaliza a totiente de Euler contando k-uplas de inteiros módulo n que geram um Z-módulo livre de posto k, ou de forma equivalente pela fórmula produto n^k vezes o produto sobre os primos p que dividem n de (1 menos p à menos k). Quando a ordem k vale um, J_1(n) recupera exatamente φ(n). Esta calculadora recebe um inteiro positivo n e uma ordem positiva k, fatora n por divisão de prova determinística e avalia o produto clássico de potências primas para obter um inteiro exato J_k(n) sem deriva de ponto flutuante nem serviços externos. Use-a para conferir exercícios, contagens de pontos de rede e pipelines de teoria dos números que já confiam em aritmética exata.
O que a totiente de Jordan mede e por que importa
A totiente de Euler φ(n) conta as classes de resíduo módulo n coprimas com n. A função de Jordan eleva essa contagem a posto superior: J_k(n) é o número de k-uplas de inteiros em {1, …, n}^k relativamente primas como conjunto a n, no sentido de que o máximo divisor comum de todas as k coordenadas junto com n é um.
De forma equivalente, é a ordem do grupo de matrizes invertíveis k por k sobre o anel de inteiros módulo n redutíveis à forma elementar, e aparece como o grau da extensão do corpo ciclotômico ao estudar reticulados e valores especiais da zeta de Dedekind. Para uma potência prima p à a a forma fechada é p à k vezes (a menos um) vezes (p à k menos um), e a multiplicatividade sobre fatores coprimos produz o produto global.
Engenheiros e autores de competições encontram J_k ao contar geradores livres de módulos, dimensionar grupos de unidades de anéis de matrizes sobre Z/nZ ou verificar identidades que se reduzem a φ quando k é um. Devolver o valor da totiente e a fatoração que o produziu elimina uma fonte comum de erros de desvio em corretores de exercícios, comparações com CAS e pipelines inteiros que, de outro modo, reimplementariam a fatoração ad hoc em cada exercício.
Como esta calculadora avalia J_k(n) a partir dos fatores primos
Chame a capacidade com dois campos inteiros positivos: n e k. A implementação fatore n por divisão de prova separando fatores de dois, depois candidatos ímpares até a raiz quadrada e, por fim, qualquer cofator primo restante. A partir dessa lista ordenada aplica a forma inteira exata do produto de Jordan: para cada potência prima p à a que divide n, multiplica o resultado acumulado por p elevado a k vezes (a menos um) vezes (p à k menos um).
As potências são calculadas com inteiros de precisão arbitrária para que os intermediários permaneçam exatos; o resultado final deve caber em um inteiro seguro de JavaScript para que os clientes recebam um número simples. Quando k vale um, o mesmo caminho reproduz a fórmula produto de Euler, de modo que J_1(n) coincide com φ(n) para todo n aceito. A resposta inclui n, k, jordan, a lista de fatores como pares primo e expoente, e uma string curta de fórmula para documentação.
Uso prático, limites, preço e entrega
Use a ferramenta do navegador quando quiser uma resposta imediata ao estudar teoria dos números multiplicativa, conferir uma identidade de livro que se especializa na totiente de Euler ou depurar uma contagem de pontos de rede. Os intervalos aceitos são n de um até um trilhão e k de um até vinte, cobrindo tamanhos típicos de competição, sala de aula e aplicação e mantendo a divisão de prova prática. Os resultados são determinísticos: o mesmo n e k sempre geram o mesmo valor jordan e a mesma lista de fatores.
Não há modelo de linguagem, nem serviço externo de fatoração, nem aleatoriedade, de modo que a capacidade é segura para fixar em testes automatizados.
Casos de uso
Verificação de tarefas e competições
Alunos e avaliadores podem confirmar J_k(n) para n e ordem k positivos arbitrários, inspecionar os fatores primos usados e verificar que J_1 coincide com φ de Euler sem um CAS local.
Demos de reticulados e módulos
Materiais didáticos sobre Z-módulos livres módulo n ou grupos de unidades de anéis de matrizes podem calcular totientes de Jordan sob demanda e mostrar a fatoração ao lado do resultado.
Perguntas frequentes
O que acontece se n ou k for menor que 1?
A totiente de Jordan é definida para inteiros positivos n e ordem k positiva; zero e negativos são rejeitados e não são cobrados.
Como J_k(n) se relaciona com a totiente de Euler?
Quando k vale 1, J_1(n) é igual a φ(n). Para k maior que 1 a função conta uma condição de coprimidade de posto superior via o produto n^k · Π (1 − p^{−k}).
A calculadora de totiente de Jordan é gratuita?
A ferramenta do navegador roda grátis no seu dispositivo.
Quais são o maior n e k que posso enviar?
n pode ir de 1 até 1,000,000,000,000 (1e12) e k de 1 até 20. Combinações cujo resultado excede o intervalo de inteiros seguros também são rejeitadas.
O que a totiente de Jordan conta?
Ela conta as k-uplas de números de 1 a n cujas coordenadas, junto com n, têm máximo divisor comum 1. Com k igual a 1 é exatamente a totiente de Euler, ou seja, quantos números são coprimos com n.
Ferramentas relacionadas
Para desenvolvedores — acesso via API
Tudo nesta página está disponível via API. Esta seção é para equipes que querem integrar a ferramenta aos próprios sistemas; quem não precisa disso pode simplesmente usar a ferramenta acima.
Endpoint
Autenticação por token Bearer. Um único POST coloca a tarefa na fila; o resultado chega por webhook ou link assinado.
Chame do seu código
curl -X POST https://api.kit.forhosting.com/numth/jordan-totient \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"n":36,"k":1}'const res = await fetch("https://api.kit.forhosting.com/numth/jordan-totient", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"n": 36,
"k": 1
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/numth/jordan-totient",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"n": 36,
"k": 1
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/numth/jordan-totient", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"n":36,"k":1}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"n":36,"k":1}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/numth/jordan-totient", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)Exemplo de requisição
{
"n": 36,
"k": 1
}Exemplo de resposta
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "numth.jordan_totient",
"status": "queued",
"_links": {
"result": "/tasks/tsk_…/result"
}
}A API é assíncrona: cada chamada devolve um task_id na hora. Se preferir polling, consulte o status a até 1 requisição por segundo.
Preço
Preço publicado, sem tokens nem créditos escondidos. Tarefa que falha não é cobrada.
Limites
max_n | 1000000000000 |
max_k | 20 |
Erros
| HTTP | Código | O que significa |
|---|---|---|
401 | unauthorized | Token ausente ou inválido. Confira o header Authorization. |
402 | insufficient_balance | Saldo insuficiente para esta tarefa. Faça uma recarga e tente de novo. |
404 | unknown_type | Esse tipo de tarefa não existe. Confira o campo type no catálogo. |
429 | rate_limited | Muitas requisições em pouco tempo. Espere um instante e tente de novo. |
Notas técnicas
Como esta calculadora avalia J_k(n) a partir dos fatores primos
Entradas abaixo de um em qualquer campo, não inteiros, campos ausentes, valores acima dos limites publicados e combinações cujo resultado estouraria o intervalo de inteiros seguros são rejeitadas como invalid_input e nunca são cobradas. A mesma função pura alimenta a ferramenta gratuita no navegador e o caminho da API, de modo que um exemplo dourado no servidor é a mesma aritmética que um visitante executa localmente sem ida e volta de rede nem estado oculto.
Uso prático, limites, preço e entrega
Use a API quando um script, um job de integração contínua ou uma plataforma educacional precisar de J_k(n) para muitos pares sem embutir uma biblioteca de fatoração. Cada pedido bem-sucedido é um item faturável a US$ 0,002; a validação falha não consome saldo. Conecte o endpoint a demonstrações de teoria dos números, sandboxes didáticos de criptografia que contrastam φ com contagens de Jordan de ordem superior, ou etapas de pré-processamento inteiro em que você já confia mais na aritmética exata do que em heurísticas aproximadas e precisa de um item precificado por par.
Casos de integração
Pipelines automatizados de teoria dos números
Scripts que enumeram identidades multiplicativas, valores especiais ou k-uplas reduzidas podem chamar um único endpoint determinístico com preço por item em vez de embutir código de fatoração.
Perguntas técnicas
Como calcular a totiente de Jordan J_k(n) com esta API?
Envie um corpo JSON com os campos inteiros positivos n e k para a capacidade numth.jordan_totient. A resposta devolve jordan, a fatoração prima ordenada e uma string de fórmula.