# Affine

## Definitions for Affine

Function: fast_linsolve ([expr_1, ..., expr_m], [x_1, ..., x_n])
Solves the simultaneous linear equations expr_1, ..., expr_m for the variables x_1, ..., x_n. Each expr_i may be an equation or a general expression; if given as a general expression, it is treated as an equation of the form `expr_i = 0`.

The return value is a list of equations of the form `[x_1 = a_1, ..., x_n = a_n]` where a_1, ..., a_n are all free of x_1, ..., x_n.

`fast_linsolve` is faster than `linsolve` for system of equations which are sparse.

Function: grobner_basis ([expr_1, ..., expr_m])
Returns a Groebner basis for the equations expr_1, ..., expr_m. The function `polysimp` can then be used to simplify other functions relative to the equations.

```grobner_basis ([3*x^2+1, y*x])\$

polysimp (y^2*x + x^3*9 + 2) ==> -3*x + 2
```

`polysimp(f)` yields 0 if and only if f is in the ideal generated by expr_1, ..., expr_m, that is, if and only if f is a polynomial combination of the elements of expr_1, ..., expr_m.

Function: set_up_dot_simplifications (eqns, check_through_degree)
Function: set_up_dot_simplifications (eqns)
The eqns are polynomial equations in non commutative variables. The value of `current_variables` is the list of variables used for computing degrees. The equations must be homogeneous, in order for the procedure to terminate.

If you have checked overlapping simplifications in `dot_simplifications` above the degree of f, then the following is true: `dotsimp (f)` yields 0 if and only if f is in the ideal generated by the equations, i.e., if and only if f is a polynomial combination of the elements of the equations.

The degree is that returned by `nc_degree`. This in turn is influenced by the weights of individual variables.

Function: declare_weight (x_1, w_1, ..., x_n, w_n)
Assigns weights w_1, ..., w_n to x_1, ..., x_n, respectively. These are the weights used in computing `nc_degree`.

Function: nc_degree (p)
Returns the degree of a noncommutative polynomial p. See `declare_weights`.

Function: dotsimp (f)
Returns 0 if and only if f is in the ideal generated by the equations, i.e., if and only if f is a polynomial combination of the elements of the equations.

Function: fast_central_elements ([x_1, ..., x_n], n)
If `set_up_dot_simplifications` has been previously done, finds the central polynomials in the variables x_1, ..., x_n in the given degree, n.

For example:

```set_up_dot_simplifications ([y.x + x.y], 3);
fast_central_elements ([x, y], 2);
[y.y, x.x];
```

Checks the overlaps thru degree n, making sure that you have sufficient simplification rules in each degree, for `dotsimp` to work correctly. This process can be speeded up if you know before hand what the dimension of the space of monomials is. If it is of finite global dimension, then `hilbert` should be used. If you don't know the monomial dimensions, do not specify a `rank_functiion`. An optional third argument `reset`, `false` says don't bother to query about resetting things.

Function: mono ([x_1, ..., x_n], n)
Returns the list of independent monomials relative to the current dot simplifications of degree n in the variables x_1, ..., x_n.

Function: monomial_dimensions (n)
Compute the Hilbert series through degree n for the current algebra.

Function: extract_linear_equations ([p_1, ..., p_n], [m_1, ..., m_n])

Makes a list of the coefficients of the noncommutative polynomials p_1, ..., p_n of the noncommutative monomials m_1, ..., m_n. The coefficients should be scalars. Use `list_nc_monomials` to build the list of monomials.

Function: list_nc_monomials ([p_1, ..., p_n])
Function: list_nc_monomials (p)

Returns a list of the non commutative monomials occurring in a polynomial p or a list of polynomials p_1, ..., p_n.

Function: create_list (form, x_1, list_1, ..., x_n, list_n)

Create a list by evaluating form with x_1 bound to each element of list_1, and for each such binding bind x_2 to each element of list_2, .... The number of elements in the result will be the product of the number of elements in each list. Each variable x_i must actually be a symbol--it will not be evaluated. The list arguments will be evaluated once at the beginning of the iteration.

```(%i82) create_list1(x^i,i,[1,3,7]);
(%o82) [x,x^3,x^7]
```

With a double iteration:

```(%i79) create_list([i,j],i,[a,b],j,[e,f,h]);
(%o79) [[a,e],[a,f],[a,h],[b,e],[b,f],[b,h]]
```

Instead of list_i two args may be supplied each of which should evaluate to a number. These will be the inclusive lower and upper bounds for the iteration.

```(%i81) create_list([i,j],i,[1,2,3],j,1,i);
(%o81) [[1,1],[2,1],[2,2],[3,1],[3,2],[3,3]]
```

Note that the limits or list for the j variable can depend on the current value of i.

Option variable: all_dotsimp_denoms
Default value: `false`

When `all_dotsimp_denoms` is a list, the denominators encountered by `dotsimp` are appended to the list. `all_dotsimp_denoms` may be initialized to an empty list `[]` before calling `dotsimp`.

By default, denominators are not collected by `dotsimp`.