二元函数的性质


14

抽象代数中的许多重要主题都涉及对集合起作用的二进制函数。在研究此类主题时,已定义了此类功能的许多属性。

您的挑战将是确定给定域上的给定二进制函数是否拥有这些属性中的五个。

物产

关闭

如果每个可能的输出都在域中,则关闭二进制函数。

关联性

如果将二进制函数应用于一系列输入的顺序不影响结果,则该二进制函数为关联函数。也就是说,$如果(a $ b) $ c始终等于,则是关联的a $ (b $ c)。请注意,由于该值(a $ b)用作输入,因此必须关闭关联功能。

可交换性

如果交换输入的顺序不会更改结果,则二进制函数是可交换的。换句话说,如果a $ b始终等于b $ a

身分识别

如果e域中存在某个元素,则二元函数将具有一个identity元素,a $ e = a = e $ a以便a该域中的所有元素都具有。

幂等

如果将二进制函数应用于两个相同的输入给出该数字作为输出,则该函数是幂等的。换句话说,如果是域中的a $ a = a所有人a

输入值

您将获得矩阵形式的函数,该函数的域为数字0 ... n-1,其中n为矩阵的边长。

该值(a $ b)在矩阵中被编码为第at行的bth元素。如果输入矩阵为Q,则a $ b=Q[a][b]

例如,**域上的幂函数(在Python中)[0, 1, 2]被编码为:

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

左域和右域是相同的,因此矩阵将始终为正方形。

您可以使用任何方便的矩阵格式作为输入,例如列表列表,以行或列为主要顺序的单个列表,语言的本机矩阵对象等。但是,您可能无法直接将函数用作输入。

为简单起见,矩阵条目均为整数。您可能会认为它们适合您语言的本机整数类型。

输出量

您可以指示上述哪种属性以您选择的任何格式保存,包括布尔值列表,每个属性具有不同字符的字符串等。但是,对于24个可能的子集,必须有不同的唯一输出属性。此输出必须易于理解。

例子

域n = 4上的最大函数:

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

此函数具有封闭,关联,可交换性,同一性和幂等的特性。

域n = 3上的幂函数:

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

此功能不具有以上属性。

域n = 3上的加法函数:

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

此功能具有可交换性和标识性。

域n = 3上的K组合器:

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

该功能具有封闭性,关联性和幂等性。

域n = 3上的绝对差函数:

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

此功能具有闭包,可交换性和标识性。

域n = 3上的平均函数四舍五入为偶数:

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

该函数具有封闭,可交换性,恒等式和幂等性。

域n = 3上的相等函数:

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

此函数具有闭包和可交换性的属性。

挑战

这是代码高尔夫。有标准漏洞。最少字节获胜。

Answers:


4

Pyth,51个字节

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

在线尝试:演示测试套件

这将打印5个布尔值的列表。它们按顺序指示属性:

[Idempotence, Commutativity, Identity, Closure, Associativity]

这是一种更好的输出格式:演示测试套件

说明:

幂等:

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

可交换性:

CIQ   check if transpose(Q) is equal to Q

身份:

}]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 ^

关闭:

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

关联性:

&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,178171字节

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

返回具有五个布尔值的列表,这些布尔值依次为闭包,关联性,可交换性,同一性和幂等。

用法示例:f [[1, 0, 0],[0, 1, 0],[0, 0, 1]]->[True,False,True,False,False]

怎么运行的:

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

编辑@xnor发现要保存的一些字节。谢谢!


怎么c=all(l>)
xnor

另外,[i%i|i<-b]==b
xnor

代码高尔夫非常可读-太好了!
isaacg 2015年

4

CJam,95个字节

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*

打印的子序列*AC1I*闭合的符号,A关联的C可交换的1同一性的I幂等的


读取输入数组q~并将其存储在A(:A)中。

关闭

Ae_A,:Bf<:*'**

如果:*矩阵(Ae_)中的所有()元素均小于f<B = size(A)(A,:B),则打印*'**)。

关联性

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

生成域(B3m*)中的所有三元组。A如果它们都满足条件({...}%:*'A*),我们将进行打印。

条件是,对于某些三元组[i j k],将列表用A_{A==}*)左折叠,并将其反向[k j i]\W%)用A op{Az==}*)左折叠,A将等于(=)。

可交换性

必须等于它的转置:A_z=。如果是这样,我们打印C'C=)。

身分识别

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.

身份必须是唯一的,所以我们只能打印一个 1

幂等

Ae_B)%B,='I*

检查对角线是否相等B,。如果是这样,请打印一个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)])

需要注意的重要一点是,非封闭意味着非关联。使用矩阵的某些属性可以轻松地检查其中的许多属性:

  • 关闭:所有给定范围内的矩阵条目?
  • 关联性:一如既往最难检查
  • 可交换性:矩阵对称吗?
  • 身份:是否存在索引k,以使第k行和第k列恰好是索引列表?
  • 等幂性:对角线是否对应于索引列表?

通过标准Matlab符号输入:[a,b;c,d][[a,b];[c,d]][a b;c d]

对于给定顺序的每个属性,输出是一个矢量,其值为零,1 = true,0 = false。

完整代码:

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

一个匿名函数,返回一个具有五个0/1值的数组,这些值的顺序为Closure,Associativity,Comutativity,Identity和等幂。

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]

少打高尔夫球

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
)

测试

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>

By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.