a meta simplifier  the simplification process is a key point in computer algebra systems. two ideas have induced our model of simplifier : homogenizing the computation over numerical (see below) and formal expressions, and building a simplifier completely reachable by the user. in order to evaluate numerical expressions, the simplifier calls functions which compute the result or raise a runtime type error. formal expressions are transformed modulo the properties of the operators. for homogenizing those two processes, three basic mechanisms come out : simplification by properties, type checking, evaluation. more over a fourth mechanism using rewriting rules is necessary to compute non-standard transformations needed by the user. the structure of this four-component simplifier must make it completely reachable by the user unlike the usual simplifiers that include a kernel that the user can't modify. for example the operator "+" is always considered as associative and commutative and there is no way to suppress those properties because they are implicitly used in the code. the only means of suppressing this kernel is to express explicitly all knowledge needed by the simplifier. the model that comes out consists of two parts : a knowledge- base that contains all information and an engine split into four components that consults this base, we call it a meta simplifier1.  each component of the engine takes the needed knowledge in the base to compute transformations on expressions. the algebraic properties allowed are all those used in other systems such as associativity, commutativity with some new ones such as to be an endomorphism, or a ring. the type-checker uses formal types to compute the type of all expressions. in any system, different types of objects are used, for example, integer, sparse-matrix, dense-matrix, list. we call them numerical types because they depend on representation, then a formal type is a set of numerical types which are equivalent modulo representation. for example the formal type matrix would contain sparse matrix and dense matrix. the conversions usually defined between numerical types, are extended to formal types. every operator is given several formal signatures so the simplifier explicitly solves this overloading. thus numerical and formal expressions are considered in the same way, and type errors are raised by the same mechanism. this process type checks the expression, solves the overloading and infers types over symbols. the third mechanism uses functions to convert (numerical conversions) and to evaluate numerical expressions (interpretations). the typing process has introduced formal conversions, and not overloaded operators, then the evaluator converts the numerical objects, and applies evaluating function over numerical arguments. the last component performs rewriting with types modulo associativity and commutativity.  the information which are introduced above (operators properties, formal signatures, interpretations, conversions, formal types, rewriting rules) are stored in the knowledge base as objects built by the user through an interface, and are consulted but not modified by the engine. the main object in the base is the operator, it consists of a name, properties, formal signatures and interpretations. all the objects are completely modifiable by the user, for example a "+" can be defined just associative with a semantic of "append" over the lists and associative, commutative with a semantic of "add" over algebraic objects.  the knowledge-base can be completely customized by the user to fit his precise needs, so the user has potentially several simplifiers at his disposal. the standard scheme of simplification involves those four components in the precise order they have been described above, but the user can choose an other scheme to change the simplifier behavior. given an interface to build the base, an engine supplied with a mechanism of control, the user can build exactly the simplifier he requires.  c. faure