Propriétés des fonctions binaires

14

De nombreux sujets importants en algèbre abstraite impliquent une fonction binaire agissant sur un ensemble. Un certain nombre de propriétés de ces fonctions ont été définies dans l'étude de ces sujets.

Votre défi sera de déterminer si une fonction binaire donnée sur un domaine donné possède cinq de ces propriétés.

Propriétés

Fermeture

Une fonction binaire est fermée si toutes les sorties possibles se trouvent dans le domaine.

Associativité

Une fonction binaire est associative si l'ordre dans lequel la fonction est appliquée à une série d'entrées n'affecte pas le résultat. C'est-à-dire qu'il $est associatif s'il est (a $ b) $ ctoujours égal a $ (b $ c). Notez que la valeur (a $ b)étant utilisée en entrée, les fonctions associatives doivent être fermées.

Commutativité

Une fonction binaire est commutative si l'échange de l'ordre des entrées ne change pas le résultat. En d'autres termes, si a $ btoujours égal b $ a.

Identité

Une fonction binaire a un élément d'identité s'il existe un élément edans le domaine tel que a $ e = a = e $ apour tous adans le domaine.

Idempotence

Une fonction binaire est idempotente si l'appliquer à deux entrées identiques donne ce nombre comme sortie. En d'autres termes, si a $ a = apour tous adans le domaine.

Contribution

Vous recevrez une fonction sous la forme d'une matrice, et le domaine de la fonction sera les nombres 0 ... n-1, où nest la longueur latérale de la matrice.

La valeur (a $ b)est codée dans la matrice en tant que e élément de la atroisième ligne b. Si la matrice d'entrée est Q, alors a $ b=Q[a][b]

Par exemple, la fonction d'exponentiation ( **en Python) sur le domaine [0, 1, 2]est codée comme suit:

[[1, 0, 0]
 [1, 1, 1]
 [1, 2, 4]]

Les domaines gauche et droit sont identiques, donc la matrice sera toujours carrée.

Vous pouvez utiliser n'importe quel format de matrice pratique en entrée, comme une liste de listes, une seule liste dans l'ordre principal des lignes ou des colonnes, l'objet matriciel natif de votre langue, etc. Cependant, vous ne pouvez pas prendre directement une fonction en entrée.

Par souci de simplicité, les entrées de la matrice seront toutes des entiers. Vous pouvez supposer qu'ils correspondent au type d'entier natif de votre langue.

Production

Vous pouvez indiquer laquelle des propriétés ci-dessus contient dans n'importe quel format que vous choisissez, y compris une liste de booléens, une chaîne avec un caractère différent pour chaque propriété, etc. Cependant, il doit y avoir une sortie distincte et unique pour chacun des 24 sous-ensembles possibles des propriétés. Cette sortie doit être facilement lisible par l'homme.

Exemples

La fonction maximale sur le domaine n = 4:

[[0, 1, 2, 3]
 [1, 1, 2, 3]
 [2, 2, 2, 3]
 [3, 3, 3, 3]]

Cette fonction a les propriétés de fermeture, d'associativité, de commutativité, d'identité et d'idempotence.

La fonction d'exponentiation sur le domaine n = 3:

[[1, 0, 0]
 [1, 1, 1]
 [1, 2, 4]]

Cette fonction n'a aucune des propriétés ci-dessus.

La fonction d'addition sur le domaine n = 3:

[[0, 1, 2]
 [1, 2, 3]
 [2, 3, 4]]

Cette fonction a les propriétés de commutativité et d'identité.

Le combinateur K sur le domaine n = 3:

[[0, 0, 0]
 [1, 1, 1]
 [2, 2, 2]]

Cette fonction a les propriétés de fermeture, d'associativité et d'idempotence.

La fonction de différence absolue sur le domaine n = 3:

[[0, 1, 2]
 [1, 0, 1]
 [2, 1, 0]]

Cette fonction a les propriétés de fermeture, de commutativité et d'identité.

