Mensaje original en formato texto

From: javier@eb2dsn.ampr.org (Javier Cantero)
Newsgroups: linux.debian.spanish
Subject: Re: Si al pasar a potato me potatizé, cuando pase a woody me...
Date: Sat, 9 Sep 2000 11:15:35 +0200

>Recapitulando, la nueva * es asociativa, existe el elemento neutro y
>todo elemento de string' tiene simétrico ==> el par (string', *) es un
>grupo. Pero no es abeliano :-|

    De todas formas, déjame que demuestre un teorema, que lo necesitaré luego.

    Sean los strings a y b, se cumple

            a = b * a * 1/b = 1/b * a * b
             [1]           [2]

    Demostración:

a = b * a * 1/b   => 1/b * a = 1/b * ( b * a * 1/b ) = ( 1/b * b ) * a * 1/b )
{asociatividad} = a * 1/b {elemento inverso} => 1/b * a * b = a * 1/b * b =
a * ( 1/b * b ) {elemento inverso} = a  con lo que se demuestra [1]

sabiendo [1], es fácil deducir [2]

       {por [1] tomando c = b * a * 1/b }

1/b * a * b = c * ( 1/b * a * b ) * 1/c  si tomamos c=b =>
1/b * a * b = b * ( 1/b * a * b ) * 1/b {asociatividad} =>
1/b * a * b = ( b * 1/b ) * a * (b * 1/b ) {elemento inverso} =>
1/b * a * b = a  y a partir nuevamente de [1]
1/b * a * b = b * a * 1/b

Por ejemplo:

potato * x * 1/potato = x =>
1/potato * ( potato * x * 1/potato ) = 1/potato * x
1/potato * ( potato * x * 1/potato ) * potato = 1/potato * x * potato
agrupando y simplificando:
( 1/potato * potato ) * x * ( 1/potato * potato ) = 1/potato * x * potato =>
x = 1/potato * x * potato o sea que:

          potato * x * 1/potato = x = 1/potato * x * potato


>APLICACION
>
>Volviendo al problema, y siendo algo menos formales ;-) tenemos
>       potato  <-->    potatizar
>   woody   <-->    x
>
> potato * woody = potatizar * x
>[...]
>o bien
>  woody * potato = x * potatizar

       x * potato = potatizar * woody   (otra posibilidad)

      1/potato * x * potato = 1/potato * ( potatizar * woody )
      otatop * x * potato =  otatop * ( potatizar * woody )
      otatop * x * potato = ( otatop * potatizar ) * woody
      otatop * x * potato = oizar * woody
      1/potato * x * potato = oizar * woody   Ale Hop! =>
                 x          = oizar * woody

    Podemos probar con otros puntos de partida:

      potato * x = woody * potatizar

      1/potatizar * potato * x = 1/potatizar * woody * potatizar
      razitatop * potato * x  = 1/potatizar * woody * potatizar
      razio * x = 1/potatizar * woody * potatizar  otra vez el teorema =>
      razio * x = woody => 1/razio * razio * x = 1/razio * woody => ...
      x = oizar * woody

   como ves, el mismo resultado. Pero ahora viene lo bueno:

      x = oizar * woody (por el teorema, tomando b=woody) =>
      x = woody * ( oizar * woody ) * 1/woody => asociativa, reorganizamos
      x = (woody * oizar ) * ( woody * 1/woody ) inverso =>
      x = woody * oziar = woodyizar

(si sustituyes woody por gudi, la demostracion es igual gudioizar. Para
llegar a gudizar, hay que echar mano de la linguistica para cargarse la
molesta "o").

>Conclusión:
>==========

    ¡¡Qué forma de perder el tiempo!!


                                       Saludos de Javier Cantero
                                (mi email de verdad: jcantero at jet.es)


- --
(zzz)