¿Alguien sabe de un contraejemplo del algoritmo de isomorfismo gráfico Dharwadker-Tevet?


10

En http://www.dharwadker.org/tevet/isomorphism/ , hay una presentación de un algoritmo para determinar si dos gráficos son isomorfos. Teniendo en cuenta una serie de afirmaciones "interesantes" de A Dharwadker, no estoy dispuesto a creerlo.

En mi investigación, encuentro que el algoritmo definitivamente producirá la respuesta correcta y le diré que dos gráficos no son isomórficos cuando en realidad es correcto. Sin embargo, no está claro que el algoritmo le diga constantemente si dos gráficos son isomórficos cuando en realidad lo son. La "prueba" de su resultado deja algo que desear.

Sin embargo, no conozco un contraejemplo. Antes de comenzar a escribir software para probar el algoritmo, pensé que vería si alguien ya conocía un contraejemplo.

Alguien solicitó una sinopsis del algoritmo. Haré lo que pueda aquí, pero para entenderlo realmente, debe visitar http://www.dharwadker.org/tevet/isomorphism/ .

El algoritmo tiene dos fases: una fase de "firma" y una fase de clasificación. La primera fase de "firma" (este es mi término para su proceso; lo llaman generar la "matriz de signos") clasifica efectivamente los vértices en diferentes clases de equivalencia. La segunda fase primero ordena los vértices de acuerdo con su clase de equivalencia, y luego aplica un procedimiento de clasificación dentro de las clases de equivalencia para establecer un isomorfismo entre los dos gráficos. Curiosamente, no pretenden establecer una forma canónica para los gráficos; en cambio, un gráfico se usa como una especie de plantilla para el segundo.

La fase de firma es realmente bastante interesante, y no le haría justicia aquí al intentar parafrasearla. Si desea más detalles, le recomiendo seguir el enlace para examinar su fase de firma. La "matriz de signos" generada ciertamente retiene toda la información sobre el gráfico original y luego establece un poco más de información. Después de recopilar las firmas, ignoran la matriz original, ya que las firmas contienen toda la información sobre la matriz original. Baste decir que la firma realiza alguna operación que se aplica a cada borde relacionado con el vértice y luego recolecta el conjunto múltiple de elementos para un vértice para establecer una clase de equivalencia para el vértice.

La segunda fase, la fase de clasificación, es la parte que es dudosa. En particular, esperaría que si su proceso funcionara, entonces el algoritmo desarrollado por Anna Lubiw para proporcionar un "Orden de matrices doblemente léxico" (Ver: http://dl.acm.org/citation.cfm?id=22189 ) También funcionaría para definir una forma canónica para un gráfico.

Para ser justos, no entiendo completamente su proceso de clasificación, aunque creo que hacen un trabajo razonable al describirlo. (Simplemente no he trabajado con todos los detalles). En otras palabras, me puede faltar algo. Sin embargo, no está claro cómo este proceso puede hacer mucho más que encontrar accidentalmente un isomorfismo. Claro, probablemente lo encontrarán con alta probabilidad, pero no con garantía. Si las dos gráficas no son isomorfas, el proceso de clasificación nunca lo encontrará y el proceso rechaza correctamente las gráficas.


¿Puedes dar un resumen de la idea del algoritmo?
Mohammad Al-Turkistany

1
ver también math.stackexchange.com/questions/333633/… . Esto solo muestra que hay una buena oportunidad de encontrar un contraejemplo para el programa provisto, pero todavía hay que encontrar uno ...
Thomas Klimpel

Los gráficos muy regulares parecen una buena apuesta, pero no he tenido suerte con las permutaciones seleccionadas al azar del gráfico de Petersen, el gráfico de Clebsch o el gráfico de torre de 4x4.
Peter Taylor

Del mismo modo, probé el gráfico Shrikhande, pero no probé todas las permutaciones. Le envié un correo electrónico a Anna Lubiw para pedirle contraejemplos a su "Orden de matrices doblemente léxico", pero ella no ha respondido (al menos no todavía). Sospecho que tendré que hacer una búsqueda más sistemática.
Bill Province

1
no sienta que está prestando un servicio al omitir afirmaciones extravagantes del artículo, aunque es probable que levante banderas en este sitio. ¿Cuáles son sus extravagantes afirmaciones que te hacen escéptico? tal vez afirman que tiene un rendimiento rápido, pero eso no se puede refutar con un solo contraejemplo. es decir, es posible que el algoritmo sea correcto (no se ha buscado) pero el análisis de complejidad está desactivado. de todos modos, invite a una discusión más profunda / análisis más profundo en el chat teórico de ciencias de la computación , donde varios visitantes han expresado un interés significativo en GI en el pasado y hay una discusión extendida reciente.
vzn

Respuestas:


18

Para graphA.txt:

25
 0 1 1 1 1 1 1 1 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0
 1 0 1 1 1 1 1 0 0 0 0 0 0 1 1 1 1 1 1 0 0 0 0 0 0
 1 1 0 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1
 1 1 1 0 0 0 0 1 1 1 0 0 0 1 1 1 0 0 0 1 1 1 0 0 0
 1 1 1 0 0 0 0 1 0 0 1 1 0 1 0 0 1 1 0 1 0 0 1 1 0
 1 1 1 0 0 0 0 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
 1 1 1 0 0 0 0 0 0 1 0 1 1 0 0 1 0 1 1 0 0 1 0 1 1
 1 0 0 1 1 0 0 0 1 1 1 0 0 1 0 1 0 0 1 0 0 0 1 1 1
 1 0 0 1 0 1 0 1 0 1 0 0 1 0 0 0 1 1 1 1 0 1 1 0 0
 1 0 0 1 0 0 1 1 1 0 0 1 0 0 1 0 1 1 0 0 1 0 0 1 1
 1 0 0 0 1 1 0 1 0 0 0 1 1 0 1 1 0 0 1 1 1 0 0 1 0
 1 0 0 0 1 0 1 0 0 1 1 0 1 1 1 0 0 1 0 0 1 1 1 0 0
 1 0 0 0 0 1 1 0 1 0 1 1 0 1 0 1 1 0 0 1 0 1 0 0 1
 0 1 0 1 1 0 0 1 0 0 0 1 1 0 1 1 1 0 0 0 0 1 1 0 1
 0 1 0 1 0 1 0 0 0 1 1 1 0 1 0 0 1 0 1 0 1 1 0 1 0
 0 1 0 1 0 0 1 1 0 0 1 0 1 1 0 0 0 1 1 1 1 0 0 0 1
 0 1 0 0 1 1 0 0 1 1 0 0 1 1 1 0 0 1 0 1 0 0 0 1 1
 0 1 0 0 1 0 1 0 1 1 0 1 0 0 0 1 1 0 1 1 1 0 1 0 0
 0 1 0 0 0 1 1 1 1 0 1 0 0 0 1 1 0 1 0 0 0 1 1 1 0
 0 0 1 1 1 0 0 0 1 0 1 0 1 0 0 1 1 1 0 0 1 1 0 1 0
 0 0 1 1 0 1 0 0 0 1 1 1 0 0 1 1 0 1 0 1 0 0 1 0 1
 0 0 1 1 0 0 1 0 1 0 0 1 1 1 1 0 0 0 1 1 0 0 1 1 0
 0 0 1 0 1 1 0 1 1 0 0 1 0 1 0 0 0 1 1 0 1 1 0 0 1
 0 0 1 0 1 0 1 1 0 1 1 0 0 0 1 0 1 0 1 1 0 1 0 0 1
 0 0 1 0 0 1 1 1 0 1 0 0 1 1 0 1 1 0 0 0 1 0 1 1 0

y graphB.txt:

25
 0 0 0 1 1 0 0 0 0 1 1 1 1 0 0 1 0 1 1 0 1 1 0 1 0
 0 0 1 1 1 1 1 0 0 0 0 0 0 0 1 1 0 0 1 1 1 1 0 0 1
 0 1 0 1 0 0 1 1 1 0 1 0 0 0 0 1 0 1 1 1 0 0 1 1 0
 1 1 1 0 1 0 1 1 1 1 1 1 0 0 1 0 0 0 0 0 0 1 0 0 0
 1 1 0 1 0 0 0 0 1 1 0 0 0 1 1 1 1 0 0 1 1 0 0 1 0
 0 1 0 0 0 0 1 0 0 1 1 0 0 0 1 0 1 1 0 0 1 1 1 1 1
 0 1 1 1 0 1 0 0 1 1 0 0 1 1 0 0 1 1 1 0 0 1 0 0 0
 0 0 1 1 0 0 0 0 1 0 1 1 1 0 1 0 1 1 0 1 1 0 0 0 1
 0 0 1 1 1 0 1 1 0 1 0 0 1 1 0 0 0 0 0 0 1 0 1 1 1
 1 0 0 1 1 1 1 0 1 0 0 1 0 0 0 1 1 1 0 0 0 0 1 0 1
 1 0 1 1 0 1 0 1 0 0 0 0 1 0 1 1 1 0 0 0 0 1 1 1 0
 1 0 0 1 0 0 0 1 0 1 0 0 0 1 1 0 0 1 1 1 0 1 1 0 1
 1 0 0 0 0 0 1 1 1 0 1 0 0 1 0 1 1 0 1 0 1 1 0 0 1
 0 0 0 0 1 0 1 0 1 0 0 1 1 0 1 0 1 0 1 1 0 1 1 1 0
 0 1 0 1 1 1 0 1 0 0 1 1 0 1 0 0 1 0 1 0 1 0 1 0 0
 1 1 1 0 1 0 0 0 0 1 1 0 1 0 0 0 1 0 1 1 0 0 1 0 1
 0 0 0 0 1 1 1 1 0 1 1 0 1 1 1 1 0 1 0 1 0 0 0 0 0
 1 0 1 0 0 1 1 1 0 1 0 1 0 0 0 0 1 0 1 1 1 0 0 1 0
 1 1 1 0 0 0 1 0 0 0 0 1 1 1 1 1 0 1 0 0 1 0 1 0 0
 0 1 1 0 1 0 0 1 0 0 0 1 0 1 0 1 1 1 0 0 0 1 0 1 1
 1 1 0 0 1 1 0 1 1 0 0 0 1 0 1 0 0 1 1 0 0 0 0 1 1
 1 1 0 1 0 1 1 0 0 0 1 1 1 1 0 0 0 0 0 1 0 0 0 1 1
 0 0 1 0 0 1 0 0 1 1 1 1 0 1 1 1 0 0 1 0 0 0 0 1 1
 1 0 1 0 1 1 0 0 1 0 1 0 0 1 0 0 0 1 0 1 1 1 1 0 0
 0 1 0 0 0 1 0 1 1 1 0 1 1 0 0 1 0 0 0 1 1 1 1 0 0

que se obtiene graphA.txtaplicando la permutación (aleatoria)

 22 9 24 11 15 8 5 18 13 14 2 10 23 0 3 17 4 16 6 19 7 21 12 1 20

El programa C ++ isororphism.cppde la Figura 6.3. Un programa C ++ para el algoritmo de isomorfismo gráfico en http://www.dharwadker.org/tevet/isomorphism/ ofrece el siguiente resultado:

The Graph Isomorphism Algorithm
by Ashay Dharwadker and John-Tagore Tevet
http://www.dharwadker.org/tevet/isomorphism/
Copyright (c) 2009
Computing the Sign Matrix of Graph A...
Computing the Sign Matrix of Graph B...
Graph A and Graph B have the same sign frequency vectors in lexicographic order but cannot be isomorphic.
See result.txt for details.

Por lo tanto, podemos suponer que este es un contraejemplo del algoritmo de isomorfismo gráfico Dharwadker-Tevet.

Como lo sugirió Bill Province, el problema es

GAGB

La objeción de Bill Province es que la prueba de la Proposición 4.1. no utiliza ninguna propiedad especial de la matriz de signos que no se aplique también a la matriz de adyacencia. Más precisamente, el siguiente paso en la prueba es incorrecto:

1,...,tAB1,...,tAv1,...,vt1,...,tBφ(v1)=v1,...,φ(vt)=vt respectivamente.

porque incluso si las filas han coincidido perfectamente, no se sigue que las etiquetas de vértice coincidan con las etiquetas dadas por cualquier isomorfismo .φ

Debido a que se identificó un agujero en la prueba de corrección, el contraejemplo anterior debería ser suficiente para refutar la corrección alegada del algoritmo propuesto.


Agradecimientos El contraejemplo es el primero de los octavos pares de gráficos de

http://funkybee.narod.ru/graphs.htm

Para manipular gráficos, utilicé y modifiqué el código fuente de ScrewBoxR1160.tar que se encuentra en

https://people.mpi-inf.mpg.de/~pascal/software/

Para comprender el agujero en la prueba de corrección, el comentario de András Salamon sobre Weisfeiler-Lehman fue muy útil, al igual que las explicaciones de

http://users.cecs.anu.edu.au/~pascal/docs/thesis_pascal_schweitzer.pdf

Vzn proporcionó la motivación para usar esta pregunta como una oportunidad para familiarizarse con la náutica / Traces y los aspectos prácticos del isomorfismo gráfico. El beneficio de aprender a usar programas de última generación para los isomorfismos de gráficos hizo que valiera la pena dedicar algo de tiempo para encontrar un contraejemplo (que creía firmemente que existía).


Gracias por la respuesta muy detallada. ¿Hubo algún criterio de selección que utilizó para el gráfico para encontrar el contraejemplo? Una vez que se seleccionó el contraejemplo, su comentario parece sugerir que la permutación se eligió al azar. ¿Era esto cierto? ¿O había algo más en la selección de la permutación?
Bill Province

@BillProvince El criterio de selección se basó en el comentario de András Salamon, porque indicaba que una construcción de Cai, Fürer e Immerman podría tener éxito. Primero probé un ejemplo n = 546 de Pascal Schweitzer, pero el programa original de C ++ isororphism.cpp ahora está computando desde> 1566 minutos. Utilicé mejores estructuras de datos y aprendí después de> 2h que el gran contraejemplo funciona. Sabía que trg787 / funkybee tenía algunas construcciones de Cai, Fürer e Immerman entre sus pares de gráficos, así que probé suerte. Intenté múltiples permutaciones aleatorias (para el ejemplo n = 25), la segunda funcionó.
Thomas Klimpel

cuál es el ahorro de tiempo, 1. encontrar un contraejemplo 2. probar 4.1 está mal.
Jim

Detuve el programa original de C ++ isoromorphism.cpp para el ejemplo n = 546 ahora, después de ejecutar durante más de 6200 minutos sin un final a la vista.
Thomas Klimpel

@ThomasKlimpel Planeo escribir un artículo que mencione este resultado. Si tiene una atribución profesional preferida, puede enviarme esa atribución por correo electrónico a billprovince@gmail.com. En cualquier caso, tengo la intención de seguir los requisitos de atribución publicados en blog.stackexchange.com/2009/06/attribution-required .
Bill Province
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.