La fonction moyenne, arrondie vers pair, sur le domaine n = 3:

[[0, 0, 1]
 [0, 1, 2]
 [1, 2, 2]]

Cette fonction a les propriétés de fermeture, commutativité, identité et idempotence.

La fonction d'égalité sur le domaine n = 3:

[[1, 0, 0]
 [0, 1, 0]
 [0, 0, 1]]

Cette fonction a les propriétés de fermeture et de commutativité.

Défi

C'est le golf de code. Des échappatoires standard s'appliquent. Le moins d'octets l'emporte.

isaacg
la source

Réponses:

4

Pyth, 51 octets

[qKUQ@VQKCIQ}]Km{@RdCBQKJ!-sQK&JqF.bsm@[email protected],sQK

Essayez-le en ligne: démonstration ou suite de tests

Ceci imprime une liste de 5 valeurs booléennes. Ils indiquent les propriétés dans l'ordre:

[Idempotence, Commutativity, Identity, Closure, Associativity]

Voici un meilleur format de sortie: démonstration ou suite de tests

Explication:

Idempotence:

qKUQ@VQK
   Q       Q = input matrix
  UQ       [0, 1, ..., len(matrix)-1]
 K         assign to K
    @VQK   vectorized lookup of Q and K //gets the diagonal elements
qK         check, if this is equal to K

Commutativité:

CIQ   check if transpose(Q) is equal to Q

Identité:

}]Km{@RdCBQK
   m       K   map each d in K to:
        CBQ       the list [Q, transpose(Q)]
     @Rd          take the d-th element of each ^
    {             remove duplicates
}]K            check if [K] is in ^

Fermeture:

J!-sQK
   sQ    sum(Q) //all elements of Q
  -  K   remove the elements, that also appear in K
 !       ckeck, if the results in an empty list
J        store the result in J

Associativité:

&JqF.bsm@[email protected],sQK
               .p,sQK  all permutations of [sum(Q), K] //all 2 ;-)
    .b                 map each pair (N,Y) of ^ to:
       m      N           map each d of N to:
          @Qd                the row Q[d]
        @L   Y               map each element of Y to the corr. element in ^
      s                   unfold this 2-d list
  qF                   check if they result in identically lists
&J                     and J
Jakube
la source
5

Haskell, 178 171 octets

import Data.List
f x=[c,c&&and[(m%n)%o==m%(n%o)|m<-b,n<-b,o<-b],x==t,all(elem b)[x,t],b==[i%i|i<-b]]where c=all(l>)(id=<<x);b=[0..l-1];a%b=x!!a!!b;l=length x;t=transpose x

Renvoie une liste avec cinq booléens, qui sont en ordre de fermeture, associativité, commutativité, identité et idempotence.

Exemple d'utilisation: f [[1, 0, 0],[0, 1, 0],[0, 0, 1]]-> [True,False,True,False,False].

Comment ça fonctionne:

f x=[
  c,                         -- closure (see below)
  c&&and[(m%n)%o==m%(n%o)|   -- assoc: make sure it's closed, then check the
          m<-b,n<-b,o<-b],   --        assoc rule for all possible combinations
  x==t,                      -- comm: x must equal it's transposition
  all(elem b)[x,t],          -- identity: b must be a row and a column
  b==[i%i|i<-b]              -- idemp: element at (i,i) must equal i
  ]
  where                      -- some helper functions
  c=all(l>)(id=<<x);         -- closure: all elements of the input must be < l 
  b=[0..l-1];                -- a list with the numbers from 0 to l-1
  a%b=x!!a!!b;               -- % is an access function for index (a,b)
  l=length x;                -- l is the number of rows of the input matrix
  t=transpose x

Edit @xnor a trouvé quelques octets à enregistrer. Merci!

nimi
la source
Et alors c=all(l>)?
2015
Aussi [i%i|i<-b]==b.
2015
Très lisible pour le code-golf - sympa!
isaacg
4

CJam, 95 octets

q~:Ae_A,:Bf<:*'**B3m*{_{A==}*\W%{Az==}*=}%:*'A*A_z='C*B{aB*ee_Wf%+{A==}f*B,2*='1*}%Ae_B)%B,='I*

Imprime une sous-séquence de *AC1I. *est le symbole de la fermeture , Aest pour associatif , Cest pour commutatif , 1est pour identité et Iest pour idempotent .


Le tableau d'entrée est lu q~et stocké dans A ( :A).

Fermeture

Ae_A,:Bf<:*'**

Si tous les :*éléments ( ) de la matrice ( Ae_) sont inférieurs f<à B = taille (A) ( A,:B), imprimez a *( '**).

Associativité

B3m*{_{A==}*\W%{Az==}*=}%:*'A*

Générez tous les triplets dans le domaine ( B3m*). Nous imprimons As'ils remplissent tous une condition ( {...}%:*'A*).

La condition est que, pour certains triples [i j k], le pliage à gauche de cette liste avec A ( _{A==}*) et le pliage à gauche son inverse [k j i]( \W%) avec A op ( {Az==}*), la version inversée de A, soient égaux ( =).

Commutativité

A doit être égale à sa transposition: A_z=. Si c'est le cas, nous imprimons C( 'C=).

Identité

B{                         }%   For each element X in the domain (0..N-1):
  aB*                           Make N copies.
     ee                         [[0 X] [1 X] ...]
       _Wf%+                    [[0 X] [1 X] ... [X 0] [X 1] ...]
            {A==}f*             [A(0, X) A(1, X) ... A(X, 0) A(X, 1)]
                   B,2*=        This list should equal the domain list repeated twice.
                        '1*     If so, X is an identity: print a 1.

L'identité est nécessairement unique, nous ne pouvons donc en imprimer qu'une 1.

Idempotent

Ae_B)%B,='I*

Vérifiez si la diagonale est égale B,. Si oui, imprimez un I.

Lynn
la source
3

Matlab, 226

a=input('');n=size(a,1);v=1:n;c=all(0<=a(:)&a(:)<n);A=c;for i=v;for j=v(1:n*c);for k=v(1:n*c);A=A&a(a(i,j)+1,k)==a(i,a(j,k)+1);end;end;b(i)=all(a(i,:)==v-1 & a(:,i)'==v-1);end;disp([c,A,~norm(a-a'),any(b),all(diag(a)'==v-1)])

Une chose importante à noter est que non fermé implique non associatif. Beaucoup de ces propriétés peuvent facilement être vérifiées en utilisant certaines propriétés de la matrice:

  • Clôture : toutes les entrées de matrice dans la plage donnée?
  • Associativité : comme toujours la plus difficile à vérifier
  • Commutativité : la matrice est-elle symétrique?
  • Identité : existe-t-il un indice k tel que la k-ième ligne et la k-ième colonne soient exactement la liste des indices?
  • Idempotence : la diagonale correspond-elle à la liste des indices?

Entrée via la notation Matlab standard: [a,b;c,d]ou [[a,b];[c,d]]ou [a b;c d]etc

La sortie est un vecteur de zéros, 1 = vrai, 0 = faux, pour chacune des propriétés dans l'ordre donné.

Code complet:

a=input('');
n=size(a,1);
v=1:n;
c=all(0<=a(:)&a(:)<n);               %check for closedness
A=c;
for i=v;
   for j=v(1:n*c); 
      for k=v(1:n*c);
          A=A&a(a(i,j)+1,k)==a(i,a(j,k)+1);   %check for associativity (only if closed)
      end;
   end;
   b(i)=all(a(i,:)==v-1 & a(:,i)'==v-1);      %check for commutativity
end
%closure, assoc, commut, identity, idempotence
disp([c,A,~norm(a-a'),any(b),all(diag(a)'==v-1)]);
flawr
la source
3

JavaScript (ES6) 165

Une fonction anonyme renvoyant un tableau avec cinq valeurs 0/1, qui sont dans l'ordre Clôture, Associativité, Commutativité, Identité et Idempotence.

q=>q.map((p,i)=>(p.map((v,j)=>(w=q[j][i],v-w?h=C=0:v-j?h=0:0,q[v]?A&=!q[v].some((v,k)=>v-q[i][q[j][k]]):A=K=0),h=1,p[i]-i?P=0:0),h?I=1:0),A=P=K=C=1,I=0)&&[K,A,C,I,P]

Moins golfé

f=q=>(
  // A associativity, P idempotence, K closure, C commuativity
  // assumed true until proved false
  A=P=K=C=1, 
  I=0, // Identity assumed false until an identity element is found
  q.map((p,i)=> (
      h=1, // assume current i is identity until proved false
      p[i]-i? P=0 :0, // not idempotent if q[i][i]!=i for any i
      p.map((v,j)=> (
          w=q[j][i], // and v is q[i][j]
          v-w // check if q[j][i] != q[i][j]
          ? h=C=0 // if so, not commutative and i is not identity element too
          : v-j // else, check again for identity
            ? h=0 // i is not identity element if v!=j or w!=j
            : 0,
          q[v] // check if q[i][j] in domain
            ? A&=!q[v].some((v,k)=>v-q[i][q[j][k]]) // loop for associativity check
            : A=K=0 // q[i][j] out of domain, not close and not associative
        )
      ),
      h ? I=1 : 0 // if i is the identity element the identity = true
    )
  ),
  [K,A,C,I,P] // return all as an array
)

Tester

f=q=>
  q.map((p,i)=>(
    p.map((v,j)=>(
      w=q[j][i],
      v-w?h=C=0:v-j?h=0:0,
      q[v]?A&=!q[v].some((v,k)=>v-q[i][q[j][k]]):A=K=0
    ),h=1,p[i]-i?P=0:0),
    h?I=1:0
  ),A=P=K=C=1,I=0)
  &&[K,A,C,I,P]

// test

console.log=x=>O.textContent+=x+'\n';

T=[
 [
  [[0, 1, 2, 3],
   [1, 1, 2, 3],
   [2, 2, 2, 3],
   [3, 3, 3, 3]]
 ,[1,1,1,1,1]] // has the properties of closure, associativity, commutativity, identity and idempotence.
,[ // exponentiation function on domain n=3:
  [[1, 0, 0],
   [1, 1, 1],
   [1, 2, 4]]
 ,[0,0,0,0,0]] // has none of the above properties.
,[ // addition function on domain n=3:
  [[0, 1, 2],
   [1, 2, 3],
   [2, 3, 4]] 
 ,[0,0,1,1,0]] // has the properties of commutativity and identity.
,[ // K combinator on domain n=3:
  [[0, 0, 0],
   [1, 1, 1],
   [2, 2, 2]]
 ,[1,1,0,0,1]] // has the properties of closure, associativity and idempotence.
,[ // absolute difference function on domain n=3:
  [[0, 1, 2],
   [1, 0, 1],
   [2, 1, 0]]
 ,[1,0,1,1,0]] // has the properties of closure, commutativity and identity.
,[ // average function, rounding towards even, on domain n=3:
  [[0, 0, 1],
   [0, 1, 2],
   [1, 2, 2]]
 ,[1,0,1,1,1]] // has the properties of closure, commutativity, identity and idempotence.
,[ // equality function on domain n=3:
  [[1, 0, 0],
   [0, 1, 0],
   [0, 0, 1]]
 ,[1,0,1,0,0]] // has the properties of closure, commutativity,
]  

T.forEach(t=>{
  F=t[0],X=t[1]+'',R=f(F)+'',console.log(F.join`\n`+'\n'+R+' (expected '+X+') '+(X==R?'OK\n':'Fail\n'))
  })
<pre id=O></pre>

edc65
la source