This is Isomorphism.info, produced by Macaulay2, version 1.24.11

Isomorphism -- Probabilistic test for isomorphism
*************************************************

Description
===========

Two modules are isomorphic if there is a surjection in each direction. These
routines produce random combinations of the generators of Hom and test whether
these are surjections.

Contributors
============

Mike Stillman

See also
========

  * isIsomorphic -- Probabilistic test for isomorphism of
    modules
  * checkDegrees -- compares the degrees of generators of
    two modules

Author
======

  * David Eisenbud (see http://www.msri.org/~de ) <de@msri.org>

Version
=======

This documentation describes version 1.0 of Isomorphism.

Source code
===========

The source code from which this documentation is derived is in the file
Isomorphism.m2 (see common/share/Macaulay2/Isomorphism.m2 ).

Exports
=======

  * Functions and commands
      * checkDegrees -- compares the degrees of generators
        of two modules
      * isIsomorphic -- Probabilistic test for isomorphism
        of modules
  * Methods
      * "checkDegrees(Matrix,Matrix)" -- see checkDegrees,
        -- compares the degrees of generators of two modules
      * "checkDegrees(Module,Module)" -- see checkDegrees,
        -- compares the degrees of generators of two modules
      * "isIsomorphic(Matrix,Matrix)" -- see isIsomorphic,
        -- Probabilistic test for isomorphism of modules
      * "isIsomorphic(Module,Module)" -- see isIsomorphic,
        -- Probabilistic test for isomorphism of modules
  * Symbols
      * Strict -- Forces strict equality of degrees

For the programmer
==================

The object Isomorphism, is a package (Macaulay2Doc).

checkDegrees -- compares the degrees of generators of two modules
*****************************************************************

Synopsis
========

  * Usage:
        d = checkDegrees(N,M)
        d = checkDegrees(n,m)
  * Inputs:
      * N, a module (Macaulay2Doc),
      * n, a matrix (Macaulay2Doc), presentation of N
      * M, a module (Macaulay2Doc),
      * m, a matrix (Macaulay2Doc), presentation of M
  * Optional inputs (Macaulay2Doc),:
      * Strict => ..., default value false
      * Verbose => ..., default value false
  * Outputs:
      * d, a sequence (Macaulay2Doc), (Boolean, a degree in the
        ring of M and N)

Description
===========

This is to be used with isIsomorphic.

The routine compares the sorted lists of degrees of generators of the two
modules; the degreeLength (can be anything). If the numbers of generators of
M,N are different, the modules are not isomorphic, and the routine returns
(false, null).

If the numbers are the same, and all the corresponding degrees pairs differ by
the same amount (so that the modules might become isomorphic after a shift,
then if Strict => false (the default) the output (true, e) tells how to adjust
the modules to make the degrees equal: either tensor N with (ring N)^{e} or
tensor M with (ring M)^{-e}.

If Strict => true, then the output is (false, null) unless the offset e is 0.

+-------------------------------------------------+
|i1 : S = ZZ/101[a,b,Degrees => {{1,0},{0,1}}]    |
|                                                 |
|o1 = S                                           |
|                                                 |
|o1 : PolynomialRing                              |
+-------------------------------------------------+
|i2 : A = S^{{2,1}}                               |
|                                                 |
|      1                                          |
|o2 = S                                           |
|                                                 |
|o2 : S-module, free, degrees {{-2, -1}}          |
+-------------------------------------------------+
|i3 : B = S^{{1,1}}                               |
|                                                 |
|      1                                          |
|o3 = S                                           |
|                                                 |
|o3 : S-module, free, degrees {{-1, -1}}          |
+-------------------------------------------------+
|i4 : B' = S^{{3,3}}**B                           |
|                                                 |
|      1                                          |
|o4 = S                                           |
|                                                 |
|o4 : S-module, free, degrees {{-4, -4}}          |
+-------------------------------------------------+
|i5 : C = S^{{1,1}, {2,3}}                        |
|                                                 |
|      2                                          |
|o5 = S                                           |
|                                                 |
|o5 : S-module, free, degrees {{-1, -1}, {-2, -3}}|
+-------------------------------------------------+
|i6 : checkDegrees(A,B)                           |
|                                                 |
|o6 = (true, {-1, 0})                             |
|                                                 |
|o6 : Sequence                                    |
+-------------------------------------------------+
|i7 : checkDegrees(A,C)                           |
|                                                 |
|o7 = (false, )                                   |
|                                                 |
|o7 : Sequence                                    |
+-------------------------------------------------+
|i8 : d = checkDegrees(B',B)                      |
|                                                 |
|o8 = (true, {-3, -3})                            |
|                                                 |
|o8 : Sequence                                    |
+-------------------------------------------------+
|i9 : degrees (S^{d_1}**B') == degrees B          |
|                                                 |
|o9 = true                                        |
+-------------------------------------------------+
|i10 : degrees (B') == degrees (S^{-d_1}**B)      |
|                                                 |
|o10 = true                                       |
+-------------------------------------------------+
|i11 : checkDegrees(B',B,Strict=>true)            |
|                                                 |
|o11 = (false, )                                  |
|                                                 |
|o11 : Sequence                                   |
+-------------------------------------------------+

See also
========

  * isIsomorphic -- Probabilistic test for isomorphism of
    modules
  * Strict -- Forces strict equality of degrees

Ways to use checkDegrees:
=========================

  * "checkDegrees(Matrix,Matrix)"
  * "checkDegrees(Module,Module)"

For the programmer
==================

The object checkDegrees, is a method function with options (Macaulay2Doc).

isIsomorphic -- Probabilistic test for isomorphism of modules
*************************************************************

Synopsis
========

  * Usage:
        t = isIsomorphic (N,M)
        t = isIsomorphic (n,m)
  * Inputs:
      * M, a module (Macaulay2Doc),
      * m, a matrix (Macaulay2Doc), presentation of M
      * N, a module (Macaulay2Doc),
      * n, a matrix (Macaulay2Doc), presentation of N
  * Optional inputs (Macaulay2Doc),:
      * Homogeneous => a Boolean value (Macaulay2Doc), default
        value true
      * Verbose => a Boolean value (Macaulay2Doc), default value
        false
      * Strict => a Boolean value (Macaulay2Doc), default value
        false
  * Outputs:
      * t, a sequence (Macaulay2Doc), (Boolean, Matrix) or
        (Boolean, null)

Description
===========

In case both modules are homogeneous the program first uses checkDegrees,
to see whether an isomorphism is possible. This may be an
isomorphism up to shift if Strict => false (the default) or on the nose if
Strict => true.

If this test is passed, the program uses a variant of the Hom command to
compute a random map of minimal possible degree from M to N, and checks whether
this is surjective and injective.

In the inhomogeneous case (or with Homogeneous => false) the random map is a
random linear combination of the generators of the module of homomorphisms.

If the output has the form (true, g), then g is guaranteed to be an
isomorphism. If the output is (false, null), then the conclusion of
non-isomorphism is only probabilistic.

+------------------------------------------------------------+
|i1 : setRandomSeed 0                                        |
|                                                            |
|o1 = 0                                                      |
+------------------------------------------------------------+
|i2 : S = ZZ/32003[x_0..x_3]                                 |
|                                                            |
|o2 = S                                                      |
|                                                            |
|o2 : PolynomialRing                                         |
+------------------------------------------------------------+
|i3 : m = random(S^3, S^{4:-2});                             |
|                                                            |
|             3      4                                       |
|o3 : Matrix S  <-- S                                        |
+------------------------------------------------------------+
|i4 : A = random(target m, target m)                         |
|                                                            |
|o4 = | 12809 6206 -246  |                                   |
|     | 15612 9476 12107 |                                   |
|     | -1548 5867 4502  |                                   |
|                                                            |
|             3      3                                       |
|o4 : Matrix S  <-- S                                        |
+------------------------------------------------------------+
|i5 : B = random(source m, source m)                         |
|                                                            |
|o5 = {2} | -4943 -8731 3015   -10261 |                      |
|     {2} | 12762 -4006 -6618  -13024 |                      |
|     {2} | -7974 610   -14394 6893   |                      |
|     {2} | -1112 -5556 -14500 15836  |                      |
|                                                            |
|             4      4                                       |
|o5 : Matrix S  <-- S                                        |
+------------------------------------------------------------+
|i6 : m' = A*m*B;                                            |
|                                                            |
|             3      4                                       |
|o6 : Matrix S  <-- S                                        |
+------------------------------------------------------------+
|i7 : isIsomorphic (S^{-3}**coker m, coker m)                |
|                                                            |
|o7 = (true, {3} | 7410 0    0    |)                         |
|            {3} | 0    7410 0    |                          |
|            {3} | 0    0    7410 |                          |
|                                                            |
|o7 : Sequence                                               |
+------------------------------------------------------------+
|i8 : isIsomorphic (S^{-3}**coker m, coker m, Strict => true)|
|                                                            |
|o8 = (false, )                                              |
|                                                            |
|o8 : Sequence                                               |
+------------------------------------------------------------+
|i9 : isIsomorphic (coker m, coker m')                       |
|                                                            |
|o9 = (true, | 230   -5422  -3121 |)                         |
|            | 14340 -12104 -190  |                          |
|            | 13380 14919  12098 |                          |
|                                                            |
|o9 : Sequence                                               |
+------------------------------------------------------------+

The following example checks two of the well-known isomorphism in homological
algebra.

+-------------------------------------------------------------------+
|i10 : setRandomSeed 0                                              |
|                                                                   |
|o10 = 0                                                            |
+-------------------------------------------------------------------+
|i11 : S = ZZ/32003[x_0..x_3]                                       |
|                                                                   |
|o11 = S                                                            |
|                                                                   |
|o11 : PolynomialRing                                               |
+-------------------------------------------------------------------+
|i12 : I = monomialCurveIdeal(S,{1,3,5})                            |
|                                                                   |
|              2          2      2     3    2                       |
|o12 = ideal (x  - x x , x x  - x x , x  - x x )                    |
|              2    1 3   1 2    0 3   1    0 2                     |
|                                                                   |
|o12 : Ideal of S                                                   |
+-------------------------------------------------------------------+
|i13 : codim I                                                      |
|                                                                   |
|o13 = 2                                                            |
+-------------------------------------------------------------------+
|i14 : W = Ext^2(S^1/I, S^1)                                        |
|                                                                   |
|o14 = cokernel {-4} | x_2 x_1 x_0^2 |                              |
|               {-4} | x_3 x_2 x_1^2 |                              |
|                                                                   |
|                             2                                     |
|o14 : S-module, quotient of S                                      |
+-------------------------------------------------------------------+
|i15 : W' = Hom(S^1/I, S^1/(I_0,I_1) )                              |
|                                                                   |
|o15 = subquotient (| x_3 x_2 |, | x_2^2-x_1x_3 x_1^2x_2-x_0^2x_3 |)|
|                                                                   |
|                                1                                  |
|o15 : S-module, subquotient of S                                   |
+-------------------------------------------------------------------+
|i16 : isIsomorphic(W,W')                                           |
|                                                                   |
|o16 = (true, {-4} | -107 0   |)                                    |
|             {-4} | 0    107 |                                     |
|                                                                   |
|o16 : Sequence                                                     |
+-------------------------------------------------------------------+
|i17 : mm = ideal gens S                                            |
|                                                                   |
|o17 = ideal (x , x , x , x )                                       |
|              0   1   2   3                                        |
|                                                                   |
|o17 : Ideal of S                                                   |
+-------------------------------------------------------------------+
|i18 : (isIsomorphic(Tor_1(W, S^1/(mm^3)), Tor_1(S^1/(mm^3), W)))_0 |
|                                                                   |
|o18 = true                                                         |
+-------------------------------------------------------------------+

Caveat
======

A negative result means that a random choice of homomorphism was not an
isomorphism; especially when the ground field is small, this may not be
definitive.

See also
========

  * checkDegrees -- compares the degrees of generators of
    two modules

Ways to use isIsomorphic:
=========================

  * "isIsomorphic(Matrix,Matrix)"
  * "isIsomorphic(Module,Module)"

For the programmer
==================

The object isIsomorphic, is a method function with options (Macaulay2Doc).

Strict -- Forces strict equality of degrees
*******************************************

Synopsis
========

  * Usage:
        d = checkDegrees(N,M, Strict =>true)

Description
===========

Used with Strict=>false, the default, checkDegrees(N,M) returns (true, deg) if
degrees M and degrees N are equal up to a shift d. With Strict => true the
degree lists must be equal.

+---------------------------------------------+
|i1 : S = ZZ/101[a,b,Degrees => {{1,0},{0,1}}]|
|                                             |
|o1 = S                                       |
|                                             |
|o1 : PolynomialRing                          |
+---------------------------------------------+
|i2 : B = S^{{1,1}}                           |
|                                             |
|      1                                      |
|o2 = S                                       |
|                                             |
|o2 : S-module, free, degrees {{-1, -1}}      |
+---------------------------------------------+
|i3 : B' = S^{{3,3}}**B                       |
|                                             |
|      1                                      |
|o3 = S                                       |
|                                             |
|o3 : S-module, free, degrees {{-4, -4}}      |
+---------------------------------------------+
|i4 : d = checkDegrees(B',B)                  |
|                                             |
|o4 = (true, {-3, -3})                        |
|                                             |
|o4 : Sequence                                |
+---------------------------------------------+
|i5 : degrees (S^{d_1}**B') == degrees B      |
|                                             |
|o5 = true                                    |
+---------------------------------------------+
|i6 : degrees (B') == degrees (S^{-d_1}**B)   |
|                                             |
|o6 = true                                    |
+---------------------------------------------+
|i7 : checkDegrees(B',B,Strict=>true)         |
|                                             |
|o7 = (false, )                               |
|                                             |
|o7 : Sequence                                |
+---------------------------------------------+

See also
========

  * checkDegrees -- compares the degrees of generators of
    two modules

Functions with optional argument named Strict:
==============================================

  * "checkDegrees(...,Strict=>...)" -- see checkDegrees, --
    compares the degrees of generators of two modules
  * "isIsomorphic(...,Strict=>...)" -- see isIsomorphic, --
    Probabilistic test for isomorphism of modules

For the programmer
==================

The object Strict, is a symbol (Macaulay2Doc).