Proprietà delle funzioni binarie


14

Molti argomenti importanti dell'algebra astratta riguardano una funzione binaria che agisce su un set. Nell'indagine su tali argomenti sono state definite alcune proprietà di tali funzioni.

La tua sfida consisterà nel determinare se una determinata funzione binaria su un determinato dominio possiede cinque di queste proprietà.

Proprietà

Chiusura

Una funzione binaria viene chiusa se ogni possibile output è nel dominio.

Associatività

Una funzione binaria è associativa se l'ordine in cui la funzione viene applicata a una serie di input non influisce sul risultato. Cioè, $è associativo se è (a $ b) $ csempre uguale a $ (b $ c). Si noti che poiché il valore (a $ b)viene utilizzato come input, le funzioni associative devono essere chiuse.

commutativity

Una funzione binaria è commutativa se lo scambio dell'ordine degli input non modifica il risultato. In altre parole, se è a $ bsempre uguale b $ a.

Identità

Una funzione binaria ha un elemento identità se esiste qualche elemento enel dominio tale che a $ e = a = e $ aper tutti anel dominio.

idempotence

Una funzione binaria è idempotente se applicandola a due input identici si ottiene quel numero come output. In altre parole, se a $ a = aper tutti anel dominio.

Ingresso

Ti verrà data una funzione sotto forma di matrice, e il dominio della funzione saranno i numeri 0 ... n-1, dove si ntrova la lunghezza laterale della matrice.

Il valore (a $ b)è codificato nella matrice come elemento th adella riga b. Se la matrice di input è Q, allora a $ b=Q[a][b]

Ad esempio, la funzione di esponenziazione ( **in Python) sul dominio [0, 1, 2]è codificata come:

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

I domini sinistro e destro sono gli stessi, quindi la matrice sarà sempre quadrata.

È possibile utilizzare qualsiasi formato matrice conveniente come input, come un elenco di elenchi, un singolo elenco in ordine di riga o colonna, l'oggetto matrice nativo della propria lingua, ecc. Tuttavia, non è possibile utilizzare direttamente una funzione come input.

Per semplicità, le voci della matrice saranno tutte numeri interi. Puoi presumere che si adattino al tipo intero nativo della tua lingua.

Produzione

È possibile indicare quale delle proprietà di cui sopra è valida in qualsiasi formato scelto, incluso un elenco di valori booleani, una stringa con un carattere diverso per ogni proprietà, ecc. Tuttavia, deve esserci un output distinto e unico per ciascuno dei 24 possibili sottoinsiemi delle proprietà. Questo output deve essere facilmente leggibile dall'uomo.

Esempi

La funzione massima sul dominio n = 4:

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

Questa funzione ha le proprietà di chiusura, associatività, commutatività, identità e idempotenza.

La funzione di esponenziazione sul dominio n = 3:

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

Questa funzione non ha nessuna delle proprietà sopra.

La funzione di aggiunta sul dominio n = 3:

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

Questa funzione ha le proprietà della commutatività e dell'identità.

Il combinatore K sul dominio n = 3:

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

Questa funzione ha le proprietà di chiusura, associatività e idempotenza.

La funzione di differenza assoluta sul dominio n = 3:

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

Questa funzione ha le proprietà di chiusura, commutatività e identità.

La funzione media, arrotondando a pari, sul dominio n = 3:

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

Questa funzione ha le proprietà di chiusura, commutatività, identità e idempotenza.

La funzione di uguaglianza sul dominio n = 3:

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

Questa funzione ha le proprietà di chiusura e commutatività.

Sfida

Questo è il codice golf. Si applicano scappatoie standard . Vince il minimo byte.

Risposte:


4

Pyth, 51 byte

[qKUQ@VQKCIQ}]Km{@RdCBQKJ!-sQK&JqF.bsm@L@QdYN.p,sQK

Provalo online: dimostrazione o Test Suite

Questo stampa un elenco di 5 valori booleani. Indicano le proprietà nell'ordine:

[Idempotence, Commutativity, Identity, Closure, Associativity]

Ecco un formato di output migliore: Demonstration o Test Suite

Spiegazione:

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

commutativity:

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 ^

Chiusura:

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@L@QdYN.p,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

5

Haskell, 178 171 byte

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

Restituisce un elenco con cinque booleani, che sono in ordine di chiusura, associatività, commutatività, identità e idempotenza.

Esempio di utilizzo: f [[1, 0, 0],[0, 1, 0],[0, 0, 1]]-> [True,False,True,False,False].

Come funziona:

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

Modifica @xnor ha trovato alcuni byte da salvare. Grazie!


Che ne dici c=all(l>)?
xnor

Inoltre, [i%i|i<-b]==b.
xnor

Molto leggibile per code-golf - bello!
isaacg,

4

CJam, 95 byte

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*

Stampa una sottosequenza di *AC1I. *è il simbolo per la chiusura , Aè per associativo , Cè per commutativo , 1è per identità ed Iè per idempotente .


L'array di input viene letto q~e memorizzato in A ( :A).

Chiusura

Ae_A,:Bf<:*'**

Se tutti gli :*elementi ( ) nella matrice ( Ae_) sono più piccoli f<di B = size (A) ( A,:B), stampa a *( '**).

Associatività

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

Genera tutte le triple nel dominio ( B3m*). Stampiamo Ase soddisfano tutti una condizione ( {...}%:*'A*).

La condizione è che, per alcuni triple [i j k], piegare a sinistra l'elenco con A ( _{A==}*) e piegare a sinistra il suo rovescio [k j i]( \W%) con A op ({Az==}*), la versione capovolta diA, siano uguali (=).

commutativity

UN deve essere uguale sua trasposta: A_z=. In tal caso, stampiamo 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à è necessariamente unica, quindi possiamo stamparne solo una 1.

idempotente

Ae_B)%B,='I*

Controlla se la diagonale è uguale B,. In tal caso, stampare un I.


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)])

Una cosa importante da notare è che non chiuso implica non associativo. Molte di queste proprietà possono essere facilmente verificate utilizzando alcune proprietà della matrice:

  • Chiusura : tutte le voci della matrice nell'intervallo indicato?
  • Associatività : come sempre la più difficile da controllare
  • commutativity : la matrice è simmetrica?
  • Identità : esiste un indice k tale che la k-esima riga e la k-esima colonna sono esattamente l'elenco degli indici?
  • idempotence : la diagonale corrisponde all'elenco degli indici?

Inserimento tramite notazione Matlab standard: [a,b;c,d]o[[a,b];[c,d]] oppure [a b;c d]ecc

L'output è un vettore di uno a zero, 1 = vero, 0 = falso, per ciascuna delle proprietà nell'ordine dato.

Codice completo:

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)]);

3

JavaScript (ES6) 165

Una funzione anonima che restituisce un array con cinque valori 0/1, che sono in ordine di chiusura, associatività, commutatività, identità e idempotenza.

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]

Meno 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
)

Test

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>

Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.