Sunteți pe pagina 1din 143

MINISTERUL EDUCAȚIEI AL REPUBLICII MOLDOVA

UNIVERSITATEA DE STAT DIN TIRASPOL

CATEDRA
FIZICĂ, MATEMATICĂ ȘI TEHNOLOGII INFORMAȚIONALE

SPECIALITATEA
TEHNOLOGII INFORMAȚIONALE ÎN INSTRUIRE

Structuri algebrice pe calculator

Laboratoare

Realizat: Spînu Mariana


Grupa: C1I1
Verificat: Chiriac Liubomir

Chişinău, 2017

1
Cuprins
Algoritmi de verificare a unor proprietăţi algebrice și de identificare a unităților pe structuri algebrice
finite .............................................................................................................................................................. 3
Algoritmi de realizare a produsului direct dintre doi grupoizi ....................................................................21
Algoritmi de realizare a produsului direct special dintre doi grupoizi ........................................................36
Algoritmi pentru identificarea unităților multiple .......................................................................................52
Algoritmi privind obținerea izotopilor unui grupoid ...................................................................................67
Algoritmi privind verificareaobținerea izomorfismelor de grupoizi ...........................................................89
Algoritm privind compunerea substituțiilor ..............................................................................................107
Algoritmi privind obținerea quasigrupului dintr-un grup comutativ pe care sunt definite careva operații
binare .........................................................................................................................................................111

2
Algoritmi de verificare a unor proprietăţi algebrice și
de identificare a unităților pe structuri algebrice finite

Problema. Se dă grupoidul (Q, ∙). Se cere de elaborat un program care verifică


dacă în grupoidul respective se îndeplinesc următoarele proprietăți:

1. Asociativitatea: a(bc)=(ab)c ,∀a,b ,c ∈Q

2. Medialitatea: (ab)(cd)=(ac )(bd ),∀a,b, c ,d∈Q

3. Paramedialitatea: (ab)(cd)=(db)( ca),∀a,b , c ,d ∈Q

4. Bicomutativitatea: (ab)(cd)=(dc)(ba),∀a ,b , c ,d∈Q

5. AG grupoid: (ab) c=(cb)a ,∀a ,b , c∈Q

6. GA grupoid: (ab) c=c(ba),∀a , b, c∈Q

7. GA-1 grupoid: (ab) c=(ca)b ,∀a,b , c∈Q

8. AD grupoid: a(bc)=c(ba),∀a,b, c∈Q

9. DA grupoid: a(bc)=c(ab),∀a,b ,c ∈Q

10. Hexagonalitatea:a⋅a=a ;(ab)(cd)=(ac )(bd),a(ba)=(ab)a=b ,∀a ,b , c ,d∈Q

11. Distributivitatea la dreapta: (ab)c=(ac)(bc ),∀a, b, c∈Q

12. Distributivitatea la stânga: c (ab)=(ca)(cb),∀ a ,b , c∈Q

13. Unitatea la dreapta: xe=x ,∀x∈Q

14. Uniatea la stânga: ex=x ,∀x∈Q

15. Unitateaxe=ex=x ,∀x∈Q

16. Ward: ab=(ac)(bc)∀a , b, c∈Q

17. Ward invers: ab=( ca)(cb)∀a,b, c∈Q.

3
Aplicând programul elaborat să se cerceteze proprietățile următoarelor structuri
algebrice:
Grupoidul(𝑄1 ) Grupoidul(𝑄2 ) Grupoidul(𝑄3 )
1 2 3 4 1 2 3 4 1 2 3 4
1 2 3 1 4 1 1 2 4 3 1 1 2 4 3
2 4 1 3 4 2 2 3 1 4 2 2 3 1 4
3 3 2 4 1 3 4 1 3 2 3 4 1 3 2
4 1 4 2 3 4 3 4 2 1 4 3 4 2 1

Grupoidul(𝑄4 ) Grupoidul(𝑄5 ) Grupoidul(𝑄6 )


1 2 3 4 1 2 3 1 2 3 4
1 2 1 3 4 1 1 2 3 1 1 4 2 3
2 1 3 4 2 2 2 3 1 2 3 2 4 1
3 3 4 2 1 3 3 1 2 3 4 1 3 2
4 4 2 1 3 4 2 3 1 4

Grupoidul(𝑄7 ) Grupoidul(𝑄8 )
1 2 3 4 5 6 7 1 2 3 4 5 6
1 1 4 7 3 6 2 5 1 1 2 2 5 6 4
2 6 2 5 1 4 7 3 2 2 2 2 5 6 4
3 4 7 3 6 2 5 1 3 2 2 3 3 6 4
4 2 5 1 4 7 3 6 4 6 6 6 4 2 5
5 7 3 6 2 5 1 4 5 4 4 4 6 5 2
6 5 1 4 7 3 6 2 6 5 5 5 2 4 6
7 3 6 2 5 1 4 7

Grupoidul(𝑄9 ) Grupoidul(𝑄10 ) Grupoidul(𝑄11 )


1 2 3 4 1 2 3 4 1 2 3 4
1 1 2 4 3 1 2 1 3 4 1 2 1 3 4
2 2 3 1 4 2 1 3 4 2 2 3 4 2 1
3 4 1 3 2 3 3 4 2 1 3 4 3 1 2
4 3 4 2 1 4 4 2 1 3 4 1 2 4 3

Grupoidul(𝑄12 ) Grupoidul(𝑄13 ) Grupoidul(𝑄14 )


1 2 3 1 2 3 1 2 3 4
1 1 2 3 1 1 3 2 1 1 3 2 4
2 3 1 2 2 2 1 3 2 2 1 4 3
3 2 3 1 3 3 2 1 3 3 4 1 2
4 4 2 3 1

Grupoidul(𝑄15 ) Grupoidul(𝑄16 )
1 2 3 4 1 2 3 4 5 6
1 1 2 3 4 1 1 3 2 4 5 6
2 3 1 4 2 2 2 1 3 6 4 5
3 2 4 1 3 3 3 2 1 5 6 4
4
4 4 3 2 1 4 4 6 5 1 2 3
5 5 4 6 3 1 2
6 6 5 4 2 3 1

Elaborarea programului:
Program problema1_2;
uses crt;
type masiv=array[1..15,1..15] of integer;
var a,gr:masiv;
r1,d1,r,d,r2,n,t,i,j,k,p,l,d2:integer;

Procedure asociativ(gr:masiv);
var l:integer;
begin
l:=0;
for i:=1 to n do
for j:=1 to n do
for k:=1 to n do begin
d:=gr[j,k];
d1:=gr[i,j];
if gr[i,d]<>gr[d1,k] then inc(l);
end;
if l=0 then writeln('Este asociativ')
else writeln('Nu este asociativ ' ) ;
end;

Procedure medial(gr:masiv);
var l:integer;
begin
l:=0;
for i:=1 to n do
for j:=1 to n do
for k:=1 to n do
for t:=1 to n do begin
d:=gr[i,j];
r:=gr[k,t];
d1:=gr[i,k];
r1:=gr[j,t];
if gr[d,r]<>gr[d1,r1] then inc (l);
end;
if l=0 then writeln('Este medial')
else writeln('Nu este medial');
end;

5
Procedure paramedial(gr:masiv);
var l:integer;
begin
l:=0;
for i:=1 to n do
for j:=1 to n do
for k:=1 to n do
for t:=1 to n do begin
d:=gr[i,j];
r:=gr[k,t];
d1:=gr[t,j];
r1:=gr[k,i];
if gr[d,r]<>gr[d1,r1] then inc(l);
end;
if l=0 then writeln('Este paramedial ')
else writeln('Nu este paramedial');
end;

Procedure bicomutativ(gr:masiv);
var l:integer;
begin
l:=0;
for i:=1 to n do
for j:=1 to n do
for k:=1 to n do
for t:=1 to n do begin
d:=gr[i,j];
r:=gr[k,t] ;
d1:=gr[t,k] ;
r1:=gr[j,i];
if gr[d,r]<>gr[d1,r1] then inc (l);
end;
if l=0 then writeln('Este bicomutativ')
else writeln('Nu este bicomutativ');
end;

Procedure ag_gr(gr:masiv);
var l:integer;
begin
l:=0;
for i:=1 to n do
for j:=1 to n do
for k:=1 to n do begin
d:=gr[i,j];
d1:=gr[k,j];

6
if gr[d,k]<>gr[d1,i] then inc(l);
end;
if l=0 then writeln('Este AG grupoid')
else writeln('Nu este AG grupoid');
end;

Procedure ga_gr(gr:masiv);
var l:integer;
begin
l:=0;
for i:=1 to n do
for j:=1 to n do
for k:=1 to n do begin
d:=gr[i,j];
d1:=gr[j,i];
if gr[d,k]<>gr[k,d1] then inc(l);
end;
if l=0 then writeln('Este GA grupoid')
else writeln('Nu este GA grupoid');
end;

Procedure ga_gr1(gr:masiv);
var l:integer;
begin
l:=0;
for i:=1 to n do
for j:=1 to n do
for k:=1 to n do begin
d:=gr[i,j];
d1:=gr[k,i];
if gr[d,k]<>gr[d1,j] then inc(l);
end;
if l=0 then writeln('Este GA1 grupoid')
else writeln('Nu este GA1 grupoid');
end;

Procedure ad_gr(gr:masiv);
var l:integer;
begin
l:=0;
for i:=1 to n do
for j:=1 to n do
for k:=1 to n do begin
d:=gr[j,k];
d1:=gr[j,i];

7
if gr[i,d]<>gr[k,d1] then inc (l);
end;
if l=0 then writeln('Este AD grupoid')
else writeln('Nu este AD grupoid' );
end;

Procedure da_gr(gr:masiv);
var l:integer;
begin
l:=0;
for i:=1 to n do
for j:=1 to n do
for k:=1 to n do begin
d:=gr[j,k];
d1:=gr[i,j];
if gr[i,d]<>gr[k,d1] then inc(l);
end;
if l=0 then writeln('Este DA grupoid')
else writeln('Nu este DA grupoid');
end;

Procedure hexagonal(gr:masiv);
var l:integer;
begin
l:=0;
for i:=1 to n do
for j:=1 to n do
for k:=1 to n do
for t:=1 to n do begin
d:=gr[i,j];
r:=gr[k,t];
d1:=gr[i,k];
r1:=gr[j,t];
r2:=gr[j,i];
if (gr[i,i]<>i)or(gr[d,r]<>gr[d1,r1])
or(gr[i,r2]<>gr[d,i]) and(gr[d,i]<>j)then inc(l);
end;
if l=0 then writeln('Este hexagonal')
else writeln('Nu este hexagonal ');
end;

Procedure dist_dr(gr:masiv);
var l:integer;
begin
l:=0;

8
for i:=1 to n do
for j:=1 to n do
for k:=1 to n do begin
d:=gr[i,j];
d1:=gr[i,k];
r1:=gr[j,k];
if gr[d,k]<>gr[d1,r1] then inc(l);
end;
if l=0 then writeln('Este distributiv la dreapta')
else writeln('Nu este distributiv la dreapta');
end;

Procedure dist_st(gr:masiv);
var l:integer;
begin
l:=0;
for i:=1 to n do
for j:=1 to n do
for k:=1 to n do begin
d:=gr[i,j];
d1:=gr[k,i];
r1:=gr[k,j];
if gr[k,d]<>gr[d1,r1] then inc(l);
end;
if l=0 then writeln('Este distributiv la stinga')
else writeln ('Nu este distributiv la stinga');
end;

Procedure unitate_dreapta(gr:masiv);
var l:integer;
begin
j:=0;
r:=0;
for i:=1 to n do begin
l:=0;
inc(j);
if gr[j,i]=i then begin
for k:=1 to n do begin
if gr[k,j]=k then inc(l);
if l=n then r:=j;
end; end; end;
if r<>0 then writeln('Este unitate de dreapta ',r)
else writeln('Nu este unitate de dreapta');
end;

9
Procedure unitate_stanga(gr:masiv);
var l:integer;
begin
j:=0; r2:=0;
for i:=1 to n do begin
l:=0;
inc(j);
if gr[i,j]=i then begin
for k:=1 to n do begin
if gr[j,k]=k then inc(l);
if l=n then r2:=j;
end; end; end;
if r2<>0 then writeln('Este unitate de stanga ', r2)
else writeln('Nu este unitate de stanga ');
end;

Procedure unitate;
begin
if (r=r2) and (r>0) then writeln('Este unitate ',r)
else writeln('Nu este unitate');
end;

Procedure afisare;
begin
for i:=1 to n do begin
writeln;
for j:=1 to n do begin
write(a[i,j],' ');
end; end; end;

Procedure ward(gr: masiv);


var i,j,k:integer;
begin
l:=0;
for i:=1 to n do
for j:=1 to n do
for k:=1 to n do
begin
d:=gr[i,j]; d1:=gr[i,k]; d2:=gr[j,k];
if d<>gr[d1,d2] then l:=l+1;
end;
if l=0 then writeln('Este Ward')
else writeln('Nu este Ward');
end;

10
Procedure ward_inv(gr: masiv);
var i,j,k:integer;
begin
l:=0;
for i:=1 to n do
for j:=1 to n do
for k:=1 to n do
begin
d:=gr[i,j]; d1:=gr[k,i]; d2:=gr[k,j];
if d<>gr[d1,d2] then l:=l+1;
end;
if l=0 then writeln('Este Ward invers')
else writeln('Nu este Ward invers');
end;

Begin
clrscr;
write('Dati n= ');
readln(n);
for i:=1 to n do
for j:=1 to n do begin
write('a[',i,', ',j,']=');
readln(a[i,j]);
end;
afisare;
writeln;
asociativ(a);
medial(a);
paramedial(a);
bicomutativ(a);
ag_gr(a);
ga_gr(a);
ga_gr1(a);
ad_gr(a);
da_gr(a);
hexagonal(a);
dist_dr(a);
dist_st(a);
unitate_dreapta(a);
unitate_stanga(a);
unitate;
ward(a);
ward_inv(a);
End.

11
În urma compilării sau obţinut următoarele rezultatele :

Grupoidul 1:

Grupoidul 2:

12
Grupoidul 3:

Grupoidul 4:

13
Grupoidul 5:

Grupoidul 6:

14
Grupoidul 7:

Grupoidul 8:

15
Grupoidul 9:

Grupoidul 10:

16
Grupoidul 11:

Grupoidul 12:

17
Grupoidul 13:

Grupoidul 14:

18
Grupoidul 15:

19
Grupoidul 16:

Tabelul cu proprietățile grupoizilor :


G1 G2 G3 G4 G5 G6 G7 G8 G9 G10 G11 G12 G13 G14 G15 G16
Asociativ - - - - + - - - - - - - - - - -
Medial + - - - + + + - - - - + + + + -
Paramedial - - - - + - - - - - + + + + + -
Bicomutativ - + + + + - - - + + - + + + + -
AG grupoid + - - - + + - - - - - + - - + -
GA grupoid - + + + + - - - + + - - - - - -
GA1 grupoid - - - - + - - - - - - - - - - -
AD grupoid + - - - + + - - - - - - + + - -
DA grupoid - - - - + - - - - - - - - - - -
Hexagonal - - - - - + + - - - - - - - - -
Distributivladreapta - - - - - + + - - - - - - - - -
Distributivlastânga - - - - - + + - - - - - - - - -
Unitatededreapta - - - - 1 - - - - - - - 1 1 - 1
Unitatedestânga - - - - 1 - - - - - - 1 - - 1 -
Unitate - - - - 1 - - - - - - - - - - -
Ward - - - - - - - - - - - - + + - +
Wardinvers - - - - - - - - - - - + - - + -

20
Algoritmi de realizare a produsului direct dintre doi
grupoizi

Problemă. Se cere de elaborat un algoritm care efectuează produsul cartezian


dintre grupoidul (𝐺1 ,∙) și (𝐺2 ,∗) conform următoarei reguli:
(𝑎1 , 𝑏1 ) ∘ (𝑎2 , 𝑏2 ) = (𝑎1 ⋅ 𝑎2 , 𝑏1 ∗ 𝑏2 ), ∀(𝑎1 , 𝑏1 ), (𝑎2 , 𝑏2 ) ∈ 𝐺1 × 𝐺2 .

Să se realizeze produsul direct dintre grupoizii indicați mai jos:


Ex.1
· 1 2 * 1 2 3
1 1 2 1 1 2 3
2 2 1 2 3 1 2
3 2 3 1

Ex.2
· 1 2 3 4 * 1 2 3 4 5 6 7
1 2 3 1 4 1 1 4 7 3 6 2 5
2 4 1 3 2 2 6 2 5 1 4 7 3
3 3 2 4 1 3 4 7 3 6 2 5 1
4 1 4 2 3 4 2 5 1 4 7 3 6
5 7 3 6 2 5 1 4
6 5 1 4 7 3 6 2
7 3 6 2 5 1 4 7

Ex.3
· 1 2 3 4 * 1 2 3
1 1 2 4 3 1 1 2 3
2 2 3 1 4 2 3 1 2
3 4 1 3 2 3 2 3 1
4 3 4 2 1

Ex.4
· 1 2 3 * 1 2 3 4
1 1 2 3 1 1 4 2 3
2 2 3 1 2 3 2 4 1
3 3 1 2 3 4 1 3 2
4 2 3 1 4

Ex.5
· 1 2 3 4 5 6 7 * 1 2 3
1 1 4 7 3 6 2 5 1 1 2 3
2 6 2 5 1 4 7 3 2 3 1 2
3 4 7 3 6 2 5 1 3 2 3 1
21
4 2 5 1 4 7 3 6
5 7 3 6 2 5 1 4
6 5 1 4 7 3 6 2
7 3 6 2 5 1 4 7

Ex.6
· 1 2 3 4 * 1 2 3 4
1 4 3 2 1 1 1 2 3 4
2 3 4 1 2 2 2 3 4 1
3 2 1 4 3 3 3 4 1 2
4 1 2 3 4 4 4 1 2 3

Ex.7
· 1 2 3 4 * 1 2 3 4
1 1 2 4 3 1 2 1 3 4
2 3 4 2 1 2 3 4 2 1
3 2 1 3 4 3 4 3 1 2
4 4 3 1 2 4 1 2 4 3

Ex.8
· 1 2 3 4 * 1 2 3 4
1 2 3 4 1 1 4 3 2 1
2 3 2 1 4 2 3 4 1 2
3 4 1 2 3 3 2 1 4 3
4 1 4 3 2 4 1 2 3 4

Elaborarea programului:
Program produs_cartezian;
uses crt;
type masiv=array[1..15,1..15] of integer;
var a,b,rez,t1,p1,gr:masiv;
c,f:array[1..100] of integer;
r1,d1,d2,r,d,r2,n,m,t,i,j,k,p,l:integer;
Procedure asociativ(gr:masiv);
var l:integer;
begin
l:=0;
for i:=1 to n do
for j:=1 to n do
for k:=1 to n do begin
d:=gr[j,k];
22
d1:=gr[i,j];
if gr[i,d]<>gr[d1,k] then inc(l);
end;
if l=0 then writeln('Este asociativ')
else writeln('Nu este asociativ ' ) ;
end;

Procedure medial(gr:masiv);
var l:integer;
begin
l:=0;
for i:=1 to n do
for j:=1 to n do
for k:=1 to n do
for t:=1 to n do begin
d:=gr[i,j];
r:=gr[k,t];
d1:=gr[i,k];
r1:=gr[j,t];
if gr[d,r]<>gr[d1,r1] then inc (l);
end;
if l=0 then writeln('Este medial')
else writeln('Nu este medial');
end;

Procedure paramedial(gr:masiv);
var l:integer;
begin
l:=0;
for i:=1 to n do
for j:=1 to n do
for k:=1 to n do
for t:=1 to n do begin
d:=gr[i,j];
r:=gr[k,t];
d1:=gr[t,j];
r1:=gr[k,i];
if gr[d,r]<>gr[d1,r1] then inc(l);
end;
if l=0 then writeln('Este paramedial ')
else writeln('Nu este paramedial');
end;
23
Procedure bicomutativ(gr:masiv);
var l:integer;
begin
l:=0;
for i:=1 to n do
for j:=1 to n do
for k:=1 to n do
for t:=1 to n do begin
d:=gr[i,j];
r:=gr[k,t] ;
d1:=gr[t,k] ;
r1:=gr[j,i];
if gr[d,r]<>gr[d1,r1] then inc (l);
end;
if l=0 then writeln('Este bicomutativ')
else writeln('Nu este bicomutativ');
end;

Procedure ag_gr(gr:masiv);
var l:integer;
begin
l:=0;
for i:=1 to n do
for j:=1 to n do
for k:=1 to n do begin
d:=gr[i,j];
d1:=gr[k,j];
if gr[d,k]<>gr[d1,i] then inc(l);
end;
if l=0 then writeln('Este AG grupoid')
else writeln('Nu este AG grupoid');
end;

Procedure ga_gr(gr:masiv);
var l:integer;
begin
l:=0;
for i:=1 to n do
for j:=1 to n do
for k:=1 to n do begin
d:=gr[i,j];
24
d1:=gr[j,i];
if gr[d,k]<>gr[k,d1] then inc(l);
end;
if l=0 then writeln('Este GA grupoid')
else writeln('Nu este GA grupoid');
end;

Procedure ga_gr1(gr:masiv);
var l:integer;
begin
l:=0;
for i:=1 to n do
for j:=1 to n do
for k:=1 to n do begin
d:=gr[i,j];
d1:=gr[k,i];
if gr[d,k]<>gr[d1,j] then inc(l);
end;
if l=0 then writeln('Este GA1 grupoid')
else writeln('Nu este GA1 grupoid');
end;

Procedure ad_gr(gr:masiv);
var l:integer;
begin
l:=0;
for i:=1 to n do
for j:=1 to n do
for k:=1 to n do begin
d:=gr[j,k];
d1:=gr[j,i];
if gr[i,d]<>gr[k,d1] then inc (l);
end;
if l=0 then writeln('Este AD grupoid')
else writeln('Nu este AD grupoid' );
end;

Procedure da_gr(gr:masiv);
var l:integer;
begin
l:=0;
for i:=1 to n do
25
for j:=1 to n do
for k:=1 to n do begin
d:=gr[j,k];
d1:=gr[i,j];
if gr[i,d]<>gr[k,d1] then inc(l);
end;
if l=0 then writeln('Este DA grupoid')
else writeln('Nu este DA grupoid');
end;

Procedure hexagonal(gr:masiv);
var l:integer;
begin
l:=0;
for i:=1 to n do
for j:=1 to n do
for k:=1 to n do
for t:=1 to n do begin
d:=gr[i,j];
r:=gr[k,t];
d1:=gr[i,k];
r1:=gr[j,t];
r2:=gr[j,i];
if (gr[i,i]<>i)or(gr[d,r]<>gr[d1,r1])
or(gr[i,r2]<>gr[d,i]) and(gr[d,i]<>j)then inc(l);
end;
if l=0 then writeln('Este hexagonal')
else writeln('Nu este hexagonal ');
end;

Procedure dist_dr(gr:masiv);
var l:integer;
begin
l:=0;
for i:=1 to n do
for j:=1 to n do
for k:=1 to n do begin
d:=gr[i,j];
d1:=gr[i,k];
r1:=gr[j,k];
if gr[d,k]<>gr[d1,r1] then inc(l);
end;
26
if l=0 then writeln('Este distributiv la dreapta')
else writeln('Nu este distributiv la dreapta');
end;

Procedure dist_st(gr:masiv);
var l:integer;
begin
l:=0;
for i:=1 to n do
for j:=1 to n do
for k:=1 to n do begin
d:=gr[i,j];
d1:=gr[k,i];
r1:=gr[k,j];
if gr[k,d]<>gr[d1,r1] then inc(l);
end;
if l=0 then writeln('Este distributiv la stinga')
else writeln ('Nu este distributiv la stinga');
end;

Procedure unitate_dreapta(gr:masiv);
var l:integer;
begin
j:=0;
r:=0;
for i:=1 to n do begin
l:=0;
inc(j);
if gr[j,i]=i then begin
for k:=1 to n do begin
if gr[k,j]=k then inc(l);
if l=n then r:=j;
end; end; end;
if r<>0 then writeln('Este unitate de dreapta ',r)
else writeln('Nu este unitate de dreapta');
end;

Procedure unitate_stanga(gr:masiv);
var l:integer;
begin
j:=0; r2:=0;
for i:=1 to n do begin
27
l:=0;
inc(j);
if gr[i,j]=i then begin
for k:=1 to n do begin
if gr[j,k]=k then inc(l);
if l=n then r2:=j;
end; end; end;
if r2<>0 then writeln('Este unitate de stanga ', r2)
else writeln('Nu este unitate de stanga ');
end;

Procedure unitate;
begin
if (r=r2) and (r>0) then writeln('Este unitate ',r)
else writeln('Nu este unitate');
end;

Procedure afisare;
begin
for i:=1 to n do begin
writeln;
for j:=1 to n do begin
write(a[i,j],' ');
end; end; end;

Procedure prod_cartezian(var s:masiv);


begin k:=1;
for i:=1 to n do
for j:=1 to m do begin
c[k]:=i;
t1[i,j]:=k;
f[k]:=j; k:=k+1;
end;
for i:=1 to n*m do
for j:=1 to n*m do
s[i,j]:=t1[a[c[i],c[j]],b[f[i],f[j]]];
end;

Procedure ward(gr: masiv);


var i,j,k:integer;
begin
l:=0;
28
for i:=1 to n do
for j:=1 to n do
for k:=1 to n do
begin
d:=gr[i,j]; d1:=gr[i,k]; d2:=gr[j,k];
if d<>gr[d1,d2] then l:=l+1;
end;
if l=0 then writeln('Este Ward')
else writeln('Nu este Ward');
end;

Procedure ward_inv(gr: masiv);


var i,j,k:integer;
begin
l:=0;
for i:=1 to n do
for j:=1 to n do
for k:=1 to n do
begin
d:=gr[i,j]; d1:=gr[k,i]; d2:=gr[k,j];
if d<>gr[d1,d2] then l:=l+1;
end;
if l=0 then writeln('Este Ward invers')
else writeln('Nu este Ward invers');
end;

Begin
clrscr;
writeln('Dati n= '); readln(n);
writeln('Dati m= '); readln(m);
for i:=1 to n do
for j:=1 to n do begin
write ('a [', i,',' , j, '] = ');
readln(a[i,j]);
end;
for i:=1 to m do
for j:=1 to m do begin
write('b[',i,',',j,'] = ');
readln(b[i,j]);
end;
afisare;
writeln;
29
prod_cartezian(rez);
for i:=1 to n*m do begin
for j:=1 to n*m do begin
write(rez[i,j],' ');
end;
writeln;
end;
asociativ(rez);
medial(rez);
paramedial(rez);
bicomutativ(rez);
ag_gr(rez);
ga_gr(rez);
ga_gr1(rez);
ad_gr(rez);
da_gr(rez);
hexagonal(rez);
dist_dr(rez);
dist_st(rez);
unitate_dreapta(rez);
unitate_stanga(rez);
unitate;
ward(rez);
ward_inv(rez);
readkey;
End.

În urma compilarii sau obținut următoarele rezultate:

30
Ex. 1

Ex. 2
2314
4132
3241
1423
8 11 14 10 13 9 12 15 18 21 17 20 16 19 1 4 7 3 6 2 5 22 25 28 24 27 23 26
13 9 12 8 11 14 10 20 16 19 15 18 21 17 6 2 5 1 4 7 3 27 23 26 22 25 28 24
11 14 10 13 9 12 8 18 21 17 20 16 19 15 4 7 3 6 2 5 1 25 28 24 27 23 26 22
9 12 8 11 14 10 13 16 19 15 18 21 17 20 2 5 1 4 7 3 6 23 26 22 25 28 24 27
14 10 13 9 12 8 11 21 17 20 16 19 15 18 7 3 6 2 5 1 4 28 24 27 23 26 22 25
12 8 11 14 10 13 9 19 15 18 21 17 20 16 5 1 4 7 3 6 2 26 22 25 28 24 27 23
10 13 9 12 8 11 14 17 20 16 19 15 18 21 3 6 2 5 1 4 7 24 27 23 26 22 25 28
22 25 28 24 27 23 26 1 4 7 3 6 2 5 15 18 21 17 20 16 19 8 11 14 10 13 9 12
27 23 26 22 25 28 24 6 2 5 1 4 7 3 20 16 19 15 18 21 17 13 9 12 8 11 14 10
25 28 24 27 23 26 22 4 7 3 6 2 5 1 18 21 17 20 16 19 15 11 14 10 13 9 12 8
23 26 22 25 28 24 27 2 5 1 4 7 3 6 16 19 15 18 21 17 20 9 12 8 11 14 10 13
28 24 27 23 26 22 25 7 3 6 2 5 1 4 21 17 20 16 19 15 18 14 10 13 9 12 8 11
26 22 25 28 24 27 23 5 1 4 7 3 6 2 19 15 18 21 17 20 16 12 8 11 14 10 13 9
24 27 23 26 22 25 28 3 6 2 5 1 4 7 17 20 16 19 15 18 21 10 13 9 12 8 11 14
15 18 21 17 20 16 19 8 11 14 10 13 9 12 22 25 28 24 27 23 26 1 4 7 3 6 2 5
20 16 19 15 18 21 17 13 9 12 8 11 14 10 27 23 26 22 25 28 24 6 2 5 1 4 7 3
18 21 17 20 16 19 15 11 14 10 13 9 12 8 25 28 24 27 23 26 22 4 7 3 6 2 5 1
16 19 15 18 21 17 20 9 12 8 11 14 10 13 23 26 22 25 28 24 27 2 5 1 4 7 3 6
21 17 20 16 19 15 18 14 10 13 9 12 8 11 28 24 27 23 26 22 25 7 3 6 2 5 1 4
19 15 18 21 17 20 16 12 8 11 14 10 13 9 26 22 25 28 24 27 23 5 1 4 7 3 6 2
17 20 16 19 15 18 21 10 13 9 12 8 11 14 24 27 23 26 22 25 28 3 6 2 5 1 4 7
1 4 7 3 6 2 5 22 25 28 24 27 23 26 8 11 14 10 13 9 12 15 18 21 17 20 16 19
6 2 5 1 4 7 3 27 23 26 22 25 28 24 13 9 12 8 11 14 10 20 16 19 15 18 21 17
4 7 3 6 2 5 1 25 28 24 27 23 26 22 11 14 10 13 9 12 8 18 21 17 20 16 19 15
2 5 1 4 7 3 6 23 26 22 25 28 24 27 9 12 8 11 14 10 13 16 19 15 18 21 17 20
7 3 6 2 5 1 4 28 24 27 23 26 22 25 14 10 13 9 12 8 11 21 17 20 16 19 15 18
5 1 4 7 3 6 2 26 22 25 28 24 27 23 12 8 11 14 10 13 9 19 15 18 21 17 20 16
3 6 2 5 1 4 7 24 27 23 26 22 25 28 10 13 9 12 8 11 14 17 20 16 19 15 18 21
Nu este asociativ
Este medial
Nu este paramedial
Nu este bicomutativ
Nu este AG grupoid
31
Nu este GA grupoid
Nu este GA1 grupoid
Nu este AD grupoid
Nu este DA grupoid
Nu este hexagonal
Nu este distributiv la dreapta
Nu este distributiv la stinga
Nu este unitate de dreapta
Nu este unitate de stanga
Nu este unitate
Nu este Ward
Nu este Ward invers

Ex. 3 Ex.4

Ex. 5
1473625
6251473
4736251
2514736
7362514
5147362
3625147
1 2 3 10 11 12 19 20 21 7 8 9 16 17 18 4 5 6 13 14 15
3 1 2 12 10 11 21 19 20 9 7 8 18 16 17 6 4 5 15 13 14
2 3 1 11 12 10 20 21 19 8 9 7 17 18 16 5 6 4 14 15 13
16 17 18 4 5 6 13 14 15 1 2 3 10 11 12 19 20 21 7 8 9
18 16 17 6 4 5 15 13 14 3 1 2 12 10 11 21 19 20 9 7 8
17 18 16 5 6 4 14 15 13 2 3 1 11 12 10 20 21 19 8 9 7

32
10 11 12 19 20 21 7 8 9 16 17 18 4 5 6 13 14 15 1 2 3
12 10 11 21 19 20 9 7 8 18 16 17 6 4 5 15 13 14 3 1 2
11 12 10 20 21 19 8 9 7 17 18 16 5 6 4 14 15 13 2 3 1
4 5 6 13 14 15 1 2 3 10 11 12 19 20 21 7 8 9 16 17 18
6 4 5 15 13 14 3 1 2 12 10 11 21 19 20 9 7 8 18 16 17
5 6 4 14 15 13 2 3 1 11 12 10 20 21 19 8 9 7 17 18 16
19 20 21 7 8 9 16 17 18 4 5 6 13 14 15 1 2 3 10 11 12
21 19 20 9 7 8 18 16 17 6 4 5 15 13 14 3 1 2 12 10 11
20 21 19 8 9 7 17 18 16 5 6 4 14 15 13 2 3 1 11 12 10
13 14 15 1 2 3 10 11 12 19 20 21 7 8 9 16 17 18 4 5 6
15 13 14 3 1 2 12 10 11 21 19 20 9 7 8 18 16 17 6 4 5
14 15 13 2 3 1 11 12 10 20 21 19 8 9 7 17 18 16 5 6 4
7 8 9 16 17 18 4 5 6 13 14 15 1 2 3 10 11 12 19 20 21
9 7 8 18 16 17 6 4 5 15 13 14 3 1 2 12 10 11 21 19 20
8 9 7 17 18 16 5 6 4 14 15 13 2 3 1 11 12 10 20 21 19
Nu este asociativ
Este medial
Nu este paramedial
Nu este bicomutativ
Nu este AG grupoid
Nu este GA grupoid
Nu este GA1 grupoid
Nu este AD grupoid
Nu este DA grupoid
Nu este hexagonal
Nu este distributiv la dreapta
Nu este distributiv la stinga
Nu este unitate de dreapta
Nu este unitate de stanga
Nu este unitate
Nu este Ward
Nu este Ward invers

33
Ex.6
Ex.7

34
Ex.8

Tabelul proprietăților grupoizilor verificați:

Ex.1 Ex.2 Ex.3 Ex.4 Ex.5 Ex.6 Ex.7 Ex.8


Asociativ - - - - - + - +
Medial + + - + + + - +
Paramedial + - - - - + + +
Bicomutativ + - + - - + - +
AG grupoid + - - + - + - +
GA grupoid - - - - - + - +
GA1 grupoid - - - - - + - +
AD grupoid - - - + - + - +
DA grupoid - - - - - + - +
Hexagonal - - - + - - - -
Distributivladreapta - - - + - - - -
Distributivlastânga - - - + - - - -
Unitatededreapta - - - - - - - -
Unitatedestânga 1 - 1 - - - - -
Unitate - - - - - - - -
Ward - - - - - - - +
Wardinvers + - - - - - - +

35
Algoritmi de realizare a produsului direct special
dintre doi grupoizi

Problemă. Se dă grupul(𝑄, +), se cere de elaborat un algoritm care realizează


produsul direct special(𝑄, +) × (𝑄, +), conform următoarelor legi:

Legea 1
(𝑥1 , 𝑦1 ) × (𝑥2 , 𝑦2 ) = (𝑥1 + 𝑦1 − 𝑦2 , 𝑥2 + 𝑦2 − 𝑥1 ), ∀𝑥1 , 𝑦1 , 𝑥2 , 𝑦2 ) ∈ 𝑄;

Legea 2
(𝑥1 , 𝑦1 ) × (𝑥2 , 𝑦2 ) = (𝑥1 + 𝑦1 − 𝑦2 , 𝑥2 + 𝑦2 − 𝑦1 ), ∀𝑥1 , 𝑦1 , 𝑥2 , 𝑦2 ) ∈ 𝑄.

Pentru fiecare din exemplele de mai jos să se realizeze (𝑄, +) × (𝑄, +)


Ex.1 Ex.2 Ex.3
+ 1 2 3 + 1 2 + 1 2 3 4
1 1 2 3 1 1 2 1 1 2 3 4
2 2 3 1 2 2 1 2 2 3 4 1
3 3 1 2 3 3 4 1 2
4 4 1 2 3

Ex.4 Ex.5
+ 1 2 3 4 + 1 2 3
1 1 2 3 4 1 1 2 3
2 2 1 4 3 2 3 1 2
3 3 4 1 2 3 2 3 1
4 4 3 2 3

Elaborarea programului:
Program prblm4;
uses crt;
type masiv=array[1..50,1..50] of integer;
var gr1,gr2,opus,a,tabel,gr:masiv;
r1,d1,r,d,r2,n,m,t,i,j,k,p,l,d2:integer;
i2,k2,k1:integer;
Procedure asociativ(gr:masiv);
var l:integer;
begin
l:=0;
for i:=1 to n do
for j:=1 to n do

36
for k:=1 to n do begin
d:=gr[j,k];
d1:=gr[i,j];
if gr[i,d]<>gr[d1,k] then inc(l);
end;
if l=0 then writeln('Este asociativ')
else writeln('Nu este asociativ ' ) ;
end;

Procedure medial(gr:masiv);
var l:integer;
begin
l:=0;
for i:=1 to n do
for j:=1 to n do
for k:=1 to n do
for t:=1 to n do begin
d:=gr[i,j];
r:=gr[k,t];
d1:=gr[i,k];
r1:=gr[j,t];
if gr[d,r]<>gr[d1,r1] then inc (l);
end;
if l=0 then writeln('Este medial')
else writeln('Nu este medial');
end;

Procedure paramedial(gr:masiv);
var l:integer;
begin
l:=0;
for i:=1 to n do
for j:=1 to n do
for k:=1 to n do
for t:=1 to n do begin
d:=gr[i,j];
r:=gr[k,t];
d1:=gr[t,j];
r1:=gr[k,i];
if gr[d,r]<>gr[d1,r1] then inc(l);
end;
if l=0 then writeln('Este paramedial ')

37
else writeln('Nu este paramedial');
end;

Procedure bicomutativ(gr:masiv);
var l:integer;
begin
l:=0;
for i:=1 to n do
for j:=1 to n do
for k:=1 to n do
for t:=1 to n do begin
d:=gr[i,j];
r:=gr[k,t] ;
d1:=gr[t,k] ;
r1:=gr[j,i];
if gr[d,r]<>gr[d1,r1] then inc (l);
end;
if l=0 then writeln('Este bicomutativ')
else writeln('Nu este bicomutativ');
end;

Procedure ag_gr(gr:masiv);
var l:integer;
begin
l:=0;
for i:=1 to n do
for j:=1 to n do
for k:=1 to n do begin
d:=gr[i,j];
d1:=gr[k,j];
if gr[d,k]<>gr[d1,i] then inc(l);
end;
if l=0 then writeln('Este AG grupoid')
else writeln('Nu este AG grupoid');
end;

Procedure ga_gr(gr:masiv);
var l:integer;
begin
l:=0;
for i:=1 to n do
for j:=1 to n do

38
for k:=1 to n do begin
d:=gr[i,j];
d1:=gr[j,i];
if gr[d,k]<>gr[k,d1] then inc(l);
end;
if l=0 then writeln('Este GA grupoid')
else writeln('Nu este GA grupoid');
end;

Procedure ga_gr1(gr:masiv);
var l:integer;
begin
l:=0;
for i:=1 to n do
for j:=1 to n do
for k:=1 to n do begin
d:=gr[i,j];
d1:=gr[k,i];
if gr[d,k]<>gr[d1,j] then inc(l);
end;
if l=0 then writeln('Este GA1 grupoid')
else writeln('Nu este GA1 grupoid');
end;

Procedure ad_gr(gr:masiv);
var l:integer;
begin
l:=0;
for i:=1 to n do
for j:=1 to n do
for k:=1 to n do begin
d:=gr[j,k];
d1:=gr[j,i];
if gr[i,d]<>gr[k,d1] then inc (l);
end;
if l=0 then writeln('Este AD grupoid')
else writeln('Nu este AD grupoid' );
end;

Procedure da_gr(gr:masiv);
var l:integer;
begin

39
l:=0;
for i:=1 to n do
for j:=1 to n do
for k:=1 to n do begin
d:=gr[j,k];
d1:=gr[i,j];
if gr[i,d]<>gr[k,d1] then inc(l);
end;
if l=0 then writeln('Este DA grupoid')
else writeln('Nu este DA grupoid');
end;

Procedure hexagonal(gr:masiv);
var l:integer;
begin
l:=0;
for i:=1 to n do
for j:=1 to n do
for k:=1 to n do
for t:=1 to n do begin
d:=gr[i,j];
r:=gr[k,t];
d1:=gr[i,k];
r1:=gr[j,t];
r2:=gr[j,i];
if (gr[i,i]<>i)or(gr[d,r]<>gr[d1,r1])
or(gr[i,r2]<>gr[d,i]) and(gr[d,i]<>j)then inc(l);
end;
if l=0 then writeln('Este hexagonal')
else writeln('Nu este hexagonal ');
end;

Procedure dist_dr(gr:masiv);
var l:integer;
begin
l:=0;
for i:=1 to n do
for j:=1 to n do
for k:=1 to n do begin
d:=gr[i,j];
d1:=gr[i,k];
r1:=gr[j,k];

40
if gr[d,k]<>gr[d1,r1] then inc(l);
end;
if l=0 then writeln('Este distributiv la dreapta')
else writeln('Nu este distributiv la dreapta');
end;

Procedure dist_st(gr:masiv);
var l:integer;
begin
l:=0;
for i:=1 to n do
for j:=1 to n do
for k:=1 to n do begin
d:=gr[i,j];
d1:=gr[k,i];
r1:=gr[k,j];
if gr[k,d]<>gr[d1,r1] then inc(l);
end;
if l=0 then writeln('Este distributiv la stinga')
else writeln ('Nu este distributiv la stinga');
end;

Procedure unitate_dreapta(gr:masiv);
var l:integer;
begin
j:=0;
r:=0;
for i:=1 to n do begin
l:=0;
inc(j);
if gr[j,i]=i then begin
for k:=1 to n do begin
if gr[k,j]=k then inc(l);
if l=n then r:=j;
end; end; end;
if r<>0 then writeln('Este unitate de dreapta ',r)
else writeln('Nu este unitate de dreapta');
end;

Procedure unitate_stanga(gr:masiv);
var l:integer;
begin

41
j:=0; r2:=0;
for i:=1 to n do begin
l:=0;
inc(j);
if gr[i,j]=i then begin
for k:=1 to n do begin
if gr[j,k]=k then inc(l);
if l=n then r2:=j;
end; end; end;
if r2<>0 then writeln('Este unitate de stanga ', r2)
else writeln('Nu este unitate de stanga ');
end;

Procedure unitate;
begin
if (r=r2) and (r>0) then writeln('Este unitate ',r)
else writeln('Nu este unitate');
end;

Procedure Topus(n:integer);
var i,j,element,k:integer;
begin
for i:=1 to n do
for j:=1 to n do begin
write ('a [', i,',' , j, '] = ');
readln(element);
gr[i,j]:=element;
if (element=1) then opus[i,1]:=j;
end;
k:=1;
for i:=1 to n do
for j:=1 to n do begin
tabel[i,j]:=k; k:=k+1;
end; end;

Procedure pr_cartezian(gr:masiv);
var i,j,k1,k2,i1,j2:integer;
begin
k1:=0;
for i:=1 to n do
for j:=1 to n do begin
k1:=k1+1;

42
k2:=0;
for i2:=1 to n do
for j2:=1 to n do begin
k2:=k2+1;
gr2[k1,k2]:=tabel[gr[gr[i,j],opus[j2,1]],gr[gr[i2,j2],opus[i,1]]];
{gr2[k1,k2]:=tabel[gr[gr[i,j],opus[j2,1]],gr[gr[i2,j2],opus[j,1]]];} //legea2
end; end; end;

Procedure afisare_pr(gr2:masiv);
var a,i,j:integer;
begin
for i:=1 to n*n do begin
for j:=1 to n*n do
write(gr2[i,j]:4);
writeln;
end; end;
Procedure ward(gr: masiv);
var i,j,k:integer;
begin
l:=0;
for i:=1 to n do
for j:=1 to n do
for k:=1 to n do
begin
d:=gr[i,j]; d1:=gr[i,k]; d2:=gr[j,k];
if d<>gr[d1,d2] then l:=l+1;
end;
if l=0 then writeln('Este Ward')
else writeln('Nu este Ward');
end;

Procedure ward_inv(gr: masiv);


var i,j,k:integer;
begin
l:=0;
for i:=1 to n do
for j:=1 to n do
for k:=1 to n do
begin
d:=gr[i,j]; d1:=gr[k,i]; d2:=gr[k,j];
if d<>gr[d1,d2] then l:=l+1;
end;

43
if l=0 then writeln('Este Ward invers')
else writeln('Nu este Ward invers');
end;

Begin
clrscr;
writeln('Dati n=');
readln(n);
Topus(n);
pr_cartezian(gr);
writeln('Produsul');
afisare_pr(gr2);
asociativ(gr2);
medial(gr2);
paramedial(gr2);
bicomutativ (gr2);
ag_gr(gr2);
ga_gr(gr2);
ga_gr1(gr2);
ad_gr(gr2);
da_gr(gr2);
hexagonal(gr2);
dist_dr(gr2);
dist_st(gr2);
unitate_dreapta(gr2);
unitate_stanga(gr2);
unitate;
ward(gr2);
ward_inv(gr2);
readkey;
End.

44
Rezultatele obținute în urma compilării conform legii 1:

Ex.1

Ex.2

45
Ex.3

46
Ex.4

Ex.5

47
Rezultatele obținute în urma compilării conform legii 2:

Ex. 1

Ex. 2

48
Ex. 3

Ex. 4

49
Ex. 5

50
Tabelul rezultatelor obținute:
Legea 1 Legea 2
Ex.1 Ex.2 Ex.3 Ex.4 Ex.5 Ex.1 Ex.2 Ex.3 Ex.4 Ex.5
Asociativ - - - - - - - - - -
Medial + + + + - - - - - -
Paramedial - - - - + - - - - -
Bicomutativ - - - - - - - - - -
AG grupoid - + - + - - - - - -
GA grupoid - - - - - - - - - -
GA1 grupoid - - - - - - - - - -
AD grupoid - + - + - - - - - -
DA grupoid - - - - - - - - - -
Hexagonal + + + + - - - - - -
Distributivladreapta + + + + - - - - - -
Distributivlastânga + + + + - - - - - -
Unitatededreapta - - - - - - - - - -
Unitatedestânga - - - - - - - - - -
Unitate - - - - - - - - - -
Ward - - - - - - - - - -
Wardinvers - - - - - - - - - -

51
Algoritmi pentru identificarea unităților multiple

Problema.Fie (𝐺,∙) – grupoid. Se cere de elaborat un program care identifică (n,


m) – unitatea în grupoidul respectiv. Să se testeze proprietățile algebrice.

Elementul e, 𝑒 ∈ 𝐺 se numește (n, m) – unitate dacă se îndeplinesc următoarele


condții:

1. e*e=1

2. n(e, x)=x, pentru orice 𝒙 ∈ (𝑮,∙)

3. (x, e)m=x, pentru orice 𝒙 ∈ (𝑮,∙)

Pentru fiecare din exemple, să se determine (n,m)-unitățile.


Ex.1 Ex.2 Ex.3
· 1 2 3 · 1 2 3 4 · 1 2 3 4 5
1 1 2 3 1 1 2 4 3 1 1 5 4 3 2
2 3 1 2 2 3 4 2 1 2 3 2 1 5 4
3 2 3 1 3 4 1 3 2 3 5 4 3 2 1
4 2 3 1 4 4 2 1 5 4 3
5 4 3 2 1 5
Ex.4 Ex.5
· 1 2 3 4 · 1 2 3 4 5
1 1 2 4 3 1 1 3 2 5 4
2 2 1 3 4 2 3 4 1 2 5
3 3 4 1 2 3 2 1 5 4 3
4 4 3 2 1 4 5 2 4 3 1
5 4 5 3 1 2

Ex.6 Ex.7
· 1 2 3 4 5 · 1 2 3 4
1 1 3 2 5 4 1 1 2 3 4
2 4 2 5 1 3 2 2 1 4 3
3 5 4 3 2 1 3 4 3 1 2
4 3 5 1 4 2 4 3 4 2 1
5 2 1 4 3 5

52
Elaborarea programului:
Program unitate_multipla;
uses crt;
label y;
type masiv=array[1..20,1..20] of byte;
var {i,j,n,}l:byte;
s:boolean;
a,gr:masiv;
c,b:array[1..20] of 0..20;
r1,d1,r,d,r2,n,t,i,j,k,p,d2:integer;

Procedure asociativ(gr:masiv);
var l:integer;
begin
l:=0;
for i:=1 to n do
for j:=1 to n do
for k:=1 to n do begin
d:=gr[j,k];
d1:=gr[i,j];
if gr[i,d]<>gr[d1,k] then inc(l);
end;
if l=0 then writeln('Este asociativ')
else writeln('Nu este asociativ ' ) ;
end;

Procedure medial(gr:masiv);
var l:integer;
begin
l:=0;
for i:=1 to n do
for j:=1 to n do
for k:=1 to n do
for t:=1 to n do begin
d:=gr[i,j];
r:=gr[k,t];
d1:=gr[i,k];
r1:=gr[j,t];
if gr[d,r]<>gr[d1,r1] then inc (l);
end;
if l=0 then writeln('Este medial')

53
else writeln('Nu este medial');
end;

Procedure paramedial(gr:masiv);
var l:integer;
begin
l:=0;
for i:=1 to n do
for j:=1 to n do
for k:=1 to n do
for t:=1 to n do begin
d:=gr[i,j];
r:=gr[k,t];
d1:=gr[t,j];
r1:=gr[k,i];
if gr[d,r]<>gr[d1,r1] then inc(l);
end;
if l=0 then writeln('Este paramedial ')
else writeln('Nu este paramedial');
end;

Procedure bicomutativ(gr:masiv);
var l:integer;
begin
l:=0;
for i:=1 to n do
for j:=1 to n do
for k:=1 to n do
for t:=1 to n do begin
d:=gr[i,j];
r:=gr[k,t] ;
d1:=gr[t,k] ;
r1:=gr[j,i];
if gr[d,r]<>gr[d1,r1] then inc (l);
end;
if l=0 then writeln('Este bicomutativ')
else writeln('Nu este bicomutativ');
end;

Procedure ag_gr(gr:masiv);
var l:integer;
begin

54
l:=0;
for i:=1 to n do
for j:=1 to n do
for k:=1 to n do begin
d:=gr[i,j];
d1:=gr[k,j];
if gr[d,k]<>gr[d1,i] then inc(l);
end;
if l=0 then writeln('Este AG grupoid')
else writeln('Nu este AG grupoid');
end;

Procedure ga_gr(gr:masiv);
var l:integer;
begin
l:=0;
for i:=1 to n do
for j:=1 to n do
for k:=1 to n do begin
d:=gr[i,j];
d1:=gr[j,i];
if gr[d,k]<>gr[k,d1] then inc(l);
end;
if l=0 then writeln('Este GA grupoid')
else writeln('Nu este GA grupoid');
end;

Procedure ga_gr1(gr:masiv);
var l:integer;
begin
l:=0;
for i:=1 to n do
for j:=1 to n do
for k:=1 to n do begin
d:=gr[i,j];
d1:=gr[k,i];
if gr[d,k]<>gr[d1,j] then inc(l);
end;
if l=0 then writeln('Este GA1 grupoid')
else writeln('Nu este GA1 grupoid');
end;

55
Procedure ad_gr(gr:masiv);
var l:integer;
begin
l:=0;
for i:=1 to n do
for j:=1 to n do
for k:=1 to n do begin
d:=gr[j,k];
d1:=gr[j,i];
if gr[i,d]<>gr[k,d1] then inc (l);
end;
if l=0 then writeln('Este AD grupoid')
else writeln('Nu este AD grupoid' );
end;

Procedure da_gr(gr:masiv);
var l:integer;
begin
l:=0;
for i:=1 to n do
for j:=1 to n do
for k:=1 to n do begin
d:=gr[j,k];
d1:=gr[i,j];
if gr[i,d]<>gr[k,d1] then inc(l);
end;
if l=0 then writeln('Este DA grupoid')
else writeln('Nu este DA grupoid');
end;

Procedure hexagonal(gr:masiv);
var l:integer;
begin
l:=0;
for i:=1 to n do
for j:=1 to n do
for k:=1 to n do
for t:=1 to n do begin
d:=gr[i,j];
r:=gr[k,t];
d1:=gr[i,k];
r1:=gr[j,t];

56
r2:=gr[j,i];
if (gr[i,i]<>i)or(gr[d,r]<>gr[d1,r1])
or(gr[i,r2]<>gr[d,i]) and(gr[d,i]<>j)then inc(l);
end;
if l=0 then writeln('Este hexagonal')
else writeln('Nu este hexagonal ');
end;

Procedure dist_dr(gr:masiv);
var l:integer;
begin
l:=0;
for i:=1 to n do
for j:=1 to n do
for k:=1 to n do begin
d:=gr[i,j];
d1:=gr[i,k];
r1:=gr[j,k];
if gr[d,k]<>gr[d1,r1] then inc(l);
end;
if l=0 then writeln('Este distributiv la dreapta')
else writeln('Nu este distributiv la dreapta');
end;

Procedure dist_st(gr:masiv);
var l:integer;
begin
l:=0;
for i:=1 to n do
for j:=1 to n do
for k:=1 to n do begin
d:=gr[i,j];
d1:=gr[k,i];
r1:=gr[k,j];
if gr[k,d]<>gr[d1,r1] then inc(l);
end;
if l=0 then writeln('Este distributiv la stinga')
else writeln ('Nu este distributiv la stinga');
end;

Procedure unitate_dreapta(gr:masiv);
var l:integer;

57
begin
j:=0;
r:=0;
for i:=1 to n do begin
l:=0;
inc(j);
if gr[j,i]=i then begin
for k:=1 to n do begin
if gr[k,j]=k then inc(l);
if l=n then r:=j;
end; end; end;
if r<>0 then writeln('Este unitate de dreapta ',r)
else writeln('Nu este unitate de dreapta');
end;

Procedure unitate_stanga(gr:masiv);
var l:integer;
begin
j:=0; r2:=0;
for i:=1 to n do begin
l:=0;
inc(j);
if gr[i,j]=i then begin
for k:=1 to n do begin
if gr[j,k]=k then inc(l);
if l=n then r2:=j;
end; end; end;
if r2<>0 then writeln('Este unitate de stanga ', r2)
else writeln('Nu este unitate de stanga ');
end;

Procedure unitate;
begin
if (r=r2) and (r>0) then writeln('Este unitate ',r)
else writeln('Nu este unitate');
end;

Procedure afisare;
begin
for i:=1 to n do begin
writeln;
for j:=1 to n do begin

58
write(a[i,j],' ');
end; end; end;

Function mm(g:byte):byte;
var ii,jj,k,x,q:byte;
begin
for jj:=1 to n do begin
k:=0;
x:=jj;
repeat begin
x:=a[x,g];
inc(k);
end;
until(x=jj)or(k>n);
if k>n then b[jj]:=0
else b[jj]:=k;
end;
q:=b[1];
for jj:=1 to n do
if b[jj]>q then q:=b[jj];
mm:=q;
end;

Function nn(gg:byte):byte;
var ii,jj,k,x,q:byte;
begin
for jj:=1 to n do begin
k:=0;
x:=jj;
repeat begin
x:=a[gg,x];
inc(k);
end;
until (x=jj)or(k>n+1);
if k>n then c[jj]:=0
else c[jj]:=k;
end;
q:=c[1] ;
for jj:=1 to n do
if c[jj]>q then q:=c[jj];
nn:=q;
end;

59
Procedure tipar(h:masiv);
var contor:integer;
begin
contor:=0;
write('a,(*);');
for i:=1 to n do begin
contor:=contor+3;
gotoxy(2+3*i,3);write('_');
gotoxy(4,i+3);write('|');
gotoxy(3+contor,3);write(i);
end;
for i:=1 to n do
for j:=1 to n do begin
gotoxy(3+3*j,3+i);writeln(h[i,j]);
end;end;
Procedure ward(gr: masiv);
var i,j,k:integer;
begin
l:=0;
for i:=1 to n do
for j:=1 to n do
for k:=1 to n do
begin
d:=gr[i,j]; d1:=gr[i,k]; d2:=gr[j,k];
if d<>gr[d1,d2] then l:=l+1;
end;
if l=0 then writeln('Este Ward')
else writeln('Nu este Ward');
end;

Procedure ward_inv(gr: masiv);


var i,j,k:integer;
begin
l:=0;
for i:=1 to n do
for j:=1 to n do
for k:=1 to n do
begin
d:=gr[i,j]; d1:=gr[k,i]; d2:=gr[k,j];
if d<>gr[d1,d2] then l:=l+1;
end;

60
if l=0 then writeln('Este Ward invers')
else writeln('Nu este Ward invers');
end;
Begin
y:clrscr;
write ('Dati n= ');
readln(n);
for i:=1 to n do begin
gotoxy(2+3*i,3);write('_');
gotoxy(4,i+3);write('|');
gotoxy(3+3*i,2);write(i);
gotoxy (3,3+i);write(i);
end;
for i:=1 to n do
for j:=1 to n do begin
gotoxy(3+3*j,3+i);
read(a[i,j]);
end;
for i:=1 to n do
for j:=1 to n do
for l:=1 to j-1 do
if a[i,j]=a[i,1] then goto y;
for i:=1 to n do
for j:=1 to n do
for l:=1 to j-1 do
if a[i,j]=a[i,l] then goto y;
clrscr;
tipar(a);
for i:=1 to n do
if ((a[i,i]=i) and (mm(i)<>0) and (nn(i)<>0)) then begin
writeln(i,'=E(',nn(i),',',mm(i),')');
end;
afisare;
writeln;
asociativ(a);
medial(a);
paramedial(a);
bicomutativ(a);
ag_gr(a);
ga_gr(a);
ga_gr1(a);
ad_gr(a);

61
da_gr(a);
hexagonal(a);
dist_dr(a);
dist_st(a);
unitate_dreapta(a);
unitate_stanga(a);
unitate;
ward(a);
ward_inv(a);
readkey;
End.

În urma compilării sau obținut următoarele rezultate:

Ex. 1

62
Ex. 2

Ex. 3

63
Ex. 4

Ex. 5

64
Ex. 6

Ex. 7

65
Tabelul proprietăților obținute :
Ex.1 Ex.2 Ex.3 Ex.4 Ex.5 Ex.6 Ex.7
1=E(2,4) 1=E(2,4)
1=E(2,3) 2=E(2,4) 2=E(2,4)
Unități multiple 1=E(1,2) 3=E(3,2) 3=E(2,4) 1=E(2,1) 1=E(2,2) 3=E(2,4) 1=E(1,2)
4=E(3,3) 4=E(2,4) 4=E(2,4)
5=E(2,4) 5=E(2,4)
Asociativ - - - - - - -
Medial + - + + + + +
Paramedial + - - + + - +
Bicomutativ + - - + + - +
AG grupoid + - + - - + +
GA grupoid - - - - + - -
GA1 grupoid - - - - - - -
AD grupoid - - - + - - -
DA grupoid - - - - - - -
Hexagonal - - + - - + -
Distributivladreapta - - + - - + -
Distributivlastânga - - + - - + -
Unitatededreapta - - - 1 - - -
Unitatedestânga 1 - - - - - 1
Unitate - - - - - - -
Ward - - - + - - -
Wardinvers + - - - - - +

66
Algoritmi privind obținerea izotopilor unui grupoid

Problemă. Fie grupoidul (𝑄,∙) de dimensiunea n. Fie 𝛼, 𝛽, 𝛾sunt trei permutări arbitrare ale
mulțimii Q. Atunci aplicând permutarea 𝛼 elementelor de pe linia de bordare, permutarea 𝛽
elementelor de pe coloana de bordare și permutarea 𝛾 −1 a elementelor din interiorul tabelei, se
obține o nouă lege de compoziție ° pe Q și este clar că (𝑄, °) este izotop cu quasigrupul (𝑄,∙). Se
cere să se elaboreze un program care efecuează permutările date. Să se cerceteze proprietățile
algebrice ale quasigrupului obținut.

Pentru fiecare din exemple, să se efectueze transformările 𝜶, 𝜷, 𝜸−𝟏 .

Ex.1
Ex.2

· 1 2 3 4 · 1 2 3 4
1 4 1 2 3 α=(2 3 4 1) 1 1 2 3 4 α=(2 3 1 4)
2 3 4 1 2 β=(4 3 2 1) 2 2 3 4 1 β=(3 1 4 2)
−1
3 2 3 4 1 𝛾 =(2 1 4 3) 3 4 1 2 3 𝛾 −1 =(1 3 4 2)
4 1 2 3 4 4 3 4 1 2

Ex.3 Ex.4
· 1 2 3 4 5 · 1 2 3
1 1 2 3 4 5 α=(2 3 1 5 4) 1 1 2 3 α=(1 3 2)
2 2 3 1 5 4 β=(3 1 2 4 5) 2 3 1 2 β=(3 2 1)
−1
3 4 1 5 2 3 𝛾 =(5 3 2 4 1) 3 2 3 1 𝛾 −1 =(2 1 3)
4 3 5 4 1 2
5 5 4 2 3 1

Ex.5 Ex.6
· 1 2 3 4 · 1 2 3 4
1 1 2 3 4 α=(4 3 2 1) 1 1 2 3 4 α=(4 3 2 1)
2 2 1 4 3 β=(4 3 2 1) 2 3 1 4 2 β=(3 4 1 2)
−1
3 3 4 1 2 𝛾 =(4 3 2 1) 3 2 4 1 3 𝛾 −1 =(2 3 4 1)
4 4 3 2 1 4 4 3 2 1

67
Ex.7
· 1 2 3 4 5 α=(5 4 3 2 1)

1 1 2 3 4 5 β=(4 3 2 1 5)

2 2 3 4 5 1 𝛾 −1 =(3 2 1 5 4)

3 3 4 5 1 2
4 4 5 1 2 3
5 5 1 2 3 4

Elaborarea programului:
Program L5;
uses crt;
label y;
type masiv=array[1..20,1..20] of byte;
var l:byte;
s:boolean;
m,gr,m1,m2,m3:masiv;
a,g,c,b:array[1..20] of 0..20;
r1,d1,r,d,r2,n,t,i,j,k,p,d2:integer;

Procedure asociativ(gr:masiv);
var l:integer;
begin
l:=0;
for i:=1 to n do
for j:=1 to n do
for k:=1 to n do begin
d:=gr[j,k];
d1:=gr[i,j];
if gr[i,d]<>gr[d1,k] then inc(l);
end;
if l=0 then writeln('Este asociativ')
else writeln('Nu este asociativ ' ) ;
end;

Procedure medial(gr:masiv);
var l:integer;
begin
l:=0;

68
for i:=1 to n do
for j:=1 to n do
for k:=1 to n do
for t:=1 to n do begin
d:=gr[i,j];
r:=gr[k,t];
d1:=gr[i,k];
r1:=gr[j,t];
if gr[d,r]<>gr[d1,r1] then inc (l);
end;
if l=0 then writeln('Este medial')
else writeln('Nu este medial');
end;

Procedure paramedial(gr:masiv);
var l:integer;
begin
l:=0;
for i:=1 to n do
for j:=1 to n do
for k:=1 to n do
for t:=1 to n do begin
d:=gr[i,j];
r:=gr[k,t];
d1:=gr[t,j];
r1:=gr[k,i];
if gr[d,r]<>gr[d1,r1] then inc(l);
end;
if l=0 then writeln('Este paramedial ')
else writeln('Nu este paramedial');
end;

Procedure bicomutativ(gr:masiv);
var l:integer;
begin
l:=0;
for i:=1 to n do
for j:=1 to n do
for k:=1 to n do
for t:=1 to n do begin
d:=gr[i,j];
r:=gr[k,t] ;

69
d1:=gr[t,k] ;
r1:=gr[j,i];
if gr[d,r]<>gr[d1,r1] then inc (l);
end;
if l=0 then writeln('Este bicomutativ')
else writeln('Nu este bicomutativ');
end;

Procedure ag_gr(gr:masiv);
var l:integer;
begin
l:=0;
for i:=1 to n do
for j:=1 to n do
for k:=1 to n do begin
d:=gr[i,j];
d1:=gr[k,j];
if gr[d,k]<>gr[d1,i] then inc(l);
end;
if l=0 then writeln('Este AG grupoid')
else writeln('Nu este AG grupoid');
end;

Procedure ga_gr(gr:masiv);
var l:integer;
begin
l:=0;
for i:=1 to n do
for j:=1 to n do
for k:=1 to n do begin
d:=gr[i,j];
d1:=gr[j,i];
if gr[d,k]<>gr[k,d1] then inc(l);
end;
if l=0 then writeln('Este GA grupoid')
else writeln('Nu este GA grupoid');
end;

Procedure ga_gr1(gr:masiv);
var l:integer;
begin
l:=0;

70
for i:=1 to n do
for j:=1 to n do
for k:=1 to n do begin
d:=gr[i,j];
d1:=gr[k,i];
if gr[d,k]<>gr[d1,j] then inc(l);
end;
if l=0 then writeln('Este GA1 grupoid')
else writeln('Nu este GA1 grupoid');
end;

Procedure ad_gr(gr:masiv);
var l:integer;
begin
l:=0;
for i:=1 to n do
for j:=1 to n do
for k:=1 to n do begin
d:=gr[j,k];
d1:=gr[j,i];
if gr[i,d]<>gr[k,d1] then inc (l);
end;
if l=0 then writeln('Este AD grupoid')
else writeln('Nu este AD grupoid' );
end;

Procedure da_gr(gr:masiv);
var l:integer;
begin
l:=0;
for i:=1 to n do
for j:=1 to n do
for k:=1 to n do begin
d:=gr[j,k];
d1:=gr[i,j];
if gr[i,d]<>gr[k,d1] then inc(l);
end;
if l=0 then writeln('Este DA grupoid')
else writeln('Nu este DA grupoid');
end;

Procedure hexagonal(gr:masiv);

71
var l:integer;
begin
l:=0;
for i:=1 to n do
for j:=1 to n do
for k:=1 to n do
for t:=1 to n do begin
d:=gr[i,j];
r:=gr[k,t];
d1:=gr[i,k];
r1:=gr[j,t];
r2:=gr[j,i];
if (gr[i,i]<>i)or(gr[d,r]<>gr[d1,r1])
or(gr[i,r2]<>gr[d,i]) and(gr[d,i]<>j)then inc(l);
end;
if l=0 then writeln('Este hexagonal')
else writeln('Nu este hexagonal ');
end;

Procedure dist_dr(gr:masiv);
var l:integer;
begin
l:=0;
for i:=1 to n do
for j:=1 to n do
for k:=1 to n do begin
d:=gr[i,j];
d1:=gr[i,k];
r1:=gr[j,k];
if gr[d,k]<>gr[d1,r1] then inc(l);
end;
if l=0 then writeln('Este distributiv la dreapta')
else writeln('Nu este distributiv la dreapta');
end;

Procedure dist_st(gr:masiv);
var l:integer;
begin
l:=0;
for i:=1 to n do
for j:=1 to n do
for k:=1 to n do begin

72
d:=gr[i,j];
d1:=gr[k,i];
r1:=gr[k,j];
if gr[k,d]<>gr[d1,r1] then inc(l);
end;
if l=0 then writeln('Este distributiv la stinga')
else writeln ('Nu este distributiv la stinga');
end;

Procedure unitate_dreapta(gr:masiv);
var l:integer;
begin
j:=0;
r:=0;
for i:=1 to n do begin
l:=0;
inc(j);
if gr[j,i]=i then begin
for k:=1 to n do begin
if gr[k,j]=k then inc(l);
if l=n then r:=j;
end; end; end;
if r<>0 then writeln('Este unitate de dreapta ',r)
else writeln('Nu este unitate de dreapta');
end;

Procedure unitate_stanga(gr:masiv);
var l:integer;
begin
j:=0; r2:=0;
for i:=1 to n do begin
l:=0;
inc(j);
if gr[i,j]=i then begin
for k:=1 to n do begin
if gr[j,k]=k then inc(l);
if l=n then r2:=j;
end; end; end;
if r2<>0 then writeln('Este unitate de stanga ', r2)
else writeln('Nu este unitate de stanga ');
end;

73
Procedure unitate;
begin
if (r=r2) and (r>0) then writeln('Este unitate ',r)
else writeln('Nu este unitate');
end;

Procedure afisare;
begin
for i:=1 to n do begin
writeln;
for j:=1 to n do begin
write(m[i,j],' ');
end; end; end;

Procedure afisare1;
begin
for i:=1 to n do begin
writeln;
for j:=1 to n do begin
write(m3[i,j],' ');
end; end; end;

Function mm(g:byte):byte;
var ii,jj,k,x,q:byte;
begin
for jj:=1 to n do begin
k:=0;
x:=jj;
repeat begin
x:=m[x,g];
inc(k);
end;
until(x=jj)or(k>n);
if k>n then b[jj]:=0
else b[jj]:=k;
end;
q:=b[1];
for jj:=1 to n do
if b[jj]>q then q:=b[jj];
mm:=q;
end;

74
Function nn(gg:byte):byte;
var ii,jj,k,x,q:byte;
begin
for jj:=1 to n do begin
k:=0;
x:=jj;
repeat begin
x:=m[gg,x];
inc(k);
end;
until (x=jj)or(k>n+1);
if k>n then c[jj]:=0
else c[jj]:=k;
end;
q:=c[1] ;
for jj:=1 to n do
if c[jj]>q then q:=c[jj];
nn:=q;
end;

Function mm1(g:byte):byte;
var ii,jj,k,x,q:byte;
begin
for jj:=1 to n do begin
k:=0;
x:=jj;
repeat begin
x:=m3[x,g];
inc(k);
end;
until(x=jj)or(k>n);
if k>n then b[jj]:=0
else b[jj]:=k;
end;
q:=b[1];
for jj:=1 to n do
if b[jj]>q then q:=b[jj];
mm1:=q;
end;

Function nn1(gg:byte):byte;
var ii,jj,k,x,q:byte;

75
begin
for jj:=1 to n do begin
k:=0;
x:=jj;
repeat begin
x:=m3[gg,x];
inc(k);
end;
until (x=jj)or(k>n+1);
if k>n then c[jj]:=0
else c[jj]:=k;
end;
q:=c[1] ;
for jj:=1 to n do
if c[jj]>q then q:=c[jj];
nn1:=q;
end;

Procedure tipar(h:masiv);
var contor:integer;
begin
contor:=0;
write(' ');
for i:=1 to n do begin
contor:=contor+3;
gotoxy(2+3*i,3);write('_');
gotoxy(4,i+3);write('|');
gotoxy(3+contor,3);write(i);
end;
for i:=1 to n do
for j:=1 to n do begin
gotoxy(3+3*j,3+i);writeln(h[i,j]);
end;end;
Procedure ward(gr: masiv);
var i,j,k:integer;
begin
l:=0;
for i:=1 to n do
for j:=1 to n do
for k:=1 to n do
begin
d:=gr[i,j]; d1:=gr[i,k]; d2:=gr[j,k];

76
if d<>gr[d1,d2] then l:=l+1;
end;
if l=0 then writeln('Este Ward')
else writeln('Nu este Ward');
end;

Procedure ward_inv(gr: masiv);


var i,j,k:integer;
begin
l:=0;
for i:=1 to n do
for j:=1 to n do
for k:=1 to n do
begin
d:=gr[i,j]; d1:=gr[k,i]; d2:=gr[k,j];
if d<>gr[d1,d2] then l:=l+1;
end;
if l=0 then writeln('Este Ward invers')
else writeln('Nu este Ward invers');
end;
Begin
y:clrscr;
write ('Dati n= ');
readln(n);
for i:=1 to n do begin
gotoxy(2+3*i,3);write('_');
gotoxy(4,i+3);write('|');
gotoxy(3+3*i,2);write(i);
gotoxy (3,3+i);write(i);
end;
for i:=1 to n do
for j:=1 to n do begin
gotoxy(3+3*j,3+i);
read(m[i,j]);
end;
for i:=1 to n do
for j:=1 to n do
for l:=1 to j-1 do
if m[i,j]=m[i,1] then goto y;
for i:=1 to n do
for j:=1 to n do
for l:=1 to j-1 do

77
if m[i,j]=m[i,l] then goto y;
clrscr;
tipar(m);
writeln;
writeln('Introdu substitutia ALFA');
for i:=1 to n do
read(a[i]);
writeln;
writeln('Introdu substitutia BETA');
for i:=1 to n do
read(b[i]);
writeln;
writeln('Introdu substitutia GAMA');
for i:=1 to n do
read(g[i]);writeln;
for i:=1 to n do
for j:=1 to n do begin
t:=a[i];
m1[i,j]:=m[t,j];
end;
writeln;
writeln ('Iteratia ALFA');
for i:=1 to n do begin
for j:=1 to n do
write(m1[i,j]: 2);
writeln;
end;
for i:=1 to n do
for j:=1 to n do begin
t:=b[j];
m2[i,j]:=m1[i,t];
end;
writeln;
writeln ('Iteratia BETA');
for i:=1 to n do begin
for j:=1 to n do
write(m2[i,j]: 2);
writeln;
end;
for i:=1 to n do
for j:=1 to n do begin
t:=m2[i,j];

78
m3[i,j]:=g[t];
end;
writeln;
writeln('Iteratia GAMA');
for i:=1 to n do begin
for j:=1 to n do
write(m3[i,j]:2);
writeln;
end;
writeln;
writeln('Proprietatile algebrice grupoid initial');
readln;
afisare;
writeln;
for i:=1 to n do
if ((m[i,i]=i) and (mm(i)<>0) and (nn(i)<>0)) then begin
writeln(i,'=E(',nn(i),',',mm(i),')');
end;

asociativ(m);
medial(m);
paramedial(m);
bicomutativ(m);
ag_gr(m);
ga_gr(m);
ga_gr1(m);
ad_gr(m);
da_gr(m);
hexagonal(m);
dist_dr(m);
dist_st(m);
unitate_dreapta(m);
unitate_stanga(m);
unitate;
ward(m);
ward_inv(m);
writeln;
writeln('Proprietatile algebrice grupoid gama');
readln;
afisare1;
writeln;
for i:=1 to n do

79
if ((m3[i,i]=i) and (mm1(i)<>0) and (nn1(i)<>0)) then begin
writeln(i,'=E(',nn1(i),',',mm1(i),')');
end;

asociativ(m3);
medial(m3);
paramedial(m3);
bicomutativ(m3);
ag_gr(m3);
ga_gr(m3);
ga_gr1(m3);
ad_gr(m3);
da_gr(m3);
hexagonal(m3);
dist_dr(m3);
dist_st(m3);
unitate_dreapta(m3);
unitate_stanga(m3);
unitate;
ward(m3);
ward_inv(m3);
readkey;
End.

80
În urma compilării sau obținut următoarele rezultate:

Ex. 1

81
Ex. 2

82
Ex. 3

83
Ex. 4

84
Ex. 5

85
Ex. 6

86
Ex. 7

87
Tabelul rezultatelor obținute :

După proprietățile grupoidului inițial și grupoidului final 𝜸−𝟏 observăm că


ex.4, ex.5 și ex. 7 sunt izomorfe deoarece au aceleași proprietăți.

88
Algoritmi privind verificarea obținerea
izomorfismelor de grupoizi

Problemă. Fie că avem doi grupoizi (𝑄,∙)și (𝑄,∗) de același ordin n. Să se verifice
dacă (𝑄,∙) este izomorf cu (𝑄,∗). Algoritmul de verificare al grupoizilor la
izomorfism este următorul:

1. Se introduce dimensiunea n a grupoizilor.

2. Se introduce grupoidul (𝑄,∙) din n elemente.

3. Se introduce grupoidul (𝑄,∗) din n elemente.

4. Se generează toate substituțiile 𝛼(𝑛!) și se testează condiția:

𝛼(𝑥)°𝛼(𝑦) = 𝛼(𝑥 ∗ 𝑦).

5. Se afișează la monitor acele substituții 𝛼 pentru care obținem izomorfism.

6. Se afișează la monitor rezultatul obținut: grupoizii dați (𝑄,∙), (𝑄,∗) sunt


izomorfi pentru substituțiile𝑎1 , 𝑎2 , … , 𝑎𝑛 ori grupoizii respectivi nu sînt izomorfi.

Pentru fiecare din exemple, să se verifice dacă există izomorfism între (𝑄,∙) și
(𝑄,∗).
Ex.1 Ex.2 Ex.3 Ex.4
· 1 2 3 4 · 1 2 3 4 · 1 2 3 · 1 2 3
1 1 2 3 4 1 1 2 3 4 1 1 2 3 1 1 2 3
2 2 3 4 1 2 2 1 4 3 2 3 1 2 2 2 3 1
3 4 1 2 3 3 3 4 1 2 3 2 3 1 3 3 1 2
4 3 4 1 2 4 4 3 2 1

* 1 2 3 4 * 1 2 3 4 * 1 2 3 * 1 2 3
1 1 2 3 4 1 2 1 4 3 1 3 2 1 1 3 1 2
2 2 4 1 3 2 1 2 3 4 2 1 3 2 2 2 3 1
3 4 3 2 1 3 4 3 2 1 3 2 1 3 3 1 2 3
4 3 1 4 2 4 3 4 1 2

89
Elaborarea programului:
program p4;
uses crt;
type masiv=array[1..25,1..25] of integer;
type vector=array[1..25] of integer;
var st:vector;
gr,m,m1,m2,m3,m4:masiv;
iz:boolean;
r1,d1,d2,r,d,r2,n,t,i,j,k,p,l,fact:integer;
a,b,g:array[1..20] of 0..20;
f1,f2,f3:text;

Procedure asociativ(gr:masiv);
var l:integer;
begin
l:=0;
for i:=1 to n do
for j:=1 to n do
for k:=1 to n do begin
d:=gr[j,k];
d1:=gr[i,j];
if gr[i,d]<>gr[d1,k] then inc(l);
end;
if l=0 then writeln('Este asociativ')
else writeln('Nu este asociativ ' ) ;
end;

Procedure medial(gr:masiv);
var l:integer;
begin
l:=0;
for i:=1 to n do
for j:=1 to n do
for k:=1 to n do
for t:=1 to n do begin
d:=gr[i,j];
r:=gr[k,t];
d1:=gr[i,k];
r1:=gr[j,t];
if gr[d,r]<>gr[d1,r1] then inc (l);
end;

90
if l=0 then writeln('Este medial')
else writeln('Nu este medial');
end;

Procedure paramedial(gr:masiv);
var l:integer;
begin
l:=0;
for i:=1 to n do
for j:=1 to n do
for k:=1 to n do
for t:=1 to n do begin
d:=gr[i,j];
r:=gr[k,t];
d1:=gr[t,j];
r1:=gr[k,i];
if gr[d,r]<>gr[d1,r1] then inc(l);
end;
if l=0 then writeln('Este paramedial ')
else writeln('Nu este paramedial');
end;

Procedure bicomutativ(gr:masiv);
var l:integer;
begin
l:=0;
for i:=1 to n do
for j:=1 to n do
for k:=1 to n do
for t:=1 to n do begin
d:=gr[i,j];
r:=gr[k,t] ;
d1:=gr[t,k] ;
r1:=gr[j,i];
if gr[d,r]<>gr[d1,r1] then inc (l);
end;
if l=0 then writeln('Este bicomutativ')
else writeln('Nu este bicomutativ');
end;
Procedure ag_gr(gr:masiv);
var l:integer;
begin

91
l:=0;
for i:=1 to n do
for j:=1 to n do
for k:=1 to n do begin
d:=gr[i,j];
d1:=gr[k,j];
if gr[d,k]<>gr[d1,i] then inc(l);
end;
if l=0 then writeln('Este AG grupoid')
else writeln('Nu este AG grupoid');
end;

Procedure ga_gr(gr:masiv);
var l:integer;
begin
l:=0;
for i:=1 to n do
for j:=1 to n do
for k:=1 to n do begin
d:=gr[i,j];
d1:=gr[j,i];
if gr[d,k]<>gr[k,d1] then inc(l);
end;
if l=0 then writeln('Este GA grupoid')
else writeln('Nu este GA grupoid');
end;

Procedure ga_gr1(gr:masiv);
var l:integer;
begin
l:=0;
for i:=1 to n do
for j:=1 to n do
for k:=1 to n do begin
d:=gr[i,j];
d1:=gr[k,i];
if gr[d,k]<>gr[d1,j] then inc(l);
end;
if l=0 then writeln('Este GA1 grupoid')
else writeln('Nu este GA1 grupoid');
end;

92
Procedure ad_gr(gr:masiv);
var l:integer;
begin
l:=0;
for i:=1 to n do
for j:=1 to n do
for k:=1 to n do begin
d:=gr[j,k];
d1:=gr[j,i];
if gr[i,d]<>gr[k,d1] then inc (l);
end;
if l=0 then writeln('Este AD grupoid')
else writeln('Nu este AD grupoid' );
end;

Procedure da_gr(gr:masiv);
var l:integer;
begin
l:=0;
for i:=1 to n do
for j:=1 to n do
for k:=1 to n do begin
d:=gr[j,k];
d1:=gr[i,j];
if gr[i,d]<>gr[k,d1] then inc(l);
end;
if l=0 then writeln('Este DA grupoid')
else writeln('Nu este DA grupoid');
end;

Procedure hexagonal(gr:masiv);
var l:integer;
begin
l:=0;
for i:=1 to n do
for j:=1 to n do
for k:=1 to n do
for t:=1 to n do begin
d:=gr[i,j];
r:=gr[k,t];
d1:=gr[i,k];
r1:=gr[j,t];

93
r2:=gr[j,i];
if (gr[i,i]<>i)or(gr[d,r]<>gr[d1,r1])
or(gr[i,r2]<>gr[d,i]) and(gr[d,i]<>j)then inc(l);
end;
if l=0 then writeln('Este hexagonal')
else writeln('Nu este hexagonal ');
end;

Procedure dist_dr(gr:masiv);
var l:integer;
begin
l:=0;
for i:=1 to n do
for j:=1 to n do
for k:=1 to n do begin
d:=gr[i,j];
d1:=gr[i,k];
r1:=gr[j,k];
if gr[d,k]<>gr[d1,r1] then inc(l);
end;
if l=0 then writeln('Este distributiv la dreapta')
else writeln('Nu este distributiv la dreapta');
end;

Procedure dist_st(gr:masiv);
var l:integer;
begin
l:=0;
for i:=1 to n do
for j:=1 to n do
for k:=1 to n do begin
d:=gr[i,j];
d1:=gr[k,i];
r1:=gr[k,j];
if gr[k,d]<>gr[d1,r1] then inc(l);
end;
if l=0 then writeln('Este distributiv la stinga')
else writeln ('Nu este distributiv la stinga');
end;

Procedure unitate_dreapta(gr:masiv);
var l:integer;

94
begin
j:=0;
r:=0;
for i:=1 to n do begin
l:=0;
inc(j);
if gr[j,i]=i then begin
for k:=1 to n do begin
if gr[k,j]=k then inc(l);
if l=n then r:=j;
end; end; end;
if r<>0 then writeln('Este unitate de dreapta ',r)
else writeln('Nu este unitate de dreapta');
end;

Procedure unitate_stanga(gr:masiv);
var l:integer;
begin
j:=0; r2:=0;
for i:=1 to n do begin
l:=0;
inc(j);
if gr[i,j]=i then begin
for k:=1 to n do begin
if gr[j,k]=k then inc(l);
if l=n then r2:=j;
end; end; end;
if r2<>0 then writeln('Este unitate de stanga ', r2)
else writeln('Nu este unitate de stanga ');
end;

Procedure unitate;
begin
if (r=r2) and (r>0) then writeln('Este unitate ',r)
else writeln('Nu este unitate');
end;
Procedure ward(gr: masiv);
var i,j,k:integer;
begin
l:=0;
for i:=1 to n do
for j:=1 to n do

95
for k:=1 to n do
begin
d:=gr[i,j]; d1:=gr[i,k]; d2:=gr[j,k];
if d<>gr[d1,d2] then l:=l+1;
end;
if l=0 then writeln('Este Ward')
else writeln('Nu este Ward');
end;

Procedure ward_inv(gr: masiv);


var i,j,k:integer;
begin
l:=0;
for i:=1 to n do
for j:=1 to n do
for k:=1 to n do
begin
d:=gr[i,j]; d1:=gr[k,i]; d2:=gr[k,j];
if d<>gr[d1,d2] then l:=l+1;
end;
if l=0 then writeln('Este Ward invers')
else writeln('Nu este Ward invers');
end;

Function valid(p:integer):boolean;
var i:integer;
ok:boolean;
begin
ok:=true;
for i:=1 to p-1 do
if (st[p]=st[i]) then ok:=false;
valid:=ok;
end;

Procedure tipar (p:integer);


var i:integer;
begin
for i:=1 to p do
write(f3,st[i]:2,' ') ;
writeln(f3);
end;

96
Procedure backtr(p:integer);
var pval:integer;
begin
for pval:=1 to n do begin
st[p]:=pval;
if (valid(p)) then
if (p=n) then tipar(p)
else backtr (p+1);
end;
end;

Begin
clrscr;
assign(f1,'input4.txt');
assign(f2,'output4.txt');
assign(f3,'alf.txt');
reset(f1);
rewrite(f2);
rewrite(f3);
readln(f1,n);
backtr(1);
close(f3);
fact:=1;
for i:=1 to n do
fact:=fact*i;
writeln(f2,'(Q,.)');
for i:=1 to n do begin
for j:=1 to n do begin
read (f1,m[i,j]);
write(f2,m[i,j]:2); end;
writeln(f2); end;
writeln(f2,'(Q,*)');
for i:=1 to n do begin
for j:=1 to n do begin
read(f1,m4[i,j]);
write(f2,m4[i,j]:2);end;
writeln(f2);end;
reset(f3);
iz:=false;
for k:=1 to fact do begin
for i:=1 to n do
read(f3,a[i]);

97
readln(f3);
b:=a;g:=a;
for i:=1 to n do
for j:=1 to n do begin
t:=a[i];
m1[i,j]:=m[t,j];
end;
for i:=1 to n do
for j:=1 to n do begin
t:=b[j];
m2[i,j]:=m1[i,t]; end;
for i:=1 to n do
for j:=1 to n do begin
t:=m2[i,j];
m3[i,j]:=g[t];
end;
p:=1;
for i:=1 to n do
for j:=1 to n do
if (m3[i,j]=m4[i,j]) then p:=p*1 else p:=0;
if p=1 then begin iz:=true;
write(f2,'grupoizii dati sunt izomorfi pentru ALFA =' );
for i:=1 to n do
write(f2,a[i]:2);
writeln;
end;
end;
if iz=false then write (f2,'grupoizii dati nu sunt izomorfi');
writeln;
writeln({f2},'Pentru quasigrupul avem proprietatile');
readln;
asociativ(m);
medial(m);
paramedial(m);
bicomutativ(m);
ag_gr(m);
ga_gr(m);
ga_gr1(m);
ad_gr(m);
da_gr(m);
hexagonal(m);
dist_dr(m);

98
dist_st(m);
unitate_dreapta(m);
unitate_stanga(m);
unitate;
ward(m);
ward_inv(m);
writeln;
readln;
writeln({f2},'Pentru quasigrupul izotop avem proprietatile');
asociativ(m4);
medial(m4);
paramedial(m4);
bicomutativ(m4);
ag_gr(m4);
ga_gr(m4);
ga_gr1(m4);
ad_gr(m4);
da_gr(m4);
hexagonal(m4);
dist_dr(m4);
dist_st(m4);
unitate_dreapta(m4);
unitate_stanga(m4);
unitate;
ward(m4);
ward_inv(m4);
close (f1);close(f2); close(f3);
End

99
În urma compilării am obținem următoare rezultate :

Ex.1

Fișierul input4.txt

Fișierul alf.txt

100
Fișierul output4.txt

Proprietăți:

101
Ex.2

Fișierul input4.txt

Fișierul alf.txt

102
Fișierul output4.txt

Proprietăți

Ex.3

Fișierul input4.txt

103
Fișierul alf.txt

Fișierul output4.txt

104
Proprietăți

Ex.4

Fișierul input4.txt

Fișierul alf.txt

Fișierul output4.txt

105
Proprietăți:

Tabelul rezultatelor obținute :

Ex.1 Ex.2 Ex.3 Ex.4


α= 2 1 3 4
Avemizomorfismpentrusubstitu α= 2 1 4 3
α= 1 2 4 3 Nu Nu
ția α= 2 3 4 1
α= 2 4 1 3
Asociativ - - + + - - + -
Medial - - + + + + + +
Paramedial - - + + + + + +
Bicomutativ - - + + + + + +
AG grupoid - - + + + - + +
GA grupoid - - + + - - + -
GA1 grupoid - - + + - - + -
AD grupoid - - + + - + + -
DA grupoid - - + + - - + -
Hexagonal - - - - - - - -
Distributivladreapta - - - - - - - -
Distributivlastânga - - - - - - - -
Unitatededreapta - - 1 2 - 3 1 -
Unitatedestânga 1 1 1 2 1 - 1 3
Unitate - - 1 2 - - 1 -
Ward - - + + - + - -
Wardinvers - - + + + - - +

106
Algoritm privind compunerea substituțiilor
Problemă. Fie că sunt date următoarele substituții:

e=(1 2 3),

a=(2 3 1),

b=(3 1 2),

g=(2 1 3),

h=(3 2 1),

r=(1 3 2).

Se cere de elaborat un algoritm care realizează compoziția substituțiilor date și


completează un tabel Cayley. Substituțiile se introduc într-un fișier, se extrag
substituțiile necesare și se află compoziția lor.

Elaborarea programului:
Program p8;
usescrt;
type sub=array[1..6]of 1..3;
vari,j:integer;
e,a,b,g,h,r,pr:sub;
f1,f2:text;

Procedure prod(x,y:sub);
var p1,p2,p3,p4,p5,p6:byte;
begin
for i:=1 to 3 do
pr[i]:=x[y[i]];
p1:=1;
for i:=1 to 3 do
if (pr[i]=e[i]) then p1:=p1 else p1:=0;
if p1=1 then write(f2,'e':2);
p2:=1;
for i:=1 to 3 do
if (pr[i]=a[i]) then p2:=p2 else p2:=0;
if p2=1 then write(f2,'a':2);
p3:=1;
for i:=1 to 3 do
if (pr[i]=b[i]) then p3:=p3 else p3:=0;

107
if p3=1 then write(f2,'b':2);
p4:=1;
for i:=1 to 3 do
if (pr[i]=g[i]) then p4:=p4 else p4:=0;
if p4=1 then write(f2,'g':2); p5:=1;
for i:=1 to 3 do
if (pr[i]=h[i]) then p5:=p5 else p5:=0;
if p5=1 then write(f2,'h':2);
p6:=1;
for i:=1 to 3 do
if (pr[i]=r[i]) then p6:=p6 else p6:=0;
if p6=1 then write(f2,'r':2);
end;

Procedure citire;
begin
write(f2,'e=');
for i:=1 to 3 do begin
read(f1,e[i]);
write(f2,e[i]:2);
end;
writeln (f2);
write (f2,'a=');
for i:=1 to 3 do begin
read(f1,a[i]);
write(f2,a[i]:2);
end;
writeln (f2);
write (f2,'b=');
for i:=1 to 3 do begin
read(f1,b[i]);
write(f2,b[i]:2);
end;
writeln (f2);
write (f2,'g=');
for i:=1 to 3 do begin
read(f1,g[i]);
write(f2,g[i]:2);
end;
writeln (f2);
write (f2,'h=');
for i:=1 to 3 do begin

108
read(f1,h[i]);
write(f2,h[i]:2);
end;
writeln (f2);
write (f2,'r=');
for i:=1 to 3 do begin
read(f1,r[i]);
write(f2,r[i]:2);
end;
writeln (f2);
end;

Begin
clrscr;
assign(f1,'input1.txt') ;
assign(f2,'output1.txt');
reset(f1);
rewrite(f2);
citire;
close(f1);
writeln(f2,' PRODUSUL SUBSTITUTIILOR');
writeln(f2,' | e a b g h r');
writeln(f2,'-|------------') ;
write(f2,'e|');prod(e,e);prod(e,a);prod(e,b);prod(e,g);prod(e,h);prod(e,r);
writeln(f2);
write(f2,'a|');prod(a,e);prod(a,a);prod(a,b);prod(a,g);prod(a,h);prod(a,r);
writeln(f2);
write(f2,'b|');prod(b,e);prod(b,a);prod(b,b);prod(b,g);prod(b,h);prod(b,r);
writeln(f2) ;
write(f2,'g|');prod(g,e);prod(g,a);prod(g,b);prod(g,g);prod(g,h);prod(g,r);
writeln(f2);
write(f2,'h|');prod(h,e);prod(h,a);prod(h,b);prod(h,g);prod(h,h);prod(h,r) ;
writeln(f2) ;
write(f2,'r|');prod(r,e);prod(r,a);prod(r,b);prod(r,g);prod(r,h);prod(r,r);
writeln(f2);
close (f2);
End.

109
Introducerea substituțiilor în fișierul input1.txt :

Rezultatul obținut în fișierul output1.txt

110
Algoritmi privind obținerea quasigrupului dintr-un grup
comutativ pe care sunt definite careva operații binare

Problema. Se dă grupul comutativ (Q, +) . Definim pe mulțimea Q una din


următoarele operații:

1. 𝑥°𝑦 = 𝑥 − 𝑦;
2. 𝑥°𝑦 = −𝑥 + 𝑦;
3. 𝑥°𝑦 = −𝑥 − 𝑦;
4. 𝑥°𝑦 = 𝑥 + 𝑦.

Se cere de elaborat un program care va permite obținerea quasigrupului (Q, °) .

Să se realizeze următoarele exemple:


Ex.1 Ex.2 Ex.3
+ 1 2 3 + 1 2 3 + 1 2 3 4
1 1 2 3 1 1 3 2 1 1 2 3 4
2 2 3 1 2 3 2 1 2 2 1 4 3
3 3 1 2 3 2 1 3 3 3 4 1 2
4 4 3 2 1

Ex.4 Ex.5
+ 1 2 3 4 + 1 2 3 4 5
1 1 2 3 4 1 1 2 3 4 5
2 2 3 4 1 2 2 3 4 5 1
3 3 4 1 2 3 3 4 5 1 2
4 4 1 2 3 4 4 5 1 2 3
5 5 1 2 3 4

Ex.6
7 8 9
7 7 8 9
8 8 9 7
9 9 7 8

Elaborarea programului:
Program p1;
//uses crt;
type masiv=array[1..50,1..50] of integer;

111
var gr1,gr2,opus,a,tabel,gr:masiv;
r1,d1,r,d,r2,n,m,t,i,j,k,p,l,d2:integer;
i2,k2,k1:integer;
Procedure asociativ(gr:masiv);
var l:integer;
begin
l:=0;
for i:=1 to n do
for j:=1 to n do
for k:=1 to n do begin
d:=gr[j,k];
d1:=gr[i,j];
if gr[i,d]<>gr[d1,k] then inc(l);
end;
if l=0 then writeln('Este asociativ')
else writeln('Nu este asociativ ' ) ;
end;

Procedure medial(gr:masiv);
var l:integer;
begin
l:=0;
for i:=1 to n do
for j:=1 to n do
for k:=1 to n do
for t:=1 to n do begin
d:=gr[i,j];
r:=gr[k,t];
d1:=gr[i,k];
r1:=gr[j,t];
if gr[d,r]<>gr[d1,r1] then inc (l);
end;
if l=0 then writeln('Este medial')
else writeln('Nu este medial');
end;

Procedure paramedial(gr:masiv);
var l:integer;
begin
l:=0;
for i:=1 to n do
for j:=1 to n do

112
for k:=1 to n do
for t:=1 to n do begin
d:=gr[i,j];
r:=gr[k,t];
d1:=gr[t,j];
r1:=gr[k,i];
if gr[d,r]<>gr[d1,r1] then inc(l);
end;
if l=0 then writeln('Este paramedial ')
else writeln('Nu este paramedial');
end;

Procedure bicomutativ(gr:masiv);
var l:integer;
begin
l:=0;
for i:=1 to n do
for j:=1 to n do
for k:=1 to n do
for t:=1 to n do begin
d:=gr[i,j];
r:=gr[k,t] ;
d1:=gr[t,k] ;
r1:=gr[j,i];
if gr[d,r]<>gr[d1,r1] then inc (l);
end;
if l=0 then writeln('Este bicomutativ')
else writeln('Nu este bicomutativ');
end;

Procedure ag_gr(gr:masiv);
var l:integer;
begin
l:=0;
for i:=1 to n do
for j:=1 to n do
for k:=1 to n do begin
d:=gr[i,j];
d1:=gr[k,j];
if gr[d,k]<>gr[d1,i] then inc(l);
end;
if l=0 then writeln('Este AG grupoid')

113
else writeln('Nu este AG grupoid');
end;

Procedure ga_gr(gr:masiv);
var l:integer;
begin
l:=0;
for i:=1 to n do
for j:=1 to n do
for k:=1 to n do begin
d:=gr[i,j];
d1:=gr[j,i];
if gr[d,k]<>gr[k,d1] then inc(l);
end;
if l=0 then writeln('Este GA grupoid')
else writeln('Nu este GA grupoid');
end;

Procedure ga_gr1(gr:masiv);
var l:integer;
begin
l:=0;
for i:=1 to n do
for j:=1 to n do
for k:=1 to n do begin
d:=gr[i,j];
d1:=gr[k,i];
if gr[d,k]<>gr[d1,j] then inc(l);
end;
if l=0 then writeln('Este GA1 grupoid')
else writeln('Nu este GA1 grupoid');
end;

Procedure ad_gr(gr:masiv);
var l:integer;
begin
l:=0;
for i:=1 to n do
for j:=1 to n do
for k:=1 to n do begin
d:=gr[j,k];
d1:=gr[j,i];

114
if gr[i,d]<>gr[k,d1] then inc (l);
end;
if l=0 then writeln('Este AD grupoid')
else writeln('Nu este AD grupoid' );
end;

Procedure da_gr(gr:masiv);
var l:integer;
begin
l:=0;
for i:=1 to n do
for j:=1 to n do
for k:=1 to n do begin
d:=gr[j,k];
d1:=gr[i,j];
if gr[i,d]<>gr[k,d1] then inc(l);
end;
if l=0 then writeln('Este DA grupoid')
else writeln('Nu este DA grupoid');
end;

Procedure hexagonal(gr:masiv);
var l:integer;
begin
l:=0;
for i:=1 to n do
for j:=1 to n do
for k:=1 to n do
for t:=1 to n do begin
d:=gr[i,j];
r:=gr[k,t];
d1:=gr[i,k];
r1:=gr[j,t];
r2:=gr[j,i];
if (gr[i,i]<>i)or(gr[d,r]<>gr[d1,r1])
or(gr[i,r2]<>gr[d,i]) and(gr[d,i]<>j)then inc(l);
end;
if l=0 then writeln('Este hexagonal')
else writeln('Nu este hexagonal ');
end;

Procedure dist_dr(gr:masiv);

115
var l:integer;
begin
l:=0;
for i:=1 to n do
for j:=1 to n do
for k:=1 to n do begin
d:=gr[i,j];
d1:=gr[i,k];
r1:=gr[j,k];
if gr[d,k]<>gr[d1,r1] then inc(l);
end;
if l=0 then writeln('Este distributiv la dreapta')
else writeln('Nu este distributiv la dreapta');
end;

Procedure dist_st(gr:masiv);
var l:integer;
begin
l:=0;
for i:=1 to n do
for j:=1 to n do
for k:=1 to n do begin
d:=gr[i,j];
d1:=gr[k,i];
r1:=gr[k,j];
if gr[k,d]<>gr[d1,r1] then inc(l);
end;
if l=0 then writeln('Este distributiv la stinga')
else writeln ('Nu este distributiv la stinga');
end;

Procedure unitate_dreapta(gr:masiv);
var l:integer;
begin
j:=0;
r:=0;
for i:=1 to n do begin
l:=0;
inc(j);
if gr[j,i]=i then begin
for k:=1 to n do begin
if gr[k,j]=k then inc(l);

116
if l=n then r:=j;
end; end; end;
if r<>0 then writeln('Este unitate de dreapta ',r)
else writeln('Nu este unitate de dreapta');
end;

Procedure unitate_stanga(gr:masiv);
var l:integer;
begin
j:=0; r2:=0;
for i:=1 to n do begin
l:=0;
inc(j);
if gr[i,j]=i then begin
for k:=1 to n do begin
if gr[j,k]=k then inc(l);
if l=n then r2:=j;
end; end; end;
if r2<>0 then writeln('Este unitate de stanga ', r2)
else writeln('Nu este unitate de stanga ');
end;

Procedure unitate;
begin
if (r=r2) and (r>0) then writeln('Este unitate ',r)
else writeln('Nu este unitate');
end;

Procedure Topus(n:integer);
var i,j,element,k:integer;
begin
for i:=1 to n do
for j:=1 to n do begin
write ('a [', i,',' , j, '] = ');
readln(element);
gr[i,j]:=element;
if (element=1) then opus[i,1]:=j;
end;
k:=1;
for i:=1 to n do
for j:=1 to n do begin
tabel[i,j]:=k; k:=k+1;

117
end; end;

Procedure pr_cartezian(gr:masiv);
var i,j:integer;
begin
for i:=1 to n do
for j:=1 to n do
begin
gr2[i,j]:=gr[gr[i,1],opus[j,1]];//legea 1
//gr2[i,j]:=gr[opus[i,1],gr[j,1]];//legea 2
//gr2[i,j]:=gr[opus[i,1],opus[j,1]];//legea 3
//gr2[i,j]:=gr[gr[i,1],gr[j,1]];//legea 4
end;
for i:=1 to n do
begin
for j:=1 to n do
write(gr2[i,j]:3); writeln;
end;
end;

Procedure afisare_pr(gr2:masiv);
var a,i,j:integer;
begin
for i:=1 to n do begin
for j:=1 to n do
write(gr2[i,j]:4);
writeln;
end; end;
Procedure ward(gr: masiv);
var i,j,k:integer;
begin
l:=0;
for i:=1 to n do
for j:=1 to n do
for k:=1 to n do
begin
d:=gr[i,j]; d1:=gr[i,k]; d2:=gr[j,k];
if d<>gr[d1,d2] then l:=l+1;
end;
if l=0 then writeln('Este Ward')
else writeln('Nu este Ward');

118
end;

Procedure ward_inv(gr: masiv);


var i,j,k:integer;
begin
l:=0;
for i:=1 to n do
for j:=1 to n do
for k:=1 to n do
begin
d:=gr[i,j]; d1:=gr[k,i]; d2:=gr[k,j];
if d<>gr[d1,d2] then l:=l+1;
end;
if l=0 then writeln('Este Ward invers')
else writeln('Nu este Ward invers');
end;

Begin
//clrscr;
writeln('Dati n=');
readln(n);
Topus(n);
pr_cartezian(gr);
writeln('Quasigrupul obtinut');
afisare_pr(gr2);
writeln('Proprietati:');
asociativ(gr2);
medial(gr2);
paramedial(gr2);
bicomutativ (gr2);
ag_gr(gr2);
ga_gr(gr2);
ga_gr1(gr2);
ad_gr(gr2);
da_gr(gr2);
hexagonal(gr2);
dist_dr(gr2);
dist_st(gr2);
unitate_dreapta(gr2);
unitate_stanga(gr2);
unitate;
ward(gr2);

119
ward_inv(gr2);
//readkey;
End.

Rezultatele obținute pentru operația 𝒙°𝒚 = 𝒙 − 𝒚 :

Ex.1

Ex.2

120
Ex.3

121
Ex.4

Ex.5

122
Ex.6

Rezultatele obținute pentru operația 𝒙°𝒚 = −𝒙 + 𝒚

Ex.1

123
Ex.2

Ex.3

124
Ex.4

Ex.5

125
Ex.6

Rezultatele obținute pentru legea 𝒙°𝒚 = −𝒙 − 𝒚

Ex.1

126
Ex.2

Ex.3

127
Ex.4

Ex.5

128
Ex.6

Rezultatele obținute pentru operatia 𝒙°𝒚 = 𝒙 + 𝒚

Ex.1

129
Ex.2

Ex.3

130
Ex.4

Ex.5

131
Ex.6

Tabelul obţinut :

Notă: Semnul „+” denotă că proprietatea respectivă se îndeplinește.

132
Algoritmi privind obținerea quasigrupului dintr-un grup comutativ pe care sunt
definite careva operații binare

5. 𝑥°𝑦 = 𝑥 − 𝑦;
6. 𝑥°𝑦 = −𝑥 + 𝑦;
7. 𝑥°𝑦 = −𝑥 − 𝑦;
8. 𝑥°𝑦 = 𝑥 + 𝑦.

1. Ex1

1 2 3 4 5 6
1 1 2 3 4 5 6
2 2 1 4 3 6 5
3 3 5 1 6 2 4
4 4 6 2 5 1 3
5 5 3 6 1 4 2
6 6 4 5 2 3 1

Verificarea pentru proprietatea x-y

133
Verificarea pentru proprietatea –x+y

Verificarea pentru proprietatea –x-y

134
Verificarea pentru proprietatea x+y

135
2. D4

D4 1 2 3 4 5 6 7 8
1 1 2 3 4 5 6 7 8
2 2 3 4 1 6 7 8 5
3 3 4 1 2 7 8 5 6
4 4 1 2 3 8 5 6 7
5 5 8 7 6 1 4 3 2
6 6 5 8 7 2 1 4 3
7 7 6 5 8 3 2 1 4
8 8 7 6 5 4 3 2 1

Verificarea pentru proprietatea x-y

136
Verificarea pentru proprietatea : -x+y

Verificarea pentru proprietatea : -x-y

137
Verificarea pentru proprietatea x+y

3. Q

Q 1 2 3 4 5 6 7 8
1 1 2 3 4 5 6 7 8
2 2 3 4 1 6 7 8 5
3 3 4 1 2 7 8 5 6
4 4 1 2 3 8 5 6 7
5 5 8 7 6 1 4 3 2
6 6 5 8 7 2 1 4 3
7 7 6 5 8 3 2 1 4
8 8 7 6 5 4 3 2 1

138
Verificarea pentru proprietatea: x-y

Verificarea pentru proprietatea: -x+y

139
Verificarea pentru proprietatea: -x-y

Verificarea pentru proprietatea: x+y

140
4.D5
D5
1
2 3 4 5 6 7 8 9 10
1 1 2 3 4 5 6 7 8 9 10
2 2 3 4 5 1 7 8 9 10 6
3 3 4 5 1 2 8 9 10 6 7
4 4 5 1 2 3 9 10 6 7 8
5 5 1 2 3 4 10 6 7 8 9
6 6 10 9 8 7 1 5 4 3 2
7 7 6 10 9 8 2 1 5 4 3
8 8 7 6 10 9 3 2 1 5 4
9 9 8 7 6 10 4 3 2 1 5
10 10 9 8 7 6 5 4 3 2 1

Verificarea pentru proprietatea: x-y

141
Verificarea pentru proprietatea: -x+y

Verificarea pentru proprietatea: -x-y

142
Verificarea pentru proprietatea: x+y

Tabelul rezultatelor obținute:


Legea 1 Legea 2 Legea 3 Legea 4
Ex.1 D4 Q D5 Ex.1 D4 Q D5 Ex.1 D4 Q D5 Ex.1 D4 Q D5
Asociativ - - - - - - - - - - - - + + - -
Medial - - - - - - - - - - - - - - - -
Paramedial - - - - - - - - - - - - - - - -
Bicomutativ - - - - - - - - - - - - - - -
AG grupoid - - - - - - - - - - - - - - - -
GA grupoid - - - - - - - - - - - - - - - -
GA1 grupoid - - - - - - - - - - - - - - - -
AD grupoid - - - - - - - - - - - - - - - -
DA grupoid - - - - - - - - - - - - - - - -
Hexagonal - - - - - - - - - - - - - - - -
Distributiv la
- - - - - - - - - - - - - - - -
dreapta
Distributiv la
- - - - - - - - - - - - - - - -
stânga
Unitate de
1 1 1 1 1 1 - 1 1 1 1 1 1 1 1 1
dreapta
Unitate de
- - - - - 1 1 - - 1 - - 1 1 - -
stânga
Unitate - - - - - 1 - - - 1 - - 1 1 - -
Ward + + - + + - - + + - - + - - - +
Ward invers - - - - - - - - - - - - - - - -

143