Biderketarekiko alderantzizko modular

**Biderketarekiko alderantzizko modularra** aritmetika modularrareko eragiketa bat da. n zenbaki oso baten biderketarekiko alderantzizkoa modulu p beste m zenbaki oso bat da non:

m\,n \equiv 1 \pmod{p},

hau da, mn biderketa 1-arekin kongruentea den (modulu p). m zenbakia n zenbakiaren alderantzizkoa modulu p dela horrela adierazten da:

n^{-1} \equiv m \pmod{p}.

Biderketarekiko alderantzizko modularra ez da beti existitzen. n-ren alderantzizko modularra existitzen da baldin eta soilik baldin n eta p elkarrekiko lehenak badira, hau da, zkh(n,p)=1 bada.

n zenbakiaren alderantzizkoa modulu n existitzen denean, orduan beste zenbaki bat n balioaz zatitzearen eragiketa (modulu p) defini daiteke; zenbaki bat n balioaz zatitzea n^{-1} alderantzizko modularraz biderkatzea da. p zenbaki lehena bada, orduan zenbaki guztiak dira alderantzikagarriak, 0-a izan ezik.
 

## Azalpena 
Biderketaren alderantzizko modularra ez da bakarra. Normalean, n-ren alderantzizkotzat (modulu p) hartzen den m zenbakia aukera guztien artean txikiena den zenbaki arrunta izaten da.

Adibidea:

Demagun n=3 zenbakiaren alderantzizkoa modulu p=11 kalkulatu nahi dela,
m\equiv 3^{-1}\pmod{11}.

mn \equiv 1 \pmod{p} betetzen duen m zenbakia aurkitu nahi da, hau da,

3^{-1}\cdot 3\equiv 1\pmod{11}

beteko duena. Kongruentzia hori betetzen duen zenbaki arrunt txikiena 4 da (\mathbb{Z}_{11} partizioko balioa da). Horrela egiazta daiteke:

:4=3^{-1} \pmod{11} \quad \rightarrow \quad 4 \cdot 3 \equiv 1 \pmod{11} \quad \rightarrow \quad 12 \equiv 1 \pmod{11}

Esan bezala, m=4 ez da aukera bakarra, 4-ri 11-ren multiploak gehituz, hau da, 4 + (11 \cdot z ),\ z \in \mathbb{Z}, beste 3^{-1} \pmod{11} balio posibleak lor daitezke. Horrela, {..., −18, −7, 15, 26, ...} multzoko balio guztietarako m\cdot 3\equiv 1\pmod{11} betetzen da.

## Kalkuluak 
### Euklidesen Algoritmo Hedatua 
Euklidesen algoritmo hedatua erabiliz n-ren biderketarekiko alderantzikoa modulu p kalkula daiteke.

Esan dugunez, n-ren alderantzikoa modulu p

xn \equiv 1 \pmod{p}

betetzen duen x zenbaki osoa da, p|xn-1 betetzen da, hau da, p balioak xn-1 zatitzen du. Hortaz,

:\exists k \in \mathbb{Z}\quad  non  \quad xn - 1 = kp.\,

Beste era batean idatzita:

:xn - kp = 1.\,

Euklidesen algoritmo hedatuak ebazten duen problema, hain zuzen ere, hori da. n eta p zenbaki osoak izanik, zkh(n,p) zatitzaile komunetako handiena eta

:xn + yp = zkh(n,p)

berdintza betetzen duten x eta y zenbaki osoak kalkula daitezke. Kasu honetan zkh(n,p)=1 aurrez ezarrita dator. Baldin zkh(n,p) \neq 1 bada, orduan n-ren alderantzikoa modulu p ez da existitzen.

|n| bada, algoritmoa O(log(p)^2) denboran exekutatuko da.

**Adibidea**

n=117 eta p=244 izanik, 117-ren alderantzizkoa modulu 244 horrela kalkulatzen da. Hasteko, existitzen dela egiaztatu behar da, hau da, zkh(n,p)=1 dela. Horretarako, Euklidesen algoritmoa aplikatuko dugu. Ondoren, zkh(n,p) kalkulatzeko egindako eragiketetatik n^{-1} lortuko dugu:

# |n|  denez, p=qn+r idatz daiteke. Hau da, 244=2\cdot 117+10. Hondarra askatuz: 10=224-2\cdot 117
# 117>10 denez, 117=11\cdot 10+7. Hondarra askatuz: 7=117-11\cdot 10
# 10>7 denez, 10=1\cdot 7+3. Hondarra askatuz: 3=10-1\cdot 7
# 7>3 denez, 7=2\cdot 3+1. Hondarra askatuz: 1=7-2\cdot 3
# 3>1 denez, 3=1\cdot 3+0. Hortaz, zkh(244,117)=1 betetzen denez, 244 eta 117 elkarrekiko lehenak dira eta ondorioz, bilatzen dugun alderantzizko modularra existitzen da.
# Koefizienteen kalkulurako abiapuntua 4. urratseko 1=7-2\cdot 3 adierazpena da. Ondorengo urratsetan aurreko urratsetako hondarren adierazpenak ordezkatu behar dira.
# 3. urratseko hondarra 6. urratseko ekuazioan txertatuz: 1=7-2\cdot (10-1\cdot 7), hau da, 1=2\cdot 10+3\cdot 7.
# 2. urratseko hondarra 7. urratseko ekuazioan txertatuz: 1=2\cdot 10+3\cdot (117-11\cdot 10), hau da, 1=3\cdot 117-35\cdot 10.
# 1. urratseko hondarra 8. urratseko ekuazioan txertatuz: 1=3\cdot 117-35\cdot (244-2\cdot 117), hau da, 1=35\cdot 244+73\cdot 117. Esan dezakegu n^{-1}=73 dela, 1=x\cdot n+k\cdot p ekuazioa kontuan hartuz.
# n^{-1} negatiboa bada, n^{-1}-en alderantzizkoa n^{-1}+p izango da.

## Erabilerak 
Biderketarekiko alderantzizko modularrak erabilera ugari ditu algoritmoetan, zenbaki teoria-rekin erlazioa dutenetan bereziki, algoritmo horietako askoren oinarrian aritmetika modularraren teoria dagoelako.

Makina askok ez daukate zatiketa eragiketa egiteko hardware berezirik eta ondorioz, zatiketaren eragiketa biderketarena baino motelago exekutatzen da. Alderantzizko modularraren erabilerarekin kalkuluak azkarrago egitea lortzen da.

## Inplementazioak 
### Inplementazioa C-n 
```c
//Calculador de inversos modulares (CIM), Arget-ek sortua
//Biderketarekiko alderantzizko modularraren kalkulua.
//Erabilera: cim a m
//(cim) programak (a * b)(mod m) = 1 betetzen duen b aurkituko du.
//Exekutatzean ez bada emaitzik itzultzen, ‘a’ balioak ez du alderantzizkorik modulu ‘m’.
#include 
#include 

int main(int argc, char** argv)
{
    if(argc == 1)exit(-1);

    int b, // (a * b)(mod m)-n esprezioko b balioa gordeko da
        x, //eragiketaren emaitza gordeko da
        a = atoi(argv[1]), //a gorde
        m = atoi(argv[2]); //m gorde

    for(b = 0; b < m; b++)
    {
        x = (a * b) % m;
        if(x == 1)
            printf("%i", b);
    }
    return 0;
}
```

### Inplementazioa Java-n 
```java
//JLCY-k sortua,  (17-1-2016) 
    // Bezout-en lema aplikatuz
    //zkh(z,p) lortzen da euklidesen algoritmoa erabiliz
    //zkh(a,p)=1 bada, "a" eta "p" elkarrekiko lehenak dira; "a"-ren alderantzizkoa modulu "m" existitzen da.
    public void Inverso(int a,int m)
    {
        int c1=1,c2=-1*(m/a);//a-ren eta b-ren koefizienteak hurrenez hurren
        int t1=0,t2=1;
        int r=m%a;//hondarra
        int x=a,y=r,c;
        while(r!=0)
        {
        c= x/y;//zatidura
        r= x%y;//hondarra
        //koefizienteen aldi baterako balioak gordetzen dira
        c1*=-1*c;
        c2*=-1*c;
        //aurreko korritzea batzen da
        c1+=t1;
        c2+=t2;
        //korritzea eguneratzen da
        t1=-1*(c1-t1)/c;
        t2=-1*(c2-t2)/c;
        x=y;
        y=r;
        }
      if(x==1)//aurreko hondarra 1 bada, elkarrekiko lehenak dira eta alderantzizko existitzen da
            System.out.println(""+t2);
      else
            System.out.println("ez dago alderantzizkorik");
    }
```

## Kanpo estekak