Merge pull request #2623 from fredrik-johansson/noncom

Improve support for generic noncommutative rings

Author: fredrik-johansson

doc/source/gr_domains.rst

@@ -35,6 +35,23 @@ Domain properties
     mathematical property.
     The result can be ``T_UNKNOWN``.
 
+.. function:: truth_t gr_ctx_is_approx_commutative_ring(gr_ctx_t ctx)
+
+    Returns whether the structure `\tilde R` implemented by ``ctx`` is assumed
+    to represent an approximate version of a structure `R` with the
+    respective mathematical property.
+    The usual axioms need not hold exactly as long as they hold
+    within a small perturbation, i.e. an axiom of the type `a = b` in `R` is
+    replaced by an axiom of the type
+    `|\tilde a - \tilde b| < \varepsilon` in `\tilde R`.
+    For example, polynomials with floating-point coefficients are
+    considered an approximate commutative ring, but two by two matrices
+    with floating-point coefficients are not.
+
+    The exact structure is trivially considered an approximate version of
+    itself; for example, every commutative ring is considered to be an
+    approximate commutative ring.
+
 .. function:: truth_t gr_ctx_is_exact(gr_ctx_t ctx)
 
     Returns whether the representation of elements is always exact.
@@ -109,6 +126,8 @@ Basic rings and fields
 -------------------------------------------------------------------------------
 
 .. function:: void gr_ctx_init_random(gr_ctx_t ctx, flint_rand_t state)
+              void gr_ctx_init_random_commutative_ring(gr_ctx_t ctx, flint_rand_t state)
+              void gr_ctx_init_random_field(gr_ctx_t ctx, flint_rand_t state)
 
     Initializes *ctx* to a random ring. This will currently
     only generate base rings and composite rings over certain

src/gr.h

@@ -117,6 +117,8 @@ typedef enum
     GR_METHOD_CTX_IS_COMPLEX_VECTOR_SPACE,
     GR_METHOD_CTX_IS_ORDERED_RING,
 
+    GR_METHOD_CTX_IS_APPROX_COMMUTATIVE_RING,
+
     /* group properties */
     GR_METHOD_CTX_IS_MULTIPLICATIVE_GROUP,
 
@@ -972,13 +974,14 @@ GR_INLINE truth_t gr_ctx_is_zero_ring(gr_ctx_t ctx) { return GR_CTX_PREDICATE(ct
 GR_INLINE truth_t gr_ctx_is_rational_vector_space(gr_ctx_t ctx) { return GR_CTX_PREDICATE(ctx, CTX_IS_RATIONAL_VECTOR_SPACE)(ctx); }
 GR_INLINE truth_t gr_ctx_is_real_vector_space(gr_ctx_t ctx) { return GR_CTX_PREDICATE(ctx, CTX_IS_REAL_VECTOR_SPACE)(ctx); }
 GR_INLINE truth_t gr_ctx_is_complex_vector_space(gr_ctx_t ctx) { return GR_CTX_PREDICATE(ctx, CTX_IS_COMPLEX_VECTOR_SPACE)(ctx); }
-
 GR_INLINE truth_t gr_ctx_is_unique_factorization_domain(gr_ctx_t ctx) { return GR_CTX_PREDICATE(ctx, CTX_IS_UNIQUE_FACTORIZATION_DOMAIN)(ctx); }
 GR_INLINE truth_t gr_ctx_is_finite(gr_ctx_t ctx) { return GR_CTX_PREDICATE(ctx, CTX_IS_FINITE)(ctx); }
 GR_INLINE truth_t gr_ctx_is_finite_characteristic(gr_ctx_t ctx) { return GR_CTX_PREDICATE(ctx, CTX_IS_FINITE_CHARACTERISTIC)(ctx); }
 GR_INLINE truth_t gr_ctx_is_algebraically_closed(gr_ctx_t ctx) { return GR_CTX_PREDICATE(ctx, CTX_IS_ALGEBRAICALLY_CLOSED)(ctx); }
 GR_INLINE truth_t gr_ctx_is_ordered_ring(gr_ctx_t ctx) { return GR_CTX_PREDICATE(ctx, CTX_IS_ORDERED_RING)(ctx); }
 
+GR_INLINE truth_t gr_ctx_is_approx_commutative_ring(gr_ctx_t ctx) { return GR_CTX_PREDICATE(ctx, CTX_IS_APPROX_COMMUTATIVE_RING)(ctx); }
+
 GR_INLINE truth_t gr_ctx_is_multiplicative_group(gr_ctx_t ctx) { return GR_CTX_PREDICATE(ctx, CTX_IS_MULTIPLICATIVE_GROUP)(ctx); }
 
 GR_INLINE truth_t gr_ctx_is_exact(gr_ctx_t ctx) { return GR_CTX_PREDICATE(ctx, CTX_IS_EXACT)(ctx); }
@@ -1384,6 +1387,8 @@ truth_t gr_generic_ctx_predicate_false(gr_ctx_t ctx);
 void gr_ctx_uninitialized(gr_ctx_t ctx);
 
 void gr_ctx_init_random(gr_ctx_t ctx, flint_rand_t state);
+void gr_ctx_init_random_commutative_ring(gr_ctx_t ctx, flint_rand_t state);
+void gr_ctx_init_random_field(gr_ctx_t ctx, flint_rand_t state);
 
 void gr_ctx_init_fmpz(gr_ctx_t ctx);
 void gr_ctx_init_fmpq(gr_ctx_t ctx);

src/gr/acf.c

@@ -1317,6 +1317,7 @@ gr_method_tab_input _acf_methods_input[] =
                                 (gr_funcptr) gr_generic_ctx_predicate_false},
     {GR_METHOD_CTX_IS_ORDERED_RING,
                                 (gr_funcptr) gr_generic_ctx_predicate_false},
+    {GR_METHOD_CTX_IS_APPROX_COMMUTATIVE_RING, (gr_funcptr) gr_generic_ctx_predicate_true},
     {GR_METHOD_CTX_IS_EXACT,    (gr_funcptr) gr_generic_ctx_predicate_false},
     {GR_METHOD_CTX_IS_CANONICAL,
                                 (gr_funcptr) gr_generic_ctx_predicate_false},

src/gr/arf.c

@@ -1349,6 +1349,7 @@ gr_method_tab_input _arf_methods_input[] =
                                 (gr_funcptr) gr_generic_ctx_predicate_false},
     {GR_METHOD_CTX_IS_ORDERED_RING,
                                 (gr_funcptr) gr_generic_ctx_predicate_false},
+    {GR_METHOD_CTX_IS_APPROX_COMMUTATIVE_RING, (gr_funcptr) gr_generic_ctx_predicate_true},
     {GR_METHOD_CTX_IS_EXACT,    (gr_funcptr) gr_generic_ctx_predicate_false},
     {GR_METHOD_CTX_IS_CANONICAL,
                                 (gr_funcptr) gr_generic_ctx_predicate_false},

src/gr/complex.c

@@ -54,6 +54,7 @@ static truth_t _gr_complex_ctx_is_integral_domain(gr_ctx_t ctx) { return gr_ctx_
 static truth_t _gr_complex_ctx_is_field(gr_ctx_t ctx) { return gr_ctx_is_field(REAL_CTX(ctx)); }
 static truth_t _gr_complex_ctx_is_rational_vector_space(gr_ctx_t ctx) { return gr_ctx_is_rational_vector_space(REAL_CTX(ctx)); }
 static truth_t _gr_complex_ctx_is_real_vector_space(gr_ctx_t ctx) { return gr_ctx_is_real_vector_space(REAL_CTX(ctx)); }
+static truth_t _gr_complex_ctx_is_approx_commutative_ring(gr_ctx_t ctx) { return gr_ctx_is_approx_commutative_ring(REAL_CTX(ctx)); }
 
 static truth_t _gr_complex_ctx_is_threadsafe(gr_ctx_t ctx) { return gr_ctx_is_threadsafe(REAL_CTX(ctx)); }
 static truth_t _gr_complex_ctx_is_finite(gr_ctx_t ctx) { return gr_ctx_is_finite(REAL_CTX(ctx)); }
@@ -633,6 +634,7 @@ gr_method_tab_input _gr_complex_methods_input[] =
     {GR_METHOD_CTX_IS_THREADSAFE,       (gr_funcptr)  _gr_complex_ctx_is_threadsafe},
     {GR_METHOD_CTX_IS_FINITE,           (gr_funcptr) _gr_complex_ctx_is_finite},
     {GR_METHOD_CTX_IS_FINITE_CHARACTERISTIC,    (gr_funcptr) _gr_complex_ctx_is_finite_characteristic},
+    {GR_METHOD_CTX_IS_APPROX_COMMUTATIVE_RING, (gr_funcptr)  _gr_complex_ctx_is_approx_commutative_ring},
 
     {GR_METHOD_CTX_IS_EXACT,    (gr_funcptr) _gr_complex_ctx_is_exact},
     {GR_METHOD_CTX_NGENS,       (gr_funcptr) gr_generic_ctx_ngens_1},

src/gr/init_random.c

@@ -48,7 +48,7 @@ gr_ctx_init_random_ring_composite(gr_ctx_t ctx, flint_rand_t state)
 {
     gr_ctx_struct * base_ring = _gr_random_base_ring(state);
 
-    switch (n_randint(state, 6))
+    switch (n_randint(state, 10))
     {
         case 0:
             gr_ctx_init_gr_poly(ctx, base_ring);
@@ -74,13 +74,11 @@ gr_ctx_init_random_ring_composite(gr_ctx_t ctx, flint_rand_t state)
                 gr_ctx_init_debug(ctx, base_ring, flags, unable_probability);
             }
             break;
-/*
-    this will break tests that currently assume commutativity
-
-        case 5:
+        /* generate with slightly higher probability, because this is currently
+           the only way we generate noncommutative test rings */
+        default:
             gr_ctx_init_matrix_ring(ctx, base_ring, n_randint(state, 4));
             break;
-*/
     }
 }
 
@@ -277,3 +275,25 @@ void gr_ctx_init_random(gr_ctx_t ctx, flint_rand_t state)
     gr_ctx_println(ctx);
 */
 }
+
+void gr_ctx_init_random_commutative_ring(gr_ctx_t ctx, flint_rand_t state)
+{
+    while (1)
+    {
+        gr_ctx_init_random(ctx, state);
+        if (gr_ctx_is_commutative_ring(ctx) == T_TRUE)
+            break;
+        gr_ctx_clear(ctx);
+    }
+}
+
+void gr_ctx_init_random_field(gr_ctx_t ctx, flint_rand_t state)
+{
+    while (1)
+    {
+        gr_ctx_init_random(ctx, state);
+        if (gr_ctx_is_field(ctx) == T_TRUE)
+            break;
+        gr_ctx_clear(ctx);
+    }
+}

src/gr/matrix.c

@@ -136,6 +136,25 @@ static truth_t matrix_ctx_is_complex_vector_space(gr_ctx_t ctx)
     return gr_ctx_is_complex_vector_space(MATRIX_CTX(ctx)->base_ring);
 }
 
+static truth_t matrix_ctx_is_approx_commutative_ring(gr_ctx_t ctx)
+{
+    int shape_ok = (!MATRIX_CTX(ctx)->all_sizes && MATRIX_CTX(ctx)->nrows == MATRIX_CTX(ctx)->ncols);
+
+    if (!shape_ok)
+        return T_FALSE;
+
+    if (MATRIX_CTX(ctx)->nrows == 0)
+        return T_TRUE;
+
+    if (MATRIX_CTX(ctx)->nrows == 1)
+        return gr_ctx_is_approx_commutative_ring(MATRIX_CTX(ctx)->base_ring);
+
+    if (gr_ctx_is_zero_ring(MATRIX_CTX(ctx)->base_ring) == T_TRUE)
+        return T_TRUE;
+
+    return T_UNKNOWN;
+}
+
 /* todo: public */
 truth_t gr_ctx_matrix_is_fixed_size(gr_ctx_t ctx)
 {
@@ -580,6 +599,7 @@ gr_method_tab_input _gr_mat_methods_input[] =
     {GR_METHOD_CTX_IS_RATIONAL_VECTOR_SPACE, (gr_funcptr) matrix_ctx_is_rational_vector_space},
     {GR_METHOD_CTX_IS_REAL_VECTOR_SPACE, (gr_funcptr) matrix_ctx_is_real_vector_space},
     {GR_METHOD_CTX_IS_COMPLEX_VECTOR_SPACE, (gr_funcptr) matrix_ctx_is_complex_vector_space},
+    {GR_METHOD_CTX_IS_APPROX_COMMUTATIVE_RING, (gr_funcptr) matrix_ctx_is_approx_commutative_ring},
     {GR_METHOD_INIT,        (gr_funcptr) matrix_init},
     {GR_METHOD_CLEAR,       (gr_funcptr) matrix_clear},
     {GR_METHOD_SWAP,        (gr_funcptr) matrix_swap},

src/gr/mpf.c

@@ -370,6 +370,7 @@ gr_method_tab_input _gr_mpf_methods_input[] =
     {GR_METHOD_CTX_WRITE,       (gr_funcptr) _gr_mpf_ctx_write},
     {GR_METHOD_CTX_IS_RING,     (gr_funcptr) gr_generic_ctx_predicate_false},
     {GR_METHOD_CTX_IS_EXACT,    (gr_funcptr) gr_generic_ctx_predicate_false},
+    {GR_METHOD_CTX_IS_APPROX_COMMUTATIVE_RING, (gr_funcptr) gr_generic_ctx_predicate_true},
     {GR_METHOD_CTX_HAS_REAL_PREC, (gr_funcptr) gr_generic_ctx_predicate_true},
     {GR_METHOD_CTX_SET_REAL_PREC, (gr_funcptr) _gr_mpf_ctx_set_real_prec},
     {GR_METHOD_CTX_GET_REAL_PREC, (gr_funcptr) _gr_mpf_ctx_get_real_prec},

src/gr/polynomial.c

@@ -121,6 +121,12 @@ polynomial_ctx_is_complex_vector_space(gr_ctx_t ctx)
     return gr_ctx_is_complex_vector_space(POLYNOMIAL_ELEM_CTX(ctx));
 }
 
+static truth_t
+polynomial_ctx_is_approx_commutative_ring(gr_ctx_t ctx)
+{
+    return gr_ctx_is_approx_commutative_ring(POLYNOMIAL_ELEM_CTX(ctx));
+}
+
 static truth_t
 polynomial_ctx_is_threadsafe(gr_ctx_t ctx)
 {
@@ -770,6 +776,7 @@ gr_method_tab_input _gr_poly_methods_input[] =
     {GR_METHOD_CTX_IS_RATIONAL_VECTOR_SPACE, (gr_funcptr) polynomial_ctx_is_rational_vector_space},
     {GR_METHOD_CTX_IS_REAL_VECTOR_SPACE, (gr_funcptr) polynomial_ctx_is_real_vector_space},
     {GR_METHOD_CTX_IS_COMPLEX_VECTOR_SPACE, (gr_funcptr) polynomial_ctx_is_complex_vector_space},
+    {GR_METHOD_CTX_IS_APPROX_COMMUTATIVE_RING, (gr_funcptr) polynomial_ctx_is_approx_commutative_ring},
     {GR_METHOD_CTX_IS_THREADSAFE,       (gr_funcptr) polynomial_ctx_is_threadsafe},
     {GR_METHOD_CTX_SET_GEN_NAME,        (gr_funcptr) _gr_gr_poly_ctx_set_gen_name},
     {GR_METHOD_CTX_SET_GEN_NAMES,       (gr_funcptr) _gr_gr_poly_ctx_set_gen_names},

src/gr/test/t-fmpz_mod_mpoly_q.c

@@ -30,7 +30,7 @@ TEST_FUNCTION_START(gr_fmpz_mod_mpoly_q, state)
 
         gr_ctx_init_fmpz_mod_mpoly_q(ZZxy, n_randint(state, 3), mpoly_ordering_randtest(state), m);
         ZZxy->size_limit = 100;
-        gr_test_ring(ZZxy, 1000, flags);
+        gr_test_ring(ZZxy, 100, flags);
         gr_ctx_clear(ZZxy);
 
         fmpz_clear(m);