Inverso multiplicativo modular
Encontre o número que desfaz uma multiplicação módulo m: o inverso de 3 módulo 11 é 4, porque 3 vezes 4 deixa resto 1. Você também vê o mdc e um valor de conferência, além de um aviso claro quando não há inverso. 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
- A
- 3
- Módulo m ≥ 2
- 11
- A módulo
- 3
- Inverso
- 4
- Mdc
- 1
- Verificação
- 1
O inverso multiplicativo modular de um inteiro a módulo m é o resíduo x que satisfaz a vezes x congruente a um módulo m. Esse inverso existe se e somente se a e m forem coprimos — o máximo divisor comum é um. Tutoriais de criptografia, etapas de chave privada RSA, divisão modular em programação competitiva e cálculos em grupos cíclicos precisam dessa operação, mas muitas linguagens só expõem um GCD binário e deixam os coeficientes de Bézout com você. Esta calculadora recebe a e m, executa o algoritmo de Euclides estendido de forma determinística e devolve o único inverso não negativo no intervalo de zero a m menos um, junto com o gcd e um produto de verificação para você confirmar o resultado sem rederivar os passos.
O que é um inverso modular e quando ele existe
Na aritmética comum todo número não nulo tem inverso multiplicativo: divida por ele e obtém um. Na aritmética modular a mesma ideia vira uma congruência. Dizemos que x é um inverso modular de a módulo m quando a vezes x deixa resto um ao dividir por m.
Como os resíduos reiniciam a cada m passos, nem todo a tem tal x. O obstáculo é teórico-numérico, não de ponto flutuante: se d é o gcd de a e m e d é maior que um, então a vezes qualquer inteiro é múltiplo de d, de modo que o produto nunca pode ser congruente a um, que não é múltiplo de d.
Por outro lado, a identidade de Bézout garante inteiros x e y com a x mais m y igual a um exatamente quando esse gcd é um, e reduzir x módulo m produz o inverso. Engenheiros encontram essa condição ao dividir em um corpo finito, ao escolher expoentes de decriptação RSA que invertem o expoente público módulo phi de n, ao desfazer multiplicações modulares em pipelines de hash ou ao resolver congruências lineares em programação competitiva.
Devolver um erro explícito quando o par não é coprimo é mais útil do que uma falha silenciosa: o cliente descobre que não existe inverso e pode ramificar pelo gcd em vez de adivinhar qual biblioteca devolveu um resíduo errado.
Casos de uso
Labs de cripto e ensino de RSA
Instrutores e alunos podem inverter expoentes públicos módulo φ(n) sob demanda e inspecionar o gcd quando um módulo de amostra não é coprimo com o expoente.
Programação competitiva e divisão modular
Programadores competitivos podem substituir trechos ad hoc de GCD estendido por uma única chamada determinística ao verificar divisão modular sob módulos primos ou compostos.
Perguntas frequentes
O que acontece se a e m não forem coprimos?
A mensagem inclui gcd(a, m) para você saber por que não existe inverso multiplicativo modular. Validação falha não é cobrada.
Qual algoritmo calcula o inverso?
O algoritmo de Euclides estendido. Ele acha coeficientes de Bézout para a mod m e m; quando o gcd é 1, o coeficiente de a é reduzido ao intervalo 0..m−1.
A calculadora de inverso modular é grátis?
A ferramenta do navegador roda grátis no seu dispositivo.
Quais intervalos de a e m são aceitos?
m deve ser um inteiro de 2 a 1,000,000,000,000. a deve ser um inteiro cujo valor absoluto seja no máximo esse mesmo limite. Valores fora são rejeitados.
Qual é o inverso de 3 módulo 11?
É 4. Multiplicando 3 por 4 e dividindo por 11, sobra resto 1, que é exatamente o que um inverso precisa fazer. O valor de conferência mostrado ao lado do resultado é esse 1.
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/modular-inverse \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"a":3,"m":11}'const res = await fetch("https://api.kit.forhosting.com/numth/modular-inverse", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"a": 3,
"m": 11
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/numth/modular-inverse",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"a": 3,
"m": 11
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/numth/modular-inverse", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"a":3,"m":11}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"a":3,"m":11}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/numth/modular-inverse", 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
{
"a": 3,
"m": 11
}Exemplo de resposta
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "numth.modular_inverse",
"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_abs | 1000000000000 |
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 executa o algoritmo de Euclides estendido
Chame a capacidade com os campos inteiros a e m, onde m é pelo menos dois. Os valores absolutos são limitados a um trilhão para que todo produto intermediário fique dentro da faixa de inteiros seguros do JavaScript. A implementação primeiro reduz a à classe de resíduo não negativa a_mod em zero até m menos um e depois aplica o algoritmo de Euclides estendido ao par a_mod e m. Cada passo registra o quociente inteiro e atualiza os coeficientes de Bézout de modo que, ao terminar, o coeficiente de a_mod vezes a_mod mais um coeficiente de m iguala o gcd. Se esse gcd não for um, a requisição falha com invalid_input e uma mensagem que nomeia ambas as entradas e o gcd; nada é cobrado. Se o gcd for um, o coeficiente de a_mod é reduzido ao intervalo de zero a m menos um e devolvido como inverse. A resposta também ecoa a, m, a_mod, gcd e check igual a a_mod vezes inverse módulo m, que deve ser um sempre que a chamada tiver sucesso.
Uso prático, limites, preços e entrega
Use a ferramenta do navegador quando quiser um inverso rápido ao ler uma nota de cripto, conferir uma congruência de dever de casa ou depurar um passo de multiplicação modular. As entradas aceitas são inteiros a com valor absoluto no máximo um trilhão e módulos m de dois a um trilhão. Os resultados são determinísticos: o mesmo par sempre produz o mesmo inverso e o mesmo campo check. Use a API quando um script, corretor ou plataforma educacional precisar de muitos inversos sem embutir uma rotina de GCD estendido. Cada requisição bem-sucedida é um item faturável a US$ 0,002; falhas de validação e pares não coprimos não consomem saldo. Conecte o endpoint a sandboxes de ensino RSA, demos de corpos finitos, ajudas de programação competitiva ou qualquer pipeline inteiro que prefira aritmética exata a heurísticas aproximadas. Como a unidade é um único item e o motor é parse puro, a latência permanece baixa e o canal web gratuito espelha a API paga sem um segundo caminho de código que possa divergir.
Casos de integração
Corretores de tarefas e pipelines de teoria dos números
Corretores e scripts automáticos podem confirmar inversos, detectar entradas não coprimas via invalid_input e manter cada produto intermediário dentro dos limites documentados.
Perguntas técnicas
Como calculo um inverso modular com esta API?
Envie JSON com os campos inteiros a e m (m ≥ 2) para numth.modular_inverse. Em sucesso a resposta devolve inverse em 0..m−1, mais a_mod, gcd e check igual a 1.