Verificar topología

25

Reto

Dado un conjunto Tde subconjuntos de un conjunto finito S={1,2,3,...,n}, determine si Tes una topología o no.

Explicación

El conjunto P(S) de potencia de algún conjunto Ses el conjunto de todos los subconjuntos de S. Algunos ejemplos:

S = {}, P(S) = {{}}
S = {1}, P(S) = {{}, {1}}
S = {1,2}, P(S) = {{}, {1}, {2}, {1,2}}
S = {1,2,3}, P(S) = {{}, {1}, {2}, {3}, {1,2}, {1,3}, {2,3}, {1,2,3}}

Una topología T en el conjunto Ses un subconjunto de P(S)con las siguientes propiedades:

  • {}está adentro Ty Sestá adentroT
  • Si Ay Bestán dentro, Tentonces también lo es su intersecciónA ∩ B
  • Si Ay Bestán dentro, Tentonces también lo está su unión A ∪ B*

* Esta definición no es del todo correcta, pero es cierta para conjuntos finitos, lo cual es suficiente para los propósitos de este desafío. El axioma real también permitiría uniones infinitas, pero eso es irrelevante en el caso finito.

Detalles

  • Puede suponer que S = {1,2,...,n}(o alternativamente S = {0,1,...,n}) donde nestá el número entero más grande que aparece en los conjuntos de T.
  • El formato de entrada es flexible: puede usar una cadena, una lista de listas o un conjunto de listas o cualquier formato similar que pueda manejar su idioma. También puede usar conjuntos como S = {0,1,...,n}si fuera más conveniente.
  • La salida debe ser truthey o falsey.
  • Se le permite tomar n(o alternativamente n+1o n-1) como entrada adicional.
  • Si trabaja con listas ordenadas, puede suponer que los números dentro de un conjunto están ordenados. También puede suponer que la lista tiene un cierto orden (por ejemplo, lexicográfico.
  • Como representamos conjuntos, puede suponer que no hay dos entradas de su representación de lista iguales.

Ejemplos

Topologías

{{}}  over {}
{{},{1}} over {1}
P(S) over S (see in the explanation)
{{},{1},{1,2}} over {1,2}
{{},{1},{2,3},{1,2,3}} over {1,2,3}
{{1}, {1,2,3}, {1,4,5,6}, {1,2,3,4,5,6}, {}, {2,3}, {4,5,6}, {2,3,4,5,6}}
{{}, {1}, {2,3}, {2}, {4,5,6}, {5,6}, {5}, {2,5,6}, {2,5}, {1,5}, {1,2,3,4,5,6}, {1,2,3}, {1,2}, {1,4,5,6}, {1,5,6}, {1,2,5,6}, {2,3,4,5,6}, {2,3,5,6}, {2,3,5}, {1,2,3,5}, {2,4,5,6}, {1,2,5}, {1,2,3,5,6}, {1,2,4,5,6}}
{{}, {1}, {1,2}, {1,2,3}, {1,2,3,4}, {1,2,3,4,5}, {1,2,3,4,5,6}, {1,2,3,4,5,6,7}, {1,2,3,4,5,6,7,8}, {1,2,3,4,5,6,7,8,9}}
{{}, {1}, {1,2,3}, {1,2,3,4,5}, {1,2,3,4,5,6,7}, {1,2,3,4,5,6,7,8,9}}

no topologías

{{1}} because {} is not contained
{{},{2}} because {1,2} is not contained
{{},{1,2},{2,3}} because the union {1,2,3} is not contained
{{},{1},{1,2},{2,3},{1,2,3}} because the intersection of {1,2} and {2,3} is not contained
{{},{1},{2},{3},{1,2},{2,3},{1,2,3}} because the union of {1} and {3} is not contained
{{}, {1}, {2,3}, {2}, {4,5,6}, {5,6}, {5}, {2,5,6}, {2,5}, {1,5}, {1,2,3,4,5,6}, {1,2,3}, {1,2}, {1,4,5,6}, {1,5,6}, {1,2,5,6}, {2,3,4,5,6}, {2,3,5,6}, {2,3,5}, {2,4,5,6}, {1,2,5}, {1,2,3,5,6}, {1,2,4,5,6}} because {1,2,3,5} is missing
{{}, {1}, {2}, {1,2,3}, {1,2,3,4,5}, {1,2,3,4,5,6,7}, {1,2,3,4,5,6,7,8,9}} because {1,2} is missing
code-golf  math  decision-problem  set-theory  topology 
— falla
fuente
2
Parece que muchas de las respuestas a esta pregunta estarían en la entrada {{}, {2}} porque no comprueban explícitamente que S está en el conjunto, mientras que para esa entrada, S se supone implícitamente que es {1, 2}. ¿Es esta una lectura válida de las especificaciones o me falta algo?
— Carmeister
@Carmeister Perdón por la confusión, sí, ¡su interpretación es correcta!
— flawr
¿Puede la entrada ser una matriz binaria donde cada fila es un conjunto, cada columna es un elemento y el valor indica si el elemento está en el conjunto?
— Luis Mendo
Sí, creo que eso es aceptable.
— flawr
Como Tes un conjunto, creo que es razonable suponer que no se repite ningún subconjunto en la entrada ( {{}, {1,2}, {1,2}}es decir, no es una entrada válida). ¿Puedes aclarar eso en el desafío, ya sea afirmativa o negativamente?
— Luis Mendo

Respuestas:

7

Python 2 , 117 99 97 91 bytes

n,x=input();sum(set.union(*x))!=n*-~n/2>q
[map(x.index,(i-i,i|j,i&j))for i in x for j in x]

Pruébalo en línea!

La salida es a través del código de salida

— ovs
fuente
5

Haskell , 95 89 74 78 bytes

import Data.List
t#n=all(`elem`t)$sort<$>[1..n]:[]:([union,intersect]<*>t<*>t)

Pruébalo en línea!

Explicación:

                              ([union,intersect]<*>t<*>t) -- create all unions & intersections 
                    [1..n]:[]:                            -- add the empty list and the full list
             sort<$>                                --sort them all
                                -- (as 'union' does not necessarily produce sorted outputs)
all(`elem`t)$                   -- check whether they are all already contained
— falla
fuente
¿Qué hay de [[],[2]]? Es una topología, pero no sobre el conjunto implícito ("Puede suponer que ...").
— Christian Sievers
@ChristianSievers corregido!
— flawr
5

Mathematica, 87 73 66 63 bytes

Outer[{#⋂#2,#⋃#2}&,#,#,1]~Flatten~2⋃{{},Range@#2}==#⋃#&

Toma [T, n]como entrada.

Explicación

{#⋂#2,#⋃#2}&

Función que devuelve la intersección y la unión de las entradas.

Outer[ ... ,#,#,1]

Asigna esa función a la lista de entrada en el nivel 1.

... ~Flatten~2

Acoplar el resultado (la Outerparte devuelve un montón de Lists anidados ).

... ⋃{{},Range@#2}

Tome la unión entre la lista aplanada y {{}, S}. Esto elimina duplicados y agrega {}y Sa la lista resultante.

... ==#⋃#

Compruebe si la lista de arriba es igual a la versión ordenada de la entrada.

— JungHwan Min
fuente
4

MATL , 38 bytes

!t~hXAs1>GXBXH2Z^!"@Z}Z|1MZ&hHm]vAGn~+

La entrada es una matriz binaria donde cada fila es un conjunto, cada columna es un elemento y cada entrada indica membresía. Por ejemplo, {{},{1},{1,2}}se expresa como [0 0;1 0;1 1]. Use el programa Octave vinculado para convertir a este formato.

Pruébalo en línea! O verificar todos los casos de prueba .

Explicación

!        % Implicit input. Transpose
t~       % Push a negated copy
h        % Horizontally concatenate both matrices
XA       % All: true for columns containing only 1
s        % Sum
1>       % Does it exceed 1? If so, both the empty set and the total
         % set are in the input
G        % Push input again
XB       % Convert each row from binary to decimal. This gives a column
         % vector of numbers that encode each set's contents. Union and
         % intersection will be done as bitwise XOR and AND
XH       % Copy to clipboard H
2Z^!     % Cartesian square transposed: gives all pairs of numbers as
         % columns of a matrix
"        % For each column
  @      %   Push current column
  Z}     %   Split into the two numbers
  Z|     %   Bitwise XOR
  1M     %   Push the two numbers again
  Z&     %   Bitwise AND
  h      %   Concatenate the two results horizontally
  Hm     %   Are they members of the vector of encoded sets? This gives
         %   a row vector with the two results
]        % End
v        % Concatenate all stack contents into a vertical vector
A        % Does it only contain ones? This is the main result: true iff
         % input is a non-empty topology. The empty input gives false,
         % and so it needs to be special cased
G        % Push input again
n~       % Is it empty?
+        % Add thw two results. Implicit display
— Luis Mendo
fuente
1
D: ¡tu programa ocupa más espacio que tu título!
— flawr
3

Python 2 , 92 71 122 bytes

  • Muchas gracias a @ovs por una gran reducción de 19 bytes: &y |shorthands para las operaciones de configuración.
  • Gracias @notjagan por 5 bytes
  • Gracias a @ovs por 2 bytes: set()comoi-i

Lambda que toma una lista de conjuntos como entrada y devuelve Verdadero / falso. Simplemente comprueba si hay un conjunto vacío y la unión e intersección de cada conjunto (dos conjuntos iterados como iy j) existe en la lista de conjuntos dada.

lambda x:x.sort()or all(k in x[-1]for k in range(1,max(x[-1])))and all(a in x for i in x for j in x for a in[i-j,i|j,i&j])

Pruébalo en línea!

— officialaimm
fuente
1
— ovs
@ovs Muchas gracias, no conocía a los shorthands!
— officialaimm
@ovs En realidad estoy convirtiendo explícitamente los elementos de la lista de input()a set()en el pie de página.
— officialaimm
1
— notjagan
1
Puede reemplazar set()con i-ioi^i
— ovs
2

CJam (23 bytes)

{[,M2$2m*{_~&\~|$}/]^!}

Conjunto de pruebas en línea . Este es un bloque anónimo (función). Asumo S = {0,1,...,n}; el bloque toma una matriz de matrices ordenadas y n+1como parámetros y las deja 0o 1en la pila. En el caso, {{}}el código y el marco de prueba asumen eso n+1 = 0.

— Peter Taylor
fuente
2

Pyth, 24 23 bytes

q@aasm,@Fd{Ssd*QQYJUEyJ

Banco de pruebas

Este programa toma la entrada como una lista ordenada de listas ordenadas. Las listas internas deben estar en orden ascendente y la lista de orden debe estar ordenada por longitud y luego lexicográficamente. He confirmado que este es un formato de entrada permitido. Los números comienzan en 0, y N + 1 también se toma como entrada.

En cuanto a cómo funciona, filtramos todo lo que no está en P (S), luego agregamos S, []la intersección de cada par y la unión de cada par, deduplicamos y verificamos que el resultado sea igual a la entrada.

— isaacg
fuente
0

Axioma, 358 bytes

t(a,s)==(aa:=sort(removeDuplicates(a));ss:=sort(removeDuplicates(s));a:=sort(a);s:=sort(s);a~=aa or s~=ss=>false;a:=map(sort, a);~member?([],a) or ~member?(s,a)=>false;for x in a repeat(for j in x repeat if ~member?(j,s) then return false;for y in a repeat if ~member?(sort(setIntersection(x,y)),a) or ~member?(sort(setUnion(x,y)),a) then return false);true)

sin golf y resultados:

-- all the List have to be sorted because in list [1,2]~=[2,1]
-- So here "set" means: "List without duplicate, sorted with sort() function"
-- Return true if 
-- 1) a,s are set for above definition
-- 2) a is in P(s) 
-- 3) s,[] are in a
-- 4) for all x and y in a => xUy is in a and x intersect y is in a
t1(a:List List INT, s:List INT):Boolean==
    aa:=sort(removeDuplicates(a));ss:=sort(removeDuplicates(s))
    a :=sort(a);                  s :=sort(s)
    a~=aa          or s~=ss        =>false   -- they are not sets but list with element duplicate
    a:=map(sort, a)                          -- subset of a has to be sorted too
    ~member?([],a) or ~member?(s,a)=>false
    for x in a repeat
       for j in x repeat if ~member?(j,s) then return false 
       for y in a repeat if ~member?(sort(setIntersection(x,y)),a) or ~member?(sort(setUnion(x,y)),a) then return false
    true

(4) -> t([[]], [])
   (4)  true
                                                            Type: Boolean
(5) -> t([[],[1]], [1])
   (5)  true
                                                            Type: Boolean
(6) -> t([[],[1],[2,1]], [1,2])
   (6)  true
                                                            Type: Boolean
(7) -> t([[],[1],[2,3],[1,2,3]], [3,1,2])
   (7)  true
                                                            Type: Boolean
(8) -> t([[1], [1,2,3], [1,4,5,6], [1,2,3,4,5,6], [], [2,3], [4,5,6], [2,3,4,5,6]], [1,2,3,4,5,6])
   (8)  true
                                                            Type: Boolean
(9) -> t([[], [1], [2,3], [2], [4,5,6], [5,6], [5], [2,5,6], [2,5], [1,5], [1,2,3,4,5,6], [1,2,3], [1,2], [1,4,5,6], [1,5,6], [1,2,5,6], [2,3,4,5,6], [2,3,5,6], [2,3,5], [1,2,3,5], [2,4,5,6], [1,2,5], [1,2,3,5,6], [1,2,4,5,6]], [1,2,3,4,5,6])
   (9)  true
                                                            Type: Boolean
(10) -> t([[], [1], [1,2], [1,2,3], [1,2,3,4], [1,2,3,4,5], [1,2,3,4,5,6], [1,2,3,4,5,6,7], [1,2,3,4,5,6,7,8], [1,2,3,4,5,6,7,8,9]], [1,2,3,4,5,6,7,8,9])
   (10)  true
                                                            Type: Boolean
(11) -> t([[], [1], [1,2,3], [1,2,3,4,5], [1,2,3,4,5,6,7], [1,2,3,4,5,6,7,8,9]], [1,2,3,4,5,6,7,8,9])
   (11)  true
                                                            Type: Boolean
(2) -> t([[1]], [1])
   (2)  false
                                                            Type: Boolean
(4) -> t([[],[2]], [1,2])
   (4)  false
                                                            Type: Boolean
(5) -> t([[],[1,2],[2,3]], [1,2,3])
   (5)  false
                                                            Type: Boolean
(6) -> t([[],[1],[1,2],[2,3],[1,2,3]], [1,2,3])
   (6)  false
                                                            Type: Boolean
(7) -> t([[],[1],[2],[3],[1,2],[2,3],[1,2,3]] , [1,2,3])
   (7)  false
                                                            Type: Boolean
(8) -> t([[], [1], [2,3], [2], [4,5,6], [5,6], [5], [2,5,6], [2,5], [1,5],[1,2,3,4,5,6], [1,2,3], [1,2], [1,4,5,6], [1,5,6], [1,2,5,6], [2,3,4,5,6], [2,3,5,6], [2,3,5], [2,4,5,6], [1,2,5], [1,2,3,5,6], [1,2,4,5,6]], [1,2,3,4,5,6])
   (8)  false
                                                            Type: Boolean
(9) -> t([[], [1], [2], [1,2,3], [1,2,3,4,5], [1,2,3,4,5,6,7], [1,2,3,4,5,6,7,8,9]] , [1,2,3,4,5,6,7,8,9])
   (9)  false
                                                            Type: Boolean
(10) -> t([[], [1], [2,3], [2], [4,5,6], [5,6], [5], [2,5,6], [2,5], [1,5],[1,2,3,4,5,6], [1,2,3], [1,2], [1,4,5,6], [1,5,6], [1,2,5,6], [2,3,4,5,6], [2,3,5,6], [2,3,5], [2,4,5,6], [1,2,5], [1,2,3,5,6], [1,2,4,5,6]], [1,2,3,4,5,6])
   (10)  false
                                                            Type: Boolean
— RosLuP
fuente
Al usar nuestro sitio, usted reconoce que ha leído y comprende nuestra Política de Cookies y Política de Privacidad.
Licensed under cc by-sa 3.0 with attribution required.