[poincare] Fix typo: explicite --> explicit, implicite --> implicit

2026-01-18 16:27:34 +01:00 · 2019-08-02 11:58:19 +02:00
parent ddb05d930d
commit c1cd0302b8
44 changed files with 336 additions and 336 deletions
--- a/apps/probability/law/binomial_law.cpp
+++ b/apps/probability/law/binomial_law.cpp
@@ -57,7 +57,7 @@ bool BinomialLaw::authorizedValueAtIndex(float x, int index) const {
     * abscissa within the interesting range, the complexity of the cumulative
     * probability is linear with the size of the range. Here we cap the maximal
     * size of the range to 10000. If one day we want to increase or get rid of
-     *  this cap, we should implement the explicite formula of the cumulative
+     *  this cap, we should implement the explicit formula of the cumulative
     *  probability (which depends on an incomplete beta function) to make the
     *  comlexity O(1). */
    if (x != (int)x || x < 0.0f || x > 99999.0f) {
--- a/apps/regression/model/cubic_model.cpp
+++ b/apps/regression/model/cubic_model.cpp
@@ -9,7 +9,7 @@
 #include <poincare/number.h>
 #include <poincare/symbol.h>
 #include <poincare/addition.h>
-#include <poincare/multiplication_explicite.h>
+#include <poincare/multiplication_explicit.h>
 #include <poincare/power.h>

 using namespace Poincare;
@@ -83,17 +83,17 @@ Expression CubicModel::expression(double * modelCoefficients) {
  double c = modelCoefficients[2];
  double d = modelCoefficients[3];
  Expression addChildren[] = {
-    MultiplicationExplicite::Builder(
+    MultiplicationExplicit::Builder(
      Number::DecimalNumber(a),
      Power::Builder(
        Symbol::Builder('x'),
        Decimal::Builder(3.0))),
-    MultiplicationExplicite::Builder(
+    MultiplicationExplicit::Builder(
      Number::DecimalNumber(b),
      Power::Builder(
        Symbol::Builder('x'),
        Decimal::Builder(2.0))),
-    MultiplicationExplicite::Builder(
+    MultiplicationExplicit::Builder(
      Number::DecimalNumber(c),
      Symbol::Builder('x')),
    Number::DecimalNumber(d)
--- a/apps/regression/model/quadratic_model.cpp
+++ b/apps/regression/model/quadratic_model.cpp
@@ -9,7 +9,7 @@
 #include <poincare/number.h>
 #include <poincare/symbol.h>
 #include <poincare/addition.h>
-#include <poincare/multiplication_explicite.h>
+#include <poincare/multiplication_explicit.h>
 #include <poincare/power.h>

 using namespace Poincare;
@@ -70,12 +70,12 @@ Expression QuadraticModel::expression(double * modelCoefficients) {
  double c = modelCoefficients[2];
  // a*x^2+b*x+c
  Expression addChildren[] = {
-    MultiplicationExplicite::Builder(
+    MultiplicationExplicit::Builder(
      Number::DecimalNumber(a),
      Power::Builder(
        Symbol::Builder('x'),
        Decimal::Builder(2.0))),
-    MultiplicationExplicite::Builder(
+    MultiplicationExplicit::Builder(
      Number::DecimalNumber(b),
      Symbol::Builder('x')),
    Number::DecimalNumber(c)
--- a/apps/regression/model/quartic_model.cpp
+++ b/apps/regression/model/quartic_model.cpp
@@ -9,7 +9,7 @@
 #include <poincare/number.h>
 #include <poincare/symbol.h>
 #include <poincare/addition.h>
-#include <poincare/multiplication_explicite.h>
+#include <poincare/multiplication_explicit.h>
 #include <poincare/power.h>

 using namespace Poincare;
@@ -98,25 +98,25 @@ Expression QuarticModel::expression(double * modelCoefficients) {
  double e = modelCoefficients[4];
  Expression addChildren[] = {
    // a*x^4
-    MultiplicationExplicite::Builder(
+    MultiplicationExplicit::Builder(
      Number::DecimalNumber(a),
      Power::Builder(
        Symbol::Builder('x'),
        Decimal::Builder(4.0))),
    // b*x^3
-    MultiplicationExplicite::Builder(
+    MultiplicationExplicit::Builder(
      Number::DecimalNumber(b),
      Power::Builder(
        Symbol::Builder('x'),
        Decimal::Builder(3.0))),
    // c*x^2
-    MultiplicationExplicite::Builder(
+    MultiplicationExplicit::Builder(
      Number::DecimalNumber(c),
      Power::Builder(
        Symbol::Builder('x'),
        Decimal::Builder(2.0))),
    // d*x
-    MultiplicationExplicite::Builder(
+    MultiplicationExplicit::Builder(
      Number::DecimalNumber(d),
      Symbol::Builder('x')),
    // e
--- a/apps/regression/model/trigonometric_model.cpp
+++ b/apps/regression/model/trigonometric_model.cpp
@@ -2,7 +2,7 @@
 #include "../../shared/poincare_helpers.h"
 #include <poincare/addition.h>
 #include <poincare/layout_helper.h>
-#include <poincare/multiplication_explicite.h>
+#include <poincare/multiplication_explicit.h>
 #include <poincare/number.h>
 #include <poincare/power.h>
 #include <poincare/preferences.h>
@@ -66,11 +66,11 @@ Expression TrigonometricModel::expression(double * modelCoefficients) {
  // a*sin(bx+c)+d
  Expression result =
    Addition::Builder(
-      MultiplicationExplicite::Builder(
+      MultiplicationExplicit::Builder(
        Number::DecimalNumber(a),
        Sine::Builder(
          Addition::Builder(
-            MultiplicationExplicite::Builder(
+            MultiplicationExplicit::Builder(
              Number::DecimalNumber(b),
              Symbol::Builder('x')),
            Number::DecimalNumber(c)))),
--- a/apps/sequence/list/type_parameter_controller.cpp
+++ b/apps/sequence/list/type_parameter_controller.cpp
@@ -14,7 +14,7 @@ namespace Sequence {
 TypeParameterController::TypeParameterController(Responder * parentResponder, ListController * list, TableCell::Layout cellLayout,
  KDCoordinate topMargin, KDCoordinate rightMargin, KDCoordinate bottomMargin, KDCoordinate leftMargin) :
  ViewController(parentResponder),
-  m_expliciteCell(I18n::Message::Explicit, cellLayout),
+  m_explicitCell(I18n::Message::Explicit, cellLayout),
  m_singleRecurrenceCell(I18n::Message::SingleRecurrence, cellLayout),
  m_doubleRecurenceCell(I18n::Message::DoubleRecurrence, cellLayout),
  m_layouts{},
@@ -99,7 +99,7 @@ int TypeParameterController::numberOfRows() {
 HighlightCell * TypeParameterController::reusableCell(int index) {
  assert(index >= 0);
  assert(index < k_totalNumberOfCell);
-  HighlightCell * cells[] = {&m_expliciteCell, &m_singleRecurrenceCell, &m_doubleRecurenceCell};
+  HighlightCell * cells[] = {&m_explicitCell, &m_singleRecurrenceCell, &m_doubleRecurenceCell};
  return cells[index];
 }

--- a/apps/sequence/list/type_parameter_controller.h
+++ b/apps/sequence/list/type_parameter_controller.h
@@ -34,7 +34,7 @@ private:
  }
  SequenceStore * sequenceStore();
  constexpr static int k_totalNumberOfCell = 3;
-  ExpressionTableCellWithPointer m_expliciteCell;
+  ExpressionTableCellWithPointer m_explicitCell;
  ExpressionTableCellWithPointer m_singleRecurrenceCell;
  ExpressionTableCellWithPointer m_doubleRecurenceCell;
  Poincare::Layout m_layouts[k_totalNumberOfCell];
--- a/apps/solver/equation_store.cpp
+++ b/apps/solver/equation_store.cpp
@@ -10,7 +10,7 @@
 #include <poincare/opposite.h>
 #include <poincare/addition.h>
 #include <poincare/subtraction.h>
-#include <poincare/multiplication_explicite.h>
+#include <poincare/multiplication_explicit.h>
 #include <poincare/division.h>
 #include <poincare/square_root.h>
 #include <poincare/power.h>
@@ -274,20 +274,20 @@ EquationStore::Error EquationStore::oneDimensialPolynomialSolve(Expression exact
  /* Equation ax^2+bx+c = 0 */
  assert(degree == 2);
  // Compute delta = b*b-4ac
-  Expression delta = Subtraction::Builder(Power::Builder(coefficients[1].clone(), Rational::Builder(2)), MultiplicationExplicite::Builder(Rational::Builder(4), coefficients[0].clone(), coefficients[2].clone()));
+  Expression delta = Subtraction::Builder(Power::Builder(coefficients[1].clone(), Rational::Builder(2)), MultiplicationExplicit::Builder(Rational::Builder(4), coefficients[0].clone(), coefficients[2].clone()));
  delta = delta.simplify(context, updatedComplexFormat(context), Poincare::Preferences::sharedPreferences()->angleUnit());
  if (delta.isUninitialized()) {
    delta = Poincare::Undefined::Builder();
  }
  if (delta.isRationalZero()) {
    // if delta = 0, x0=x1= -b/(2a)
-    exactSolutions[0] = Division::Builder(Opposite::Builder(coefficients[1]), MultiplicationExplicite::Builder(Rational::Builder(2), coefficients[2]));
+    exactSolutions[0] = Division::Builder(Opposite::Builder(coefficients[1]), MultiplicationExplicit::Builder(Rational::Builder(2), coefficients[2]));
    m_numberOfSolutions = 2;
  } else {
    // x0 = (-b-sqrt(delta))/(2a)
-    exactSolutions[0] = Division::Builder(Subtraction::Builder(Opposite::Builder(coefficients[1].clone()), SquareRoot::Builder(delta.clone())), MultiplicationExplicite::Builder(Rational::Builder(2), coefficients[2].clone()));
+    exactSolutions[0] = Division::Builder(Subtraction::Builder(Opposite::Builder(coefficients[1].clone()), SquareRoot::Builder(delta.clone())), MultiplicationExplicit::Builder(Rational::Builder(2), coefficients[2].clone()));
    // x1 = (-b+sqrt(delta))/(2a)
-    exactSolutions[1] = Division::Builder(Addition::Builder(Opposite::Builder(coefficients[1]), SquareRoot::Builder(delta.clone())), MultiplicationExplicite::Builder(Rational::Builder(2), coefficients[2]));
+    exactSolutions[1] = Division::Builder(Addition::Builder(Opposite::Builder(coefficients[1]), SquareRoot::Builder(delta.clone())), MultiplicationExplicit::Builder(Rational::Builder(2), coefficients[2]));
    m_numberOfSolutions = 3;
  }
  exactSolutions[m_numberOfSolutions-1] = delta;
@@ -307,18 +307,18 @@ EquationStore::Error EquationStore::oneDimensialPolynomialSolve(Expression exact
    Expression * mult2Operands[3] = {new Rational::Builder(-27), new Power::Builder(a->clone(), new Rational::Builder(2), false), new Power::Builder(d->clone(), new Rational::Builder(2), false)};
    Expression * mult3Operands[3] = {new Rational::Builder(-4), a->clone(), new Power::Builder(c->clone(), new Rational::Builder(3), false)};
    Expression * mult4Operands[3] = {new Rational::Builder(-4), d->clone(), new Power::Builder(b->clone(), new Rational::Builder(3), false)};
-    Expression * add0Operands[5] = {new MultiplicationExplicite::Builder(mult0Operands, 2, false), new MultiplicationExplicite::Builder(mult1Operands, 5, false), new MultiplicationExplicite::Builder(mult2Operands, 3, false), new MultiplicationExplicite::Builder(mult3Operands, 3, false), new MultiplicationExplicite::Builder(mult4Operands, 3, false)};
+    Expression * add0Operands[5] = {new MultiplicationExplicit::Builder(mult0Operands, 2, false), new MultiplicationExplicit::Builder(mult1Operands, 5, false), new MultiplicationExplicit::Builder(mult2Operands, 3, false), new MultiplicationExplicit::Builder(mult3Operands, 3, false), new MultiplicationExplicit::Builder(mult4Operands, 3, false)};
    Expression * delta = new Addition(add0Operands, 5, false);
    PoincareHelpers::Simplify(&delta, *context);
    // Delta0 = b^2-3ac
    Expression * mult5Operands[3] = {new Rational::Builder(3), a->clone(), c->clone()};
-    Expression * delta0 = new Subtraction::Builder(new Power::Builder(b->clone(), new Rational::Builder(2), false), new MultiplicationExplicite::Builder(mult5Operands, 3, false), false);
+    Expression * delta0 = new Subtraction::Builder(new Power::Builder(b->clone(), new Rational::Builder(2), false), new MultiplicationExplicit::Builder(mult5Operands, 3, false), false);
    Reduce(&delta0, *context);
    if (delta->isRationalZero()) {
      if (delta0->isRationalZero()) {
        // delta0 = 0 && delta = 0 --> x0 = -b/(3a)
        delete delta0;
-        m_exactSolutions[0] = new Opposite::Builder(new Division::Builder(b, new MultiplicationExplicite::Builder(new Rational::Builder(3), a, false), false), false);
+        m_exactSolutions[0] = new Opposite::Builder(new Division::Builder(b, new MultiplicationExplicit::Builder(new Rational::Builder(3), a, false), false), false);
        m_numberOfSolutions = 1;
        delete c;
        delete d;
@@ -326,33 +326,33 @@ EquationStore::Error EquationStore::oneDimensialPolynomialSolve(Expression exact
        // delta = 0 --> x0 = (9ad-bc)/(2delta0)
        //           --> x1 = (4abc-9a^2d-b^3)/(a*delta0)
        Expression * mult6Operands[3] = {new Rational::Builder(9), a, d};
-        m_exactSolutions[0] = new Division::Builder(new Subtraction::Builder(new MultiplicationExplicite::Builder(mult6Operands, 3, false), new MultiplicationExplicite::Builder(b, c, false), false), new MultiplicationExplicite::Builder(new Rational::Builder(2), delta0, false), false);
+        m_exactSolutions[0] = new Division::Builder(new Subtraction::Builder(new MultiplicationExplicit::Builder(mult6Operands, 3, false), new MultiplicationExplicit::Builder(b, c, false), false), new MultiplicationExplicit::Builder(new Rational::Builder(2), delta0, false), false);
        Expression * mult7Operands[4] = {new Rational::Builder(4), a->clone(), b->clone(), c->clone()};
        Expression * mult8Operands[3] = {new Rational::Builder(-9), new Power::Builder(a->clone(), new Rational::Builder(2), false), d->clone()};
-        Expression * add1Operands[3] = {new MultiplicationExplicite::Builder(mult7Operands, 4, false), new MultiplicationExplicite::Builder(mult8Operands,3, false), new Opposite::Builder(new Power::Builder(b->clone(), new Rational::Builder(3), false), false)};
-        m_exactSolutions[1] = new Division::Builder(new Addition(add1Operands, 3, false), new MultiplicationExplicite::Builder(a->clone(), delta0, false), false);
+        Expression * add1Operands[3] = {new MultiplicationExplicit::Builder(mult7Operands, 4, false), new MultiplicationExplicit::Builder(mult8Operands,3, false), new Opposite::Builder(new Power::Builder(b->clone(), new Rational::Builder(3), false), false)};
+        m_exactSolutions[1] = new Division::Builder(new Addition(add1Operands, 3, false), new MultiplicationExplicit::Builder(a->clone(), delta0, false), false);
        m_numberOfSolutions = 2;
      }
    } else {
      // delta1 = 2b^3-9abc+27a^2*d
      Expression * mult9Operands[4] = {new Rational::Builder(-9), a, b, c};
      Expression * mult10Operands[3] = {new Rational::Builder(27), new Power::Builder(a->clone(), new Rational::Builder(2), false), d};
-      Expression * add2Operands[3] = {new MultiplicationExplicite::Builder(new Rational::Builder(2), new Power::Builder(b->clone(), new Rational::Builder(3), false), false), new MultiplicationExplicite::Builder(mult9Operands, 4, false), new MultiplicationExplicite::Builder(mult10Operands, 3, false)};
+      Expression * add2Operands[3] = {new MultiplicationExplicit::Builder(new Rational::Builder(2), new Power::Builder(b->clone(), new Rational::Builder(3), false), false), new MultiplicationExplicit::Builder(mult9Operands, 4, false), new MultiplicationExplicit::Builder(mult10Operands, 3, false)};
      Expression * delta1 = new Addition(add2Operands, 3, false);
      // C = Root((delta1+sqrt(-27a^2*delta))/2, 3)
      Expression * mult11Operands[3] = {new Rational::Builder(-27), new Power::Builder(a->clone(), new Rational::Builder(2), false), (*delta)->clone()};
-      Expression * c = new Power::Builder(new Division::Builder(new Addition(delta1, new SquareRoot(new MultiplicationExplicite::Builder(mult11Operands, 3, false), false), false), new Rational::Builder(2), false), new Rational::Builder(1,3), false);
-      Expression * unary3roots[2] = {new Addition(new Rational::Builder(-1,2), new Division::Builder(new MultiplicationExplicite::Builder(new SquareRoot(new Rational::Builder(3), false), new Constant::Builder(UCodePointMathematicalBoldSmallI), false), new Rational::Builder(2), false), false), new Subtraction::Builder(new Rational::Builder(-1,2), new Division::Builder(new MultiplicationExplicite::Builder(new SquareRoot(new Rational::Builder(3), false), new Constant::Builder(UCodePointMathematicalBoldSmallI), false), new Rational::Builder(2), false), false)};
+      Expression * c = new Power::Builder(new Division::Builder(new Addition(delta1, new SquareRoot(new MultiplicationExplicit::Builder(mult11Operands, 3, false), false), false), new Rational::Builder(2), false), new Rational::Builder(1,3), false);
+      Expression * unary3roots[2] = {new Addition(new Rational::Builder(-1,2), new Division::Builder(new MultiplicationExplicit::Builder(new SquareRoot(new Rational::Builder(3), false), new Constant::Builder(UCodePointMathematicalBoldSmallI), false), new Rational::Builder(2), false), false), new Subtraction::Builder(new Rational::Builder(-1,2), new Division::Builder(new MultiplicationExplicit::Builder(new SquareRoot(new Rational::Builder(3), false), new Constant::Builder(UCodePointMathematicalBoldSmallI), false), new Rational::Builder(2), false), false)};
      // x_k = -1/(3a)*(b+C*z+delta0/(zC)) with z = unary cube root
      for (int k = 0; k < 3; k++) {
        Expression * ccopy = c;
        Expression * delta0copy = delta0;
        if (k < 2) {
-          ccopy = new MultiplicationExplicite::Builder(c->clone(), unary3roots[k], false);
+          ccopy = new MultiplicationExplicit::Builder(c->clone(), unary3roots[k], false);
          delta0copy = delta0->clone();
        }
        Expression * add3Operands[3] = {b->clone(), ccopy, new Division::Builder(delta0copy, ccopy->clone(), false)};
-        m_exactSolutions[k] = new MultiplicationExplicite::Builder(new Division::Builder(new Rational::Builder(-1), new MultiplicationExplicite::Builder(new Rational::Builder(3), a->clone(), false), false), new Addition(add3Operands, 3, false), false);
+        m_exactSolutions[k] = new MultiplicationExplicit::Builder(new Division::Builder(new Rational::Builder(-1), new MultiplicationExplicit::Builder(new Rational::Builder(3), a->clone(), false), false), new Addition(add3Operands, 3, false), false);
      }
      m_numberOfSolutions = 3;
    }
--- a/poincare/Makefile
+++ b/poincare/Makefile
@@ -91,8 +91,8 @@ poincare_src += $(addprefix poincare/src/,\
  matrix_trace.cpp \
  matrix_transpose.cpp \
  multiplication.cpp \
-  multiplication_explicite.cpp \
-  multiplication_implicite.cpp \
+  multiplication_explicit.cpp \
+  multiplication_implicit.cpp \
  n_ary_expression.cpp \
  naperian_logarithm.cpp \
  nth_root.cpp \
--- a/poincare/include/poincare/complex_cartesian.h
+++ b/poincare/include/poincare/complex_cartesian.h
@@ -2,7 +2,7 @@
 #define POINCARE_COMPLEX_CARTESIAN_H

 #include <poincare/expression.h>
-#include <poincare/multiplication_explicite.h>
+#include <poincare/multiplication_explicit.h>

 namespace Poincare {

@@ -67,7 +67,7 @@ private:
  static constexpr int k_maxNumberOfNodesBeforeInterrupting = 50;
  void factorAndArgumentOfFunction(Expression e, ExpressionNode::Type searchedType, Expression * factor, Expression * argument, ExpressionNode::ReductionContext reductionContext);
  ComplexCartesian interruptComputationIfManyNodes();
-  static MultiplicationExplicite squareRootHelper(Expression e, ExpressionNode::ReductionContext reductionContext);
+  static MultiplicationExplicit squareRootHelper(Expression e, ExpressionNode::ReductionContext reductionContext);
  static Expression powerHelper(Expression norm, Expression trigo, ExpressionNode::ReductionContext reductionContext);
 };

--- a/poincare/include/poincare/expression.h
+++ b/poincare/include/poincare/expression.h
@@ -61,8 +61,8 @@ class Expression : public TreeHandle {
  friend class MatrixTrace;
  friend class MatrixTranspose;
  friend class Multiplication;
-  friend class MultiplicationExplicite;
-  friend class MultiplicationImplicite;
+  friend class MultiplicationExplicit;
+  friend class MultiplicationImplicit;
  friend class MultiplicationNode;
  friend class NaperianLogarithm;
  friend class NthRoot;
@@ -131,7 +131,7 @@ public:
  bool isOfType(ExpressionNode::Type * types, int length) const { return node()->isOfType(types, length); }
  ExpressionNode::Sign sign(Context * context) const { return node()->sign(context); }
  bool isUndefined() const { return node()->type() == ExpressionNode::Type::Undefined ||  node()->type() == ExpressionNode::Type::Unreal; }
-  bool isMultiplication() const { return node()->type() == ExpressionNode::Type::MultiplicationExplicite ||  node()->type() == ExpressionNode::Type::MultiplicationImplicite; }
+  bool isMultiplication() const { return node()->type() == ExpressionNode::Type::MultiplicationExplicit ||  node()->type() == ExpressionNode::Type::MultiplicationImplicit; }
  bool isNumber() const { return node()->isNumber(); }
  bool isRationalZero() const;
  bool isRationalOne() const;
--- a/poincare/include/poincare/expression_node.h
+++ b/poincare/include/poincare/expression_node.h
@@ -31,8 +31,8 @@ public:
    Decimal,
    Float,
    Infinity,
-    MultiplicationExplicite,
-    MultiplicationImplicite,
+    MultiplicationExplicit,
+    MultiplicationImplicit,
    Power,
    Addition,
    Factorial,
--- a/poincare/include/poincare/factor.h
+++ b/poincare/include/poincare/factor.h
@@ -3,7 +3,7 @@

 #include <poincare/expression.h>
 #include <poincare/rational.h>
-#include <poincare/multiplication_explicite.h>
+#include <poincare/multiplication_explicit.h>
 #include <cmath>

 namespace Poincare {
@@ -45,7 +45,7 @@ public:

  static constexpr Expression::FunctionHelper s_functionHelper = Expression::FunctionHelper("factor", 1, &UntypedBuilderOneChild<Factor>);

-  MultiplicationExplicite createMultiplicationOfIntegerPrimeDecomposition(Integer i, Context * context, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit) const;
+  MultiplicationExplicit createMultiplicationOfIntegerPrimeDecomposition(Integer i, Context * context, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit) const;

  // Expression
  Expression shallowReduce(Context * context);
--- a/poincare/include/poincare/multiplication_explicite.h
+++ b/poincare/include/poincare/multiplication_explicite.h
@@ -1,25 +1,25 @@
-#ifndef POINCARE_MULTIPLICATION_EXPLICITE_H
-#define POINCARE_MULTIPLICATION_EXPLICITE_H
+#ifndef POINCARE_MULTIPLICATION_EXPLICIT_H
+#define POINCARE_MULTIPLICATION_EXPLICIT_H

 #include <poincare/multiplication.h>
 #include <poincare/n_ary_expression.h>

 namespace Poincare {

-class MultiplicationExpliciteNode /*final*/ : public MultiplicationNode {
+class MultiplicationExplicitNode /*final*/ : public MultiplicationNode {
  friend class Addition;
 public:
  using MultiplicationNode::MultiplicationNode;
  // Tree
-  size_t size() const override { return sizeof(MultiplicationExpliciteNode); }
+  size_t size() const override { return sizeof(MultiplicationExplicitNode); }
 #if POINCARE_TREE_LOG
  virtual void logNodeName(std::ostream & stream) const override {
-    stream << "Multiplication Explicite";
+    stream << "Multiplication Explicit";
  }
 #endif

  // Properties
-  Type type() const override { return Type::MultiplicationExplicite; }
+  Type type() const override { return Type::MultiplicationExplicit; }

 private:
  // Property
@@ -38,18 +38,18 @@ private:

 };

-class MultiplicationExplicite : public Multiplication {
+class MultiplicationExplicit : public Multiplication {
  friend class AdditionNode;
  friend class Addition;
  friend class Power;
 public:
-  MultiplicationExplicite(const MultiplicationExpliciteNode * n) : Multiplication(n) {}
-  static MultiplicationExplicite Builder() { return TreeHandle::NAryBuilder<MultiplicationExplicite, MultiplicationExpliciteNode>(); }
-  static MultiplicationExplicite Builder(Expression e1) { return MultiplicationExplicite::Builder(&e1, 1); }
-  static MultiplicationExplicite Builder(Expression e1, Expression e2) { return MultiplicationExplicite::Builder(ArrayBuilder<Expression>(e1, e2).array(), 2); }
-  static MultiplicationExplicite Builder(Expression e1, Expression e2, Expression e3) { return MultiplicationExplicite::Builder(ArrayBuilder<Expression>(e1, e2, e3).array(), 3); }
-  static MultiplicationExplicite Builder(Expression e1, Expression e2, Expression e3, Expression e4) { return MultiplicationExplicite::Builder(ArrayBuilder<Expression>(e1, e2, e3, e4).array(), 4); }
-  static MultiplicationExplicite Builder(Expression * children, size_t numberOfChildren) { return TreeHandle::NAryBuilder<MultiplicationExplicite, MultiplicationExpliciteNode>(children, numberOfChildren); }
+  MultiplicationExplicit(const MultiplicationExplicitNode * n) : Multiplication(n) {}
+  static MultiplicationExplicit Builder() { return TreeHandle::NAryBuilder<MultiplicationExplicit, MultiplicationExplicitNode>(); }
+  static MultiplicationExplicit Builder(Expression e1) { return MultiplicationExplicit::Builder(&e1, 1); }
+  static MultiplicationExplicit Builder(Expression e1, Expression e2) { return MultiplicationExplicit::Builder(ArrayBuilder<Expression>(e1, e2).array(), 2); }
+  static MultiplicationExplicit Builder(Expression e1, Expression e2, Expression e3) { return MultiplicationExplicit::Builder(ArrayBuilder<Expression>(e1, e2, e3).array(), 3); }
+  static MultiplicationExplicit Builder(Expression e1, Expression e2, Expression e3, Expression e4) { return MultiplicationExplicit::Builder(ArrayBuilder<Expression>(e1, e2, e3, e4).array(), 4); }
+  static MultiplicationExplicit Builder(Expression * children, size_t numberOfChildren) { return TreeHandle::NAryBuilder<MultiplicationExplicit, MultiplicationExplicitNode>(children, numberOfChildren); }

  Expression setSign(ExpressionNode::Sign s, ExpressionNode::ReductionContext reductionContext);
  Expression shallowReduce(ExpressionNode::ReductionContext reductionContext);
--- a/poincare/include/poincare/multiplication_implicite.h
+++ b/poincare/include/poincare/multiplication_implicite.h
@@ -1,26 +1,26 @@
-#ifndef POINCARE_MULTIPLICATION_IMPLICITE_H
-#define POINCARE_MULTIPLICATION_IMPLICITE_H
+#ifndef POINCARE_MULTIPLICATION_IMPLICIT_H
+#define POINCARE_MULTIPLICATION_IMPLICIT_H

 #include <poincare/multiplication.h>

 namespace Poincare {

-class MultiplicationImplicite;
+class MultiplicationImplicit;

-class MultiplicationImpliciteNode /*final*/ : public MultiplicationNode {
+class MultiplicationImplicitNode /*final*/ : public MultiplicationNode {
 public:
  using MultiplicationNode::MultiplicationNode;

  // Tree
-  size_t size() const override { return sizeof(MultiplicationImpliciteNode); }
+  size_t size() const override { return sizeof(MultiplicationImplicitNode); }
 #if POINCARE_TREE_LOG
  virtual void logNodeName(std::ostream & stream) const override {
-    stream << "Multiplication Implicite";
+    stream << "Multiplication Implicit";
  }
 #endif

  // Properties
-  Type type() const override { return Type::MultiplicationImplicite; }
+  Type type() const override { return Type::MultiplicationImplicit; }

 private:
  // Layout
@@ -34,11 +34,11 @@ private:
  Expression shallowReduce(ReductionContext reductionContext) override;
 };

-class MultiplicationImplicite : public Multiplication {
+class MultiplicationImplicit : public Multiplication {
 public:
-  MultiplicationImplicite(const MultiplicationImpliciteNode * n) : Multiplication(n) {}
-  static MultiplicationImplicite Builder(Expression e1, Expression e2) { return MultiplicationImplicite::Builder(ArrayBuilder<Expression>(e1, e2).array(), 2); }
-  static MultiplicationImplicite Builder(Expression * children, size_t numberOfChildren) { return TreeHandle::NAryBuilder<MultiplicationImplicite, MultiplicationImpliciteNode>(children, numberOfChildren); }
+  MultiplicationImplicit(const MultiplicationImplicitNode * n) : Multiplication(n) {}
+  static MultiplicationImplicit Builder(Expression e1, Expression e2) { return MultiplicationImplicit::Builder(ArrayBuilder<Expression>(e1, e2).array(), 2); }
+  static MultiplicationImplicit Builder(Expression * children, size_t numberOfChildren) { return TreeHandle::NAryBuilder<MultiplicationImplicit, MultiplicationImplicitNode>(children, numberOfChildren); }
  // Simplification
  Expression shallowReduce(ExpressionNode::ReductionContext reductionContext);
 };
--- a/poincare/include/poincare_nodes.h
+++ b/poincare/include/poincare_nodes.h
@@ -49,8 +49,8 @@
 #include <poincare/matrix_inverse.h>
 #include <poincare/matrix_trace.h>
 #include <poincare/matrix_transpose.h>
-#include <poincare/multiplication_implicite.h>
-#include <poincare/multiplication_explicite.h>
+#include <poincare/multiplication_implicit.h>
+#include <poincare/multiplication_explicit.h>
 #include <poincare/naperian_logarithm.h>
 #include <poincare/nth_root.h>
 #include <poincare/number.h>
--- a/poincare/src/absolute_value.cpp
+++ b/poincare/src/absolute_value.cpp
@@ -3,7 +3,7 @@
 #include <poincare/serialization_helper.h>
 #include <poincare/absolute_value_layout.h>
 #include <poincare/complex_cartesian.h>
-#include <poincare/multiplication_explicite.h>
+#include <poincare/multiplication_explicit.h>
 #include <assert.h>
 #include <cmath>

@@ -55,7 +55,7 @@ Expression AbsoluteValue::shallowReduce(ExpressionNode::ReductionContext reducti
    } else if (!std::isnan(app) &&
               ((c.isNumber() && app < 0.0f) || app <= -Expression::Epsilon<float>())) {
      // abs(a) = -a with a < 0 (same comment as above to check that a < 0)
-      MultiplicationExplicite m = MultiplicationExplicite::Builder(Rational::Builder(-1), c);
+      MultiplicationExplicit m = MultiplicationExplicit::Builder(Rational::Builder(-1), c);
      replaceWithInPlace(m);
      return m.shallowReduce(reductionContext);
    }
--- a/poincare/src/addition.cpp
+++ b/poincare/src/addition.cpp
@@ -2,7 +2,7 @@
 #include <poincare/complex_cartesian.h>
 #include <poincare/layout_helper.h>
 #include <poincare/matrix.h>
-#include <poincare/multiplication_explicite.h>
+#include <poincare/multiplication_explicit.h>
 #include <poincare/opposite.h>
 #include <poincare/power.h>
 #include <poincare/serialization_helper.h>
@@ -62,7 +62,7 @@ Expression AdditionNode::shallowBeautify(ReductionContext reductionContext) {
 // Addition

 const Number Addition::NumeralFactor(const Expression & e) {
-  if (e.type() == ExpressionNode::Type::MultiplicationExplicite && e.childAtIndex(0).isNumber()) {
+  if (e.type() == ExpressionNode::Type::MultiplicationExplicit && e.childAtIndex(0).isNumber()) {
    Number result = e.childAtIndex(0).convert<Number>();
    return result;
  }
@@ -306,7 +306,7 @@ Expression Addition::shallowReduce(ExpressionNode::ReductionContext reductionCon
 }

 int Addition::NumberOfNonNumeralFactors(const Expression & e) {
-  if (e.type() != ExpressionNode::Type::MultiplicationExplicite) {
+  if (e.type() != ExpressionNode::Type::MultiplicationExplicit) {
    return 1; // Or (e->type() != Type::Rational);
  }
  int result = e.numberOfChildren();
@@ -317,7 +317,7 @@ int Addition::NumberOfNonNumeralFactors(const Expression & e) {
 }

 const Expression Addition::FirstNonNumeralFactor(const Expression & e) {
-  if (e.type() != ExpressionNode::Type::MultiplicationExplicite) {
+  if (e.type() != ExpressionNode::Type::MultiplicationExplicit) {
    return e;
  }
  if (e.childAtIndex(0).isNumber()) {
@@ -347,7 +347,7 @@ bool Addition::TermsHaveIdenticalNonNumeralFactors(const Expression & e1, const
    return FirstNonNumeralFactor(e1).isIdenticalTo(FirstNonNumeralFactor(e2));
  } else {
    assert(numberOfNonNumeralFactors > 1);
-    return MultiplicationExplicite::HaveSameNonNumeralFactors(e1, e2);
+    return MultiplicationExplicit::HaveSameNonNumeralFactors(e1, e2);
  }
 }

@@ -361,7 +361,7 @@ Expression Addition::factorizeOnCommonDenominator(ExpressionNode::ReductionConte
  Addition a = Addition::Builder();

  // Step 1: We want to compute the common denominator, b*d
-  MultiplicationExplicite commonDenominator = MultiplicationExplicite::Builder();
+  MultiplicationExplicit commonDenominator = MultiplicationExplicit::Builder();
  for (int i = 0; i < numberOfChildren(); i++) {
    Expression childI = childAtIndex(i);
    Expression currentDenominator = childI.denominator(reductionContext.context(), reductionContext.complexFormat(), reductionContext.angleUnit());
@@ -391,14 +391,14 @@ Expression Addition::factorizeOnCommonDenominator(ExpressionNode::ReductionConte
  assert(reductionContext.target() ==  ExpressionNode::ReductionTarget::User); // Else, before, the algorithm used User target -> put back ?
  Addition numerator = Addition::Builder();
  for (int i = 0; i < numberOfChildren(); i++) {
-    MultiplicationExplicite m = MultiplicationExplicite::Builder(childAtIndex(i), commonDenominator.clone());
+    MultiplicationExplicit m = MultiplicationExplicit::Builder(childAtIndex(i), commonDenominator.clone());
    numerator.addChildAtIndexInPlace(m, numerator.numberOfChildren(), numerator.numberOfChildren());
    m.privateShallowReduce(reductionContext, true, false);
  }

  // Step 3: Add the denominator
  Power inverseDenominator = Power::Builder(commonDenominator, Rational::Builder(-1));
-  MultiplicationExplicite result = MultiplicationExplicite::Builder(numerator, inverseDenominator);
+  MultiplicationExplicit result = MultiplicationExplicit::Builder(numerator, inverseDenominator);

  // Step 4: Simplify the numerator
  numerator.shallowReduce(reductionContext);
@@ -437,9 +437,9 @@ void Addition::factorizeChildrenAtIndexesInPlace(int index1, int index2, Express
  removeChildAtIndexInPlace(index2);

  // Step 3: Create a multiplication
-  MultiplicationExplicite m = MultiplicationExplicite::Builder();
-  if (e1.type() == ExpressionNode::Type::MultiplicationExplicite) {
-    m = static_cast<MultiplicationExplicite&>(e1);
+  MultiplicationExplicit m = MultiplicationExplicit::Builder();
+  if (e1.type() == ExpressionNode::Type::MultiplicationExplicit) {
+    m = static_cast<MultiplicationExplicit&>(e1);
  } else {
    replaceChildAtIndexInPlace(index1, m);
    m.addChildAtIndexInPlace(e1, 0, 0);
--- a/poincare/src/complex_cartesian.cpp
+++ b/poincare/src/complex_cartesian.cpp
@@ -83,12 +83,12 @@ void ComplexCartesian::factorAndArgumentOfFunction(Expression e, ExpressionNode:
    *argument = e.childAtIndex(0);
    return;
  }
-  if (e.type() == ExpressionNode::Type::MultiplicationExplicite) {
+  if (e.type() == ExpressionNode::Type::MultiplicationExplicit) {
    for (int i = 0; i < e.numberOfChildren(); i++) {
      if (e.childAtIndex(i).type() == searchedType) {
        *argument = e.childAtIndex(i).childAtIndex(0);
        *factor = e.clone();
-        static_cast<MultiplicationExplicite *>(factor)->removeChildAtIndexInPlace(i);
+        static_cast<MultiplicationExplicit *>(factor)->removeChildAtIndexInPlace(i);
        *factor = factor->shallowReduce(reductionContext);
        Expression positiveFactor = factor->makePositiveAnyNegativeNumeralFactor(reductionContext);
        *factor = positiveFactor.isUninitialized() ? *factor : positiveFactor;
@@ -157,7 +157,7 @@ Expression ComplexCartesian::argument(ExpressionNode::ReductionContext reduction
    }
    // Then, compute sign(b) * π/2 - atan(a/b)
    Expression signb = SignFunction::Builder(b);
-    Expression signbPi2 = MultiplicationExplicite::Builder(Rational::Builder(1,2), signb, Constant::Builder(UCodePointGreekSmallLetterPi));
+    Expression signbPi2 = MultiplicationExplicit::Builder(Rational::Builder(1,2), signb, Constant::Builder(UCodePointGreekSmallLetterPi));
    signb.shallowReduce(reductionContext);
    Expression sub = Subtraction::Builder(signbPi2, arcTangent);
    signbPi2.shallowReduce(reductionContext);
@@ -168,7 +168,7 @@ Expression ComplexCartesian::argument(ExpressionNode::ReductionContext reduction
    Expression signa = SignFunction::Builder(a).shallowReduce(reductionContext);
    Subtraction sub = Subtraction::Builder(Rational::Builder(1), signa);
    signa.shallowReduce(reductionContext);
-    MultiplicationExplicite mul = MultiplicationExplicite::Builder(Rational::Builder(1,2), Constant::Builder(UCodePointGreekSmallLetterPi), sub);
+    MultiplicationExplicit mul = MultiplicationExplicit::Builder(Rational::Builder(1,2), Constant::Builder(UCodePointGreekSmallLetterPi), sub);
    sub.shallowReduce(reductionContext);
    return mul;
  }
@@ -184,10 +184,10 @@ ComplexCartesian ComplexCartesian::inverse(ExpressionNode::ReductionContext redu
  denominatorReal.shallowReduce(reductionContext);
  Expression denominatorImagInv = Power::Builder(denominatorImag, Rational::Builder(-1));
  denominatorImag.shallowReduce(reductionContext);
-  MultiplicationExplicite A = MultiplicationExplicite::Builder(a, denominatorRealInv);
+  MultiplicationExplicit A = MultiplicationExplicit::Builder(a, denominatorRealInv);
  denominatorRealInv.shallowReduce(reductionContext);
-  Expression numeratorImag = MultiplicationExplicite::Builder(Rational::Builder(-1), b);
-  MultiplicationExplicite B = MultiplicationExplicite::Builder(numeratorImag, denominatorImagInv);
+  Expression numeratorImag = MultiplicationExplicit::Builder(Rational::Builder(-1), b);
+  MultiplicationExplicit B = MultiplicationExplicit::Builder(numeratorImag, denominatorImagInv);
  numeratorImag.shallowReduce(reductionContext);
  denominatorImagInv.shallowReduce(reductionContext);
  ComplexCartesian result = ComplexCartesian::Builder(A,B);
@@ -196,13 +196,13 @@ ComplexCartesian ComplexCartesian::inverse(ExpressionNode::ReductionContext redu
  return result.interruptComputationIfManyNodes();
 }

-MultiplicationExplicite ComplexCartesian::squareRootHelper(Expression e, ExpressionNode::ReductionContext reductionContext) {
+MultiplicationExplicit ComplexCartesian::squareRootHelper(Expression e, ExpressionNode::ReductionContext reductionContext) {
  //(1/2)*sqrt(2*e)
-  MultiplicationExplicite doubleE = MultiplicationExplicite::Builder(Rational::Builder(2), e);
+  MultiplicationExplicit doubleE = MultiplicationExplicit::Builder(Rational::Builder(2), e);
  e.shallowReduce(reductionContext);
  Expression sqrt = SquareRoot::Builder(doubleE);
  doubleE.shallowReduce(reductionContext);
-  MultiplicationExplicite result = MultiplicationExplicite::Builder(Rational::Builder(1,2), sqrt);
+  MultiplicationExplicit result = MultiplicationExplicit::Builder(Rational::Builder(1,2), sqrt);
  sqrt.shallowReduce(reductionContext);
  return result;
 }
@@ -217,11 +217,11 @@ ComplexCartesian ComplexCartesian::squareRoot(ExpressionNode::ReductionContext r
  // A = (1/2)*sqrt(2*(sqrt(a^2+b^2)+a))
  Addition normAdda = Addition::Builder(normA, a.clone());
  normA.shallowReduce(reductionContext);
-  MultiplicationExplicite A = squareRootHelper(normAdda, reductionContext);
+  MultiplicationExplicit A = squareRootHelper(normAdda, reductionContext);
  // B = B: (1/2)*sqrt(2*(sqrt(a^2+b^2)-a))
  Subtraction normSuba = Subtraction::Builder(normB, a);
  normB.shallowReduce(reductionContext);
-  MultiplicationExplicite B = squareRootHelper(normSuba, reductionContext);
+  MultiplicationExplicit B = squareRootHelper(normSuba, reductionContext);
  // B = B: (1/2)*sqrt(2*(sqrt(a^2+b^2)-a))*sign(b)
  Expression signb = SignFunction::Builder(b);
  B.addChildAtIndexInPlace(signb, B.numberOfChildren(), B.numberOfChildren());
@@ -245,7 +245,7 @@ ComplexCartesian ComplexCartesian::powerInteger(int n, ExpressionNode::Reduction
    ComplexCartesian result;
    Expression bpow = Power::Builder(b, Rational::Builder(n));
    if (n/2%2 == 1) {
-      Expression temp = MultiplicationExplicite::Builder(Rational::Builder(-1), bpow);
+      Expression temp = MultiplicationExplicit::Builder(Rational::Builder(-1), bpow);
      bpow.shallowReduce(reductionContext);
      bpow = temp;
    }
@@ -269,7 +269,7 @@ ComplexCartesian ComplexCartesian::powerInteger(int n, ExpressionNode::Reduction
    Expression bclone = i == n ? b : b.clone();
    Power apow = Power::Builder(aclone, Rational::Builder(n-i));
    Power bpow = Power::Builder(bclone, Rational::Builder(i));
-    MultiplicationExplicite m = MultiplicationExplicite::Builder(binom, apow, bpow);
+    MultiplicationExplicit m = MultiplicationExplicit::Builder(binom, apow, bpow);
    binom.shallowReduce(reductionContext.context());
    apow.shallowReduce(reductionContext);
    bpow.shallowReduce(reductionContext);
@@ -299,14 +299,14 @@ ComplexCartesian ComplexCartesian::multiply(ComplexCartesian & other, Expression
  Expression d = other.imag();
  // (a+ib) * (c+id) = (ac-bd)+i*(ad+bc)
  // Compute ac-bd
-  Expression ac =  MultiplicationExplicite::Builder(a.clone(), c.clone());
-  Expression bd =  MultiplicationExplicite::Builder(b.clone(), d.clone());
+  Expression ac =  MultiplicationExplicit::Builder(a.clone(), c.clone());
+  Expression bd =  MultiplicationExplicit::Builder(b.clone(), d.clone());
  Subtraction A = Subtraction::Builder(ac, bd);
  ac.shallowReduce(reductionContext);
  bd.shallowReduce(reductionContext);
  // Compute ad+bc
-  Expression ad =  MultiplicationExplicite::Builder(a, d);
-  Expression bc =  MultiplicationExplicite::Builder(b, c);
+  Expression ad =  MultiplicationExplicit::Builder(a, d);
+  Expression bc =  MultiplicationExplicit::Builder(b, c);
  Addition B = Addition::Builder(ad, bc);
  ad.shallowReduce(reductionContext);
  bc.shallowReduce(reductionContext);
@@ -317,7 +317,7 @@ ComplexCartesian ComplexCartesian::multiply(ComplexCartesian & other, Expression
 }

 Expression ComplexCartesian::powerHelper(Expression norm, Expression trigo, ExpressionNode::ReductionContext reductionContext) {
-  MultiplicationExplicite m = MultiplicationExplicite::Builder(norm, trigo);
+  MultiplicationExplicit m = MultiplicationExplicit::Builder(norm, trigo);
  norm.shallowReduce(reductionContext);
  trigo.shallowReduce(reductionContext);
  return m;
@@ -333,20 +333,20 @@ ComplexCartesian ComplexCartesian::power(ComplexCartesian & other, ExpressionNod
  // R = r^c*e^(-th*d)
  Expression rpowc = Power::Builder(rclone, c.clone());
  rclone.shallowReduce(reductionContext);
-  Expression thmuld = MultiplicationExplicite::Builder(Rational::Builder(-1), thclone, d.clone());
+  Expression thmuld = MultiplicationExplicit::Builder(Rational::Builder(-1), thclone, d.clone());
  thclone.shallowReduce(reductionContext);
  Expression exp = Power::Builder(Constant::Builder(UCodePointScriptSmallE), thmuld);
  thmuld.shallowReduce(reductionContext);
-  MultiplicationExplicite norm = MultiplicationExplicite::Builder(rpowc, exp);
+  MultiplicationExplicit norm = MultiplicationExplicit::Builder(rpowc, exp);
  rpowc.shallowReduce(reductionContext);
  exp.shallowReduce(reductionContext);

  // TH = d*ln(r)+c*th
  Expression lnr = NaperianLogarithm::Builder(r);
  r.shallowReduce(reductionContext);
-  MultiplicationExplicite dlnr = MultiplicationExplicite::Builder(d, lnr);
+  MultiplicationExplicit dlnr = MultiplicationExplicit::Builder(d, lnr);
  lnr.shallowReduce(reductionContext);
-  MultiplicationExplicite thc = MultiplicationExplicite::Builder(th, c);
+  MultiplicationExplicit thc = MultiplicationExplicit::Builder(th, c);
  th.shallowReduce(reductionContext);
  Expression argument = Addition::Builder(thc, dlnr);
  thc.shallowReduce(reductionContext);
--- a/poincare/src/confidence_interval.cpp
+++ b/poincare/src/confidence_interval.cpp
@@ -1,7 +1,7 @@
 #include <poincare/confidence_interval.h>
 #include <poincare/addition.h>
 #include <poincare/matrix.h>
-#include <poincare/multiplication_explicite.h>
+#include <poincare/multiplication_explicit.h>
 #include <poincare/power.h>
 #include <poincare/layout_helper.h>
 #include <poincare/serialization_helper.h>
@@ -84,7 +84,7 @@ Expression ConfidenceInterval::shallowReduce(ExpressionNode::ReductionContext re
  // Compute [r0-1/sqr(r1), r0+1/sqr(r1)]
  Expression sqr = Power::Builder(r1, Rational::Builder(-1, 2));
  Matrix matrix = Matrix::Builder();
-  matrix.addChildAtIndexInPlace(Addition::Builder(r0.clone(), MultiplicationExplicite::Builder(Rational::Builder(-1), sqr.clone())), 0, 0);
+  matrix.addChildAtIndexInPlace(Addition::Builder(r0.clone(), MultiplicationExplicit::Builder(Rational::Builder(-1), sqr.clone())), 0, 0);
  matrix.addChildAtIndexInPlace(Addition::Builder(r0, sqr), 1, 1);
  matrix.setDimensions(1, 2);
  replaceWithInPlace(matrix);
--- a/poincare/src/conjugate.cpp
+++ b/poincare/src/conjugate.cpp
@@ -1,7 +1,7 @@
 #include <poincare/conjugate.h>
 #include <poincare/conjugate_layout.h>
 #include <poincare/complex_cartesian.h>
-#include <poincare/multiplication_explicite.h>
+#include <poincare/multiplication_explicit.h>
 #include <poincare/rational.h>
 #include <poincare/serialization_helper.h>

@@ -49,7 +49,7 @@ Expression Conjugate::shallowReduce(ExpressionNode::ReductionContext reductionCo
  }
  if (c.type() == ExpressionNode::Type::ComplexCartesian) {
    ComplexCartesian complexChild = static_cast<ComplexCartesian &>(c);
-    MultiplicationExplicite m = MultiplicationExplicite::Builder(Rational::Builder(-1), complexChild.imag());
+    MultiplicationExplicit m = MultiplicationExplicit::Builder(Rational::Builder(-1), complexChild.imag());
    complexChild.replaceChildAtIndexInPlace(1, m);
    m.shallowReduce(reductionContext);
    replaceWithInPlace(complexChild);
--- a/poincare/src/determinant.cpp
+++ b/poincare/src/determinant.cpp
@@ -1,7 +1,7 @@
 #include <poincare/determinant.h>
 #include <poincare/addition.h>
 #include <poincare/matrix.h>
-#include <poincare/multiplication_explicite.h>
+#include <poincare/multiplication_explicit.h>
 #include <poincare/layout_helper.h>
 #include <poincare/rational.h>
 #include <poincare/serialization_helper.h>
--- a/poincare/src/division.cpp
+++ b/poincare/src/division.cpp
@@ -1,7 +1,7 @@
 #include <poincare/division.h>
 #include <poincare/fraction_layout.h>
-#include <poincare/multiplication_explicite.h>
-#include <poincare/multiplication_implicite.h>
+#include <poincare/multiplication_explicit.h>
+#include <poincare/multiplication_implicit.h>
 #include <poincare/opposite.h>
 #include <poincare/power.h>
 #include <poincare/rational.h>
@@ -35,7 +35,7 @@ bool DivisionNode::childNeedsSystemParenthesesAtSerialization(const TreeNode * c
  if (static_cast<const ExpressionNode *>(child)->type() == Type::Rational && !static_cast<const RationalNode *>(child)->isInteger()) {
    return true;
  }
-  Type types[] = {Type::Subtraction, Type::Opposite, Type::MultiplicationExplicite, Type::Division, Type::Addition};
+  Type types[] = {Type::Subtraction, Type::Opposite, Type::MultiplicationExplicit, Type::Division, Type::Addition};
  return static_cast<const ExpressionNode *>(child)->isOfType(types, 6);
 }

@@ -81,7 +81,7 @@ Expression Division::shallowReduce(ExpressionNode::ReductionContext reductionCon
  /* For matrices: we decided that A/B is computed as A = A/B * B so A/B = AB^-1
   * (it could have been A = B * A/B so A/B = B^-1*A). */
  Expression p = Power::Builder(childAtIndex(1), Rational::Builder(-1));
-  MultiplicationExplicite m = MultiplicationExplicite::Builder(childAtIndex(0), p);
+  MultiplicationExplicit m = MultiplicationExplicit::Builder(childAtIndex(0), p);
  p.shallowReduce(reductionContext); // For instance: Division::Builder(2,1). p would be 1^(-1) which can be simplified
  replaceWithInPlace(m);
  return m.shallowReduce(reductionContext);
--- a/poincare/src/expression.cpp
+++ b/poincare/src/expression.cpp
@@ -111,7 +111,7 @@ bool Expression::IsRandom(const Expression e, Context * context) {
 }

 bool Expression::IsNAry(const Expression e, Context * context) {
-  return e.type() == ExpressionNode::Type::Addition || e.type() == ExpressionNode::Type::MultiplicationExplicite || e.type() == ExpressionNode::Type::MultiplicationImplicite;
+  return e.type() == ExpressionNode::Type::Addition || e.type() == ExpressionNode::Type::MultiplicationExplicit || e.type() == ExpressionNode::Type::MultiplicationImplicit;
 }

 bool Expression::IsMatrix(const Expression e, Context * context) {
@@ -584,12 +584,12 @@ Expression Expression::mapOnMatrixFirstChild(ExpressionNode::ReductionContext re

 Expression Expression::radianToDegree() {
  // e*180/Pi
-  return MultiplicationExplicite::Builder(*this, Rational::Builder(180), Power::Builder(Constant::Builder(UCodePointGreekSmallLetterPi), Rational::Builder(-1)));
+  return MultiplicationExplicit::Builder(*this, Rational::Builder(180), Power::Builder(Constant::Builder(UCodePointGreekSmallLetterPi), Rational::Builder(-1)));
 }

 Expression Expression::degreeToRadian() {
  // e*Pi/180
-  return MultiplicationExplicite::Builder(*this, Rational::Builder(1, 180), Constant::Builder(UCodePointGreekSmallLetterPi));
+  return MultiplicationExplicit::Builder(*this, Rational::Builder(1, 180), Constant::Builder(UCodePointGreekSmallLetterPi));
 }

 Expression Expression::reduce(Context * context, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit) {
@@ -617,8 +617,8 @@ Expression Expression::deepBeautify(ExpressionNode::ReductionContext reductionCo
    }
  }
  // We choose whether or not to omit multiplication sign after beautifying parent and child
-  if (e.type() == ExpressionNode::Type::MultiplicationExplicite) {
-    e = static_cast<MultiplicationExplicite &>(e).omitMultiplicationWhenPossible();
+  if (e.type() == ExpressionNode::Type::MultiplicationExplicit) {
+    e = static_cast<MultiplicationExplicit &>(e).omitMultiplicationWhenPossible();
  }
  return e;
 }
@@ -695,7 +695,7 @@ Expression Expression::CreateComplexExpression(Expression ra, Expression tb, Pre
        if (isOneTb) {
          imag = Constant::Builder(UCodePointMathematicalBoldSmallI);
        } else {
-          imag = MultiplicationImplicite::Builder(tb, Constant::Builder(UCodePointMathematicalBoldSmallI));
+          imag = MultiplicationImplicit::Builder(tb, Constant::Builder(UCodePointMathematicalBoldSmallI));
          imag.shallowAddMissingParenthesis();
        }
      }
@@ -730,7 +730,7 @@ Expression Expression::CreateComplexExpression(Expression ra, Expression tb, Pre
        if (isOneTb) {
          arg = Constant::Builder(UCodePointMathematicalBoldSmallI);
        } else {
-          arg = MultiplicationImplicite::Builder(tb, Constant::Builder(UCodePointMathematicalBoldSmallI));
+          arg = MultiplicationImplicit::Builder(tb, Constant::Builder(UCodePointMathematicalBoldSmallI));
        }
        if (isNegativeTb) {
          arg = Opposite::Builder(arg);
@@ -744,7 +744,7 @@ Expression Expression::CreateComplexExpression(Expression ra, Expression tb, Pre
      } else if (norm.isUninitialized()) {
        return exp;
      } else {
-        Expression result = MultiplicationImplicite::Builder(norm, exp);
+        Expression result = MultiplicationImplicit::Builder(norm, exp);
        result.shallowAddMissingParenthesis();
        return result;
      }
--- a/poincare/src/factor.cpp
+++ b/poincare/src/factor.cpp
@@ -34,10 +34,10 @@ Expression FactorNode::shallowBeautify(ReductionContext reductionContext) {
  return Factor(this).shallowBeautify(reductionContext);
 }

-MultiplicationExplicite Factor::createMultiplicationOfIntegerPrimeDecomposition(Integer i, Context * context, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit) const {
+MultiplicationExplicit Factor::createMultiplicationOfIntegerPrimeDecomposition(Integer i, Context * context, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit) const {
  assert(!i.isZero());
  assert(!i.isNegative());
-  MultiplicationExplicite m = MultiplicationExplicite::Builder();
+  MultiplicationExplicit m = MultiplicationExplicit::Builder();
  Integer factors[Arithmetic::k_maxNumberOfPrimeFactors];
  Integer coefficients[Arithmetic::k_maxNumberOfPrimeFactors];
  int numberOfPrimeFactors = Arithmetic::PrimeFactorization(i, factors, coefficients, Arithmetic::k_maxNumberOfPrimeFactors);
@@ -82,13 +82,13 @@ Expression Factor::shallowBeautify(ExpressionNode::ReductionContext reductionCon
    replaceWithInPlace(r);
    return r;
  }
-  MultiplicationExplicite numeratorDecomp = createMultiplicationOfIntegerPrimeDecomposition(r.unsignedIntegerNumerator(), reductionContext.context(), reductionContext.complexFormat(), reductionContext.angleUnit());
+  MultiplicationExplicit numeratorDecomp = createMultiplicationOfIntegerPrimeDecomposition(r.unsignedIntegerNumerator(), reductionContext.context(), reductionContext.complexFormat(), reductionContext.angleUnit());
  if (numeratorDecomp.numberOfChildren() == 0) {
    return replaceWithUndefinedInPlace();
  }
  Expression result = numeratorDecomp.squashUnaryHierarchyInPlace();
  if (!r.isInteger()) {
-    MultiplicationExplicite denominatorDecomp = createMultiplicationOfIntegerPrimeDecomposition(r.integerDenominator(), reductionContext.context(), reductionContext.complexFormat(), reductionContext.angleUnit());
+    MultiplicationExplicit denominatorDecomp = createMultiplicationOfIntegerPrimeDecomposition(r.integerDenominator(), reductionContext.context(), reductionContext.complexFormat(), reductionContext.angleUnit());
    if (denominatorDecomp.numberOfChildren() == 0) {
      return replaceWithUndefinedInPlace();
    }
--- a/poincare/src/factorial.cpp
+++ b/poincare/src/factorial.cpp
@@ -24,7 +24,7 @@ bool FactorialNode::childNeedsUserParentheses(const Expression & child) const {
    return true;
  }

-  Type types[] = {Type::Subtraction, Type::Opposite, Type::MultiplicationExplicite, Type::MultiplicationImplicite, Type::Addition};
+  Type types[] = {Type::Subtraction, Type::Opposite, Type::MultiplicationExplicit, Type::MultiplicationImplicit, Type::Addition};
  return child.isOfType(types, 5);
 }

--- a/poincare/src/logarithm.cpp
+++ b/poincare/src/logarithm.cpp
@@ -6,7 +6,7 @@
 #include <poincare/division.h>
 #include <poincare/infinity.h>
 #include <poincare/layout_helper.h>
-#include <poincare/multiplication_explicite.h>
+#include <poincare/multiplication_explicit.h>
 #include <poincare/naperian_logarithm.h>
 #include <poincare/power.h>
 #include <poincare/rational.h>
@@ -182,20 +182,20 @@ Expression Logarithm::shallowReduce(ExpressionNode::ReductionContext reductionCo
    Expression x = p.childAtIndex(0);
    Expression y = p.childAtIndex(1);
    replaceChildInPlace(p, x);
-    MultiplicationExplicite mult = MultiplicationExplicite::Builder(y);
+    MultiplicationExplicit mult = MultiplicationExplicit::Builder(y);
    replaceWithInPlace(mult);
    mult.addChildAtIndexInPlace(*this, 1, 1); // --> y*log(x,b)
    shallowReduce(reductionContext); // reduce log (ie log(e, e) = 1)
    return mult.shallowReduce(reductionContext);
  }
  // log(x*y, b)->log(x,b)+log(y, b) if x,y>0
-  if (c.type() == ExpressionNode::Type::MultiplicationExplicite) {
+  if (c.type() == ExpressionNode::Type::MultiplicationExplicit) {
    Addition a = Addition::Builder();
    for (int i = 0; i < c.numberOfChildren()-1; i++) {
      Expression factor = c.childAtIndex(i);
      if (factor.sign(reductionContext.context()) == ExpressionNode::Sign::Positive) {
        Expression newLog = clone();
-        static_cast<MultiplicationExplicite &>(c).removeChildInPlace(factor, factor.numberOfChildren());
+        static_cast<MultiplicationExplicit &>(c).removeChildInPlace(factor, factor.numberOfChildren());
        newLog.replaceChildAtIndexInPlace(0, factor);
        a.addChildAtIndexInPlace(newLog, a.numberOfChildren(), a.numberOfChildren());
        newLog.shallowReduce(reductionContext);
@@ -343,7 +343,7 @@ Expression Logarithm::splitLogarithmInteger(Integer i, bool isDenominator, Expre
    if (!isDenominator) {
      return e;
    }
-    MultiplicationExplicite m = MultiplicationExplicite::Builder(Rational::Builder(-1), e);
+    MultiplicationExplicit m = MultiplicationExplicit::Builder(Rational::Builder(-1), e);
    return m;
  }
  Addition a = Addition::Builder();
@@ -353,7 +353,7 @@ Expression Logarithm::splitLogarithmInteger(Integer i, bool isDenominator, Expre
    }
    Logarithm e = clone().convert<Logarithm>();
    e.replaceChildAtIndexInPlace(0, Rational::Builder(factors[index]));
-    MultiplicationExplicite m = MultiplicationExplicite::Builder(Rational::Builder(coefficients[index]), e);
+    MultiplicationExplicit m = MultiplicationExplicit::Builder(Rational::Builder(coefficients[index]), e);
    e.simpleShallowReduce(reductionContext.context(), reductionContext.complexFormat(), reductionContext.angleUnit());
    a.addChildAtIndexInPlace(m, a.numberOfChildren(), a.numberOfChildren());
    m.shallowReduce(reductionContext);
--- a/poincare/src/matrix.cpp
+++ b/poincare/src/matrix.cpp
@@ -4,7 +4,7 @@
 #include <poincare/exception_checkpoint.h>
 #include <poincare/matrix_complex.h>
 #include <poincare/matrix_layout.h>
-#include <poincare/multiplication_explicite.h>
+#include <poincare/multiplication_explicit.h>
 #include <poincare/rational.h>
 #include <poincare/serialization_helper.h>
 #include <poincare/subtraction.h>
@@ -175,7 +175,7 @@ Matrix Matrix::rowCanonize(ExpressionNode::ReductionContext reductionContext, Ex
  // The matrix children have to be reduced to be able to spot 0
  deepReduceChildren(reductionContext);

-  MultiplicationExplicite det = MultiplicationExplicite::Builder();
+  MultiplicationExplicit det = MultiplicationExplicit::Builder();

  int m = numberOfRows();
  int n = numberOfColumns();
@@ -227,7 +227,7 @@ Matrix Matrix::rowCanonize(ExpressionNode::ReductionContext reductionContext, Ex
        Expression factor = matrixChild(i, k);
        for (int j = k+1; j < n; j++) {
          Expression opIJ = matrixChild(i, j);
-          Expression newOpIJ = Subtraction::Builder(opIJ, MultiplicationExplicite::Builder(matrixChild(h, j).clone(), factor.clone()));
+          Expression newOpIJ = Subtraction::Builder(opIJ, MultiplicationExplicit::Builder(matrixChild(h, j).clone(), factor.clone()));
          replaceChildAtIndexInPlace(i*n+j, newOpIJ);
          newOpIJ.childAtIndex(1).shallowReduce(reductionContext);
          newOpIJ = newOpIJ.shallowReduce(reductionContext);
@@ -346,8 +346,8 @@ Expression Matrix::determinant(ExpressionNode::ReductionContext reductionContext
  if (dim == 2) {
    /*                |a b|
     * Determinant of |c d| is ad-bc   */
-    MultiplicationExplicite ad = MultiplicationExplicite::Builder(m.matrixChild(0,0), m.matrixChild(1,1));
-    MultiplicationExplicite bc = MultiplicationExplicite::Builder(m.matrixChild(0,1), m.matrixChild(1,0));
+    MultiplicationExplicit ad = MultiplicationExplicit::Builder(m.matrixChild(0,0), m.matrixChild(1,1));
+    MultiplicationExplicit bc = MultiplicationExplicit::Builder(m.matrixChild(0,1), m.matrixChild(1,0));
    Expression result = Subtraction::Builder(ad, bc);
    ad.shallowReduce(reductionContext);
    bc.shallowReduce(reductionContext);
@@ -368,12 +368,12 @@ Expression Matrix::determinant(ExpressionNode::ReductionContext reductionContext
    Expression i = m.matrixChild(2,2);
    constexpr int additionChildrenCount = 6;
    Expression additionChildren[additionChildrenCount] = {
-      MultiplicationExplicite::Builder(a.clone(), e.clone(), i.clone()),
-      MultiplicationExplicite::Builder(b.clone(), f.clone(), g.clone()),
-      MultiplicationExplicite::Builder(c.clone(), d.clone(), h.clone()),
-      MultiplicationExplicite::Builder(Rational::Builder(-1), c, e, g),
-      MultiplicationExplicite::Builder(Rational::Builder(-1), b, d, i),
-      MultiplicationExplicite::Builder(Rational::Builder(-1), a, f, h)};
+      MultiplicationExplicit::Builder(a.clone(), e.clone(), i.clone()),
+      MultiplicationExplicit::Builder(b.clone(), f.clone(), g.clone()),
+      MultiplicationExplicit::Builder(c.clone(), d.clone(), h.clone()),
+      MultiplicationExplicit::Builder(Rational::Builder(-1), c, e, g),
+      MultiplicationExplicit::Builder(Rational::Builder(-1), b, d, i),
+      MultiplicationExplicit::Builder(Rational::Builder(-1), a, f, h)};
    Expression result = Addition::Builder(additionChildren, additionChildrenCount);
    for (int i = 0; i < additionChildrenCount; i++) {
      additionChildren[i].shallowReduce(reductionContext);
--- a/poincare/src/multiplication.cpp
+++ b/poincare/src/multiplication.cpp
@@ -1,5 +1,5 @@
 #include <poincare/multiplication.h>
-#include <poincare/multiplication_explicite.h>
+#include <poincare/multiplication_explicit.h>
 #include <poincare/addition.h>
 #include <poincare/arithmetic.h>
 #include <poincare/division.h>
@@ -120,14 +120,14 @@ int Multiplication::getPolynomialCoefficients(Context * context, const char * sy
      int jbis = j > degI ? degI : j;
      for (int l = 0; l <= jbis ; l++) {
        // Always copy the a and b coefficients are they are used multiple times
-        a.addChildAtIndexInPlace(MultiplicationExplicite::Builder(intermediateCoefficients[l].clone(), coefficients[j-l].clone()), a.numberOfChildren(), a.numberOfChildren());
+        a.addChildAtIndexInPlace(MultiplicationExplicit::Builder(intermediateCoefficients[l].clone(), coefficients[j-l].clone()), a.numberOfChildren(), a.numberOfChildren());
      }
      /* a(j) and b(j) are used only to compute coefficient at rank >= j, we
       * can delete them as we compute new coefficient by decreasing ranks. */
      coefficients[j] = a;
    }
    // new coefficients[0] = a(0)*b(0)
-    coefficients[0] = MultiplicationExplicite::Builder(coefficients[0], intermediateCoefficients[0]);
+    coefficients[0] = MultiplicationExplicit::Builder(coefficients[0], intermediateCoefficients[0]);
  }
  return deg;
 }
--- a/poincare/src/multiplication_explicite.cpp
+++ b/poincare/src/multiplication_explicite.cpp
@@ -1,5 +1,5 @@
-#include <poincare/multiplication_explicite.h>
-#include <poincare/multiplication_implicite.h>
+#include <poincare/multiplication_explicit.h>
+#include <poincare/multiplication_implicit.h>
 #include <poincare/addition.h>
 #include <poincare/arithmetic.h>
 #include <poincare/division.h>
@@ -19,40 +19,40 @@

 namespace Poincare {

-Expression MultiplicationExpliciteNode::setSign(Sign s, ReductionContext reductionContext) {
+Expression MultiplicationExplicitNode::setSign(Sign s, ReductionContext reductionContext) {
  assert(s == ExpressionNode::Sign::Positive);
-  return MultiplicationExplicite(this).setSign(s, reductionContext);
+  return MultiplicationExplicit(this).setSign(s, reductionContext);
 }

-Layout MultiplicationExpliciteNode::createLayout(Preferences::PrintFloatMode floatDisplayMode, int numberOfSignificantDigits) const {
+Layout MultiplicationExplicitNode::createLayout(Preferences::PrintFloatMode floatDisplayMode, int numberOfSignificantDigits) const {
  constexpr int stringMaxSize = CodePoint::MaxCodePointCharLength + 1;
  char string[stringMaxSize];
  SerializationHelper::CodePoint(string, stringMaxSize, UCodePointMultiplicationSign);
-  return LayoutHelper::Infix(MultiplicationExplicite(this), floatDisplayMode, numberOfSignificantDigits, string);
+  return LayoutHelper::Infix(MultiplicationExplicit(this), floatDisplayMode, numberOfSignificantDigits, string);
 }

-int MultiplicationExpliciteNode::serialize(char * buffer, int bufferSize, Preferences::PrintFloatMode floatDisplayMode, int numberOfSignificantDigits) const {
+int MultiplicationExplicitNode::serialize(char * buffer, int bufferSize, Preferences::PrintFloatMode floatDisplayMode, int numberOfSignificantDigits) const {
  constexpr int stringMaxSize = CodePoint::MaxCodePointCharLength + 1;
  char string[stringMaxSize];
  SerializationHelper::CodePoint(string, stringMaxSize, UCodePointMultiplicationSign);
  return SerializationHelper::Infix(this, buffer, bufferSize, floatDisplayMode, numberOfSignificantDigits, string);
 }

-Expression MultiplicationExpliciteNode::shallowReduce(ReductionContext reductionContext) {
-  return MultiplicationExplicite(this).shallowReduce(reductionContext);
+Expression MultiplicationExplicitNode::shallowReduce(ReductionContext reductionContext) {
+  return MultiplicationExplicit(this).shallowReduce(reductionContext);
 }

-Expression MultiplicationExpliciteNode::shallowBeautify(ReductionContext reductionContext) {
-  return MultiplicationExplicite(this).shallowBeautify(reductionContext);
+Expression MultiplicationExplicitNode::shallowBeautify(ReductionContext reductionContext) {
+  return MultiplicationExplicit(this).shallowBeautify(reductionContext);
 }

-Expression MultiplicationExpliciteNode::denominator(Context * context, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit) const {
-  return MultiplicationExplicite(this).denominator(context, complexFormat, angleUnit);
+Expression MultiplicationExplicitNode::denominator(Context * context, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit) const {
+  return MultiplicationExplicit(this).denominator(context, complexFormat, angleUnit);
 }

-/* MultiplicationExplicite */
+/* MultiplicationExplicit */

-Expression MultiplicationExplicite::setSign(ExpressionNode::Sign s, ExpressionNode::ReductionContext reductionContext) {
+Expression MultiplicationExplicit::setSign(ExpressionNode::Sign s, ExpressionNode::ReductionContext reductionContext) {
  assert(s == ExpressionNode::Sign::Positive);
  for (int i = 0; i < numberOfChildren(); i++) {
    if (childAtIndex(i).sign(reductionContext.context()) == ExpressionNode::Sign::Negative) {
@@ -62,7 +62,7 @@ Expression MultiplicationExplicite::setSign(ExpressionNode::Sign s, ExpressionNo
  return shallowReduce(reductionContext);
 }

-Expression MultiplicationExplicite::shallowReduce(ExpressionNode::ReductionContext reductionContext) {
+Expression MultiplicationExplicit::shallowReduce(ExpressionNode::ReductionContext reductionContext) {
  return privateShallowReduce(reductionContext, true, true);
 }

@@ -71,17 +71,17 @@ static bool canOmitSignBefore(ExpressionNode::LayoutShape right) {
  return right == ExpressionNode::LayoutShape::SpecialLetter || right == ExpressionNode::LayoutShape::BoundaryPunctuation;
 }

-Expression MultiplicationExplicite::omitMultiplicationWhenPossible() {
+Expression MultiplicationExplicit::omitMultiplicationWhenPossible() {
  int i = 0;
  while (i < numberOfChildren() - 1) {
    Expression childI = childAtIndex(i);
    Expression childI1 = childAtIndex(i+1);
    if (canOmitSignBefore(childI1.node()->leftLayoutShape())) {
-      if (childI.type() == ExpressionNode::Type::MultiplicationImplicite) {
-        static_cast<MultiplicationImplicite &>(childI).addChildAtIndexInPlace(childI1, childI.numberOfChildren(), childI.numberOfChildren());
+      if (childI.type() == ExpressionNode::Type::MultiplicationImplicit) {
+        static_cast<MultiplicationImplicit &>(childI).addChildAtIndexInPlace(childI1, childI.numberOfChildren(), childI.numberOfChildren());
      } else {
-        Expression impliciteMultiplication = MultiplicationImplicite::Builder(childI, childI1);
-        replaceChildAtIndexInPlace(i, impliciteMultiplication);
+        Expression implicitMultiplication = MultiplicationImplicit::Builder(childI, childI1);
+        replaceChildAtIndexInPlace(i, implicitMultiplication);
      }
      removeChildAtIndexInPlace(i+1);
      continue;
@@ -91,7 +91,7 @@ Expression MultiplicationExplicite::omitMultiplicationWhenPossible() {
  return squashUnaryHierarchyInPlace();
 }

-Expression MultiplicationExplicite::shallowBeautify(ExpressionNode::ReductionContext reductionContext) {
+Expression MultiplicationExplicit::shallowBeautify(ExpressionNode::ReductionContext reductionContext) {
  /* Beautifying a Multiplication consists in several possible operations:
   * - Add Opposite ((-3)*x -> -(3*x), useful when printing fractions)
   * - Adding parenthesis if needed (a*(b+c) is not a*b+c)
@@ -114,7 +114,7 @@ Expression MultiplicationExplicite::shallowBeautify(ExpressionNode::ReductionCon
  if (thisExp.type() == ExpressionNode::Type::Power) {
    return thisExp.shallowBeautify(reductionContext);
  }
-  assert(thisExp.type() == ExpressionNode::Type::MultiplicationExplicite);
+  assert(thisExp.type() == ExpressionNode::Type::MultiplicationExplicit);

  // Step 3: Create a Division if needed
  for (int i = 0; i < numberOfChildren(); i++) {
@@ -143,15 +143,15 @@ Expression MultiplicationExplicite::shallowBeautify(ExpressionNode::ReductionCon
  return thisExp;
 }

-Expression MultiplicationExplicite::denominator(Context * context, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit) const {
+Expression MultiplicationExplicit::denominator(Context * context, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit) const {
  // Merge negative power: a*b^-1*c^(-Pi)*d = a*(b*c^Pi)^-1
  // WARNING: we do not want to change the expression but to create a new one.
-  MultiplicationExplicite thisClone = clone().convert<MultiplicationExplicite>();
+  MultiplicationExplicit thisClone = clone().convert<MultiplicationExplicit>();
  Expression e = thisClone.mergeNegativePower(context, complexFormat, angleUnit);
  if (e.type() == ExpressionNode::Type::Power) {
    return e.denominator(context, complexFormat, angleUnit);
  } else {
-    assert(e.type() == ExpressionNode::Type::MultiplicationExplicite);
+    assert(e.type() == ExpressionNode::Type::MultiplicationExplicit);
    for (int i = 0; i < e.numberOfChildren(); i++) {
      // a*b^(-1)*... -> a*.../b
      if (e.childAtIndex(i).type() == ExpressionNode::Type::Power
@@ -165,7 +165,7 @@ Expression MultiplicationExplicite::denominator(Context * context, Preferences::
  return Expression();
 }

-Expression MultiplicationExplicite::privateShallowReduce(ExpressionNode::ReductionContext reductionContext, bool shouldExpand, bool canBeInterrupted) {
+Expression MultiplicationExplicit::privateShallowReduce(ExpressionNode::ReductionContext reductionContext, bool shouldExpand, bool canBeInterrupted) {
  {
    Expression e = Expression::defaultShallowReduce();
    if (e.isUndefined()) {
@@ -173,7 +173,7 @@ Expression MultiplicationExplicite::privateShallowReduce(ExpressionNode::Reducti
    }
  }

-  /* Step 1: MultiplicationExpliciteNode is associative, so let's start by merging children
+  /* Step 1: MultiplicationExplicitNode is associative, so let's start by merging children
   * which also are multiplications themselves. */
  mergeMultiplicationChildrenInPlace();

@@ -232,7 +232,7 @@ Expression MultiplicationExplicite::privateShallowReduce(ExpressionNode::Reducti
        for (int j = 0; j < newResultM; j++) {
          Addition a = Addition::Builder();
          for (int k = 0; k < n; k++) {
-            Expression e = MultiplicationExplicite::Builder(currentMatrix.matrixChild(i, k).clone(), resultMatrix.matrixChild(k, j).clone());
+            Expression e = MultiplicationExplicit::Builder(currentMatrix.matrixChild(i, k).clone(), resultMatrix.matrixChild(k, j).clone());
            a.addChildAtIndexInPlace(e, a.numberOfChildren(), a.numberOfChildren());
            e.shallowReduce(reductionContext);
          }
@@ -258,7 +258,7 @@ Expression MultiplicationExplicite::privateShallowReduce(ExpressionNode::Reducti
      }
      removeChildInPlace(resultMatrix, resultMatrix.numberOfChildren());
      for (int i = 0; i < n*m; i++) {
-        MultiplicationExplicite m = clone().convert<MultiplicationExplicite>();
+        MultiplicationExplicit m = clone().convert<MultiplicationExplicit>();
        Expression entryI = resultMatrix.childAtIndex(i);
        resultMatrix.replaceChildInPlace(entryI, m);
        m.addChildAtIndexInPlace(entryI, m.numberOfChildren(), m.numberOfChildren());
@@ -440,8 +440,8 @@ Expression MultiplicationExplicite::privateShallowReduce(ExpressionNode::Reducti
      i--;
    }
    // The real children are both factors of the real and the imaginary multiplication
-    MultiplicationExplicite real = *this;
-    MultiplicationExplicite imag = clone().convert<MultiplicationExplicite>();
+    MultiplicationExplicit real = *this;
+    MultiplicationExplicit imag = clone().convert<MultiplicationExplicit>();
    real.addChildAtIndexInPlace(child.real(), real.numberOfChildren(), real.numberOfChildren());
    imag.addChildAtIndexInPlace(child.imag(), real.numberOfChildren(), real.numberOfChildren());
    ComplexCartesian newComplexCartesian = ComplexCartesian::Builder();
@@ -456,12 +456,12 @@ Expression MultiplicationExplicite::privateShallowReduce(ExpressionNode::Reducti
  return result;
 }

-void MultiplicationExplicite::mergeMultiplicationChildrenInPlace() {
+void MultiplicationExplicit::mergeMultiplicationChildrenInPlace() {
  // Multiplication is associative: a*(b*c)->a*b*c
  int i = 0;
  while (i < numberOfChildren()) {
    Expression c = childAtIndex(i);
-    if (c.type() == ExpressionNode::Type::MultiplicationExplicite) {
+    if (c.type() == ExpressionNode::Type::MultiplicationExplicit) {
      mergeChildrenAtIndexInPlace(c, i); // TODO: ensure that matrix children are not swapped to implement MATRIX_EXACT_REDUCING
      continue;
    }
@@ -469,10 +469,10 @@ void MultiplicationExplicite::mergeMultiplicationChildrenInPlace() {
  }
 }

-void MultiplicationExplicite::factorizeBase(int i, int j, ExpressionNode::ReductionContext reductionContext) {
+void MultiplicationExplicit::factorizeBase(int i, int j, ExpressionNode::ReductionContext reductionContext) {
  /* This function factorizes two children which have a common base. For example
-   * if this is MultiplicationExplicite::Builder(pi^2, pi^3), then pi^2 and pi^3 could be merged
-   * and this turned into MultiplicationExplicite::Builder(pi^5). */
+   * if this is MultiplicationExplicit::Builder(pi^2, pi^3), then pi^2 and pi^3 could be merged
+   * and this turned into MultiplicationExplicit::Builder(pi^5). */

  Expression e = childAtIndex(j);
  // Step 1: Get rid of the child j
@@ -481,7 +481,7 @@ void MultiplicationExplicite::factorizeBase(int i, int j, ExpressionNode::Reduct
  mergeInChildByFactorizingBase(i, e, reductionContext);
 }

-void MultiplicationExplicite::mergeInChildByFactorizingBase(int i, Expression e, ExpressionNode::ReductionContext reductionContext) {
+void MultiplicationExplicit::mergeInChildByFactorizingBase(int i, Expression e, ExpressionNode::ReductionContext reductionContext) {
  /* This function replace the child at index i by its factorization with e. e
   * and childAtIndex(i) are supposed to have a common base. */

@@ -496,17 +496,17 @@ void MultiplicationExplicite::mergeInChildByFactorizingBase(int i, Expression e,
  /* Step 4: Reducing the new power might have turned it into a multiplication,
   * ie: 12^(1/2) -> 2*3^(1/2). In that case, we need to merge the multiplication
   * node with this. */
-  if (p.type() == ExpressionNode::Type::MultiplicationExplicite) {
+  if (p.type() == ExpressionNode::Type::MultiplicationExplicit) {
    mergeMultiplicationChildrenInPlace();
  }
 }

-void MultiplicationExplicite::factorizeExponent(int i, int j, ExpressionNode::ReductionContext reductionContext) {
+void MultiplicationExplicit::factorizeExponent(int i, int j, ExpressionNode::ReductionContext reductionContext) {
  /* This function factorizes children which share a common exponent. For
-   * example, it turns MultiplicationExplicite::Builder(2^x,3^x) into MultiplicationExplicite::Builder(6^x). */
+   * example, it turns MultiplicationExplicit::Builder(2^x,3^x) into MultiplicationExplicit::Builder(6^x). */

  // Step 1: Find the new base
-  Expression m = MultiplicationExplicite::Builder(Base(childAtIndex(i)), Base(childAtIndex(j))); // 2^x*3^x -> (2*3)^x -> 6^x
+  Expression m = MultiplicationExplicit::Builder(Base(childAtIndex(i)), Base(childAtIndex(j))); // 2^x*3^x -> (2*3)^x -> 6^x
  // Step 2: Get rid of one of the children
  removeChildAtIndexInPlace(j);
  // Step 3: Replace the other child
@@ -517,12 +517,12 @@ void MultiplicationExplicite::factorizeExponent(int i, int j, ExpressionNode::Re
  /* Step 5: Reducing the new power might have turned it into a multiplication,
   * ie: 12^(1/2) -> 2*3^(1/2). In that case, we need to merge the multiplication
   * node with this. */
-  if (p.type() == ExpressionNode::Type::MultiplicationExplicite) {
+  if (p.type() == ExpressionNode::Type::MultiplicationExplicit) {
    mergeMultiplicationChildrenInPlace();
  }
 }

-Expression MultiplicationExplicite::distributeOnOperandAtIndex(int i, ExpressionNode::ReductionContext reductionContext) {
+Expression MultiplicationExplicit::distributeOnOperandAtIndex(int i, ExpressionNode::ReductionContext reductionContext) {
  /* This method creates a*...*b*y... + a*...*c*y... + ... from
   * a*...*(b+c+...)*y... */
  assert(i >= 0 && i < numberOfChildren());
@@ -532,7 +532,7 @@ Expression MultiplicationExplicite::distributeOnOperandAtIndex(int i, Expression
  Expression childI = childAtIndex(i);
  int numberOfAdditionTerms = childI.numberOfChildren();
  for (int j = 0; j < numberOfAdditionTerms; j++) {
-    MultiplicationExplicite m = clone().convert<MultiplicationExplicite>();
+    MultiplicationExplicit m = clone().convert<MultiplicationExplicit>();
    m.replaceChildAtIndexInPlace(i, childI.childAtIndex(j));
    // Reduce m: pi^(-1)*(pi + x) -> pi^(-1)*pi + pi^(-1)*x -> 1 + pi^(-1)*x
    a.addChildAtIndexInPlace(m, a.numberOfChildren(), a.numberOfChildren());
@@ -542,8 +542,8 @@ Expression MultiplicationExplicite::distributeOnOperandAtIndex(int i, Expression
  return a.shallowReduce(reductionContext); // Order terms, put under a common denominator if needed
 }

-void MultiplicationExplicite::addMissingFactors(Expression factor, Context * context, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit) {
-  if (factor.type() == ExpressionNode::Type::MultiplicationExplicite) {
+void MultiplicationExplicit::addMissingFactors(Expression factor, Context * context, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit) {
+  if (factor.type() == ExpressionNode::Type::MultiplicationExplicit) {
    for (int j = 0; j < factor.numberOfChildren(); j++) {
      addMissingFactors(factor.childAtIndex(j), context, complexFormat, angleUnit);
    }
@@ -590,7 +590,7 @@ void MultiplicationExplicite::addMissingFactors(Expression factor, Context * con
  sortChildrenInPlace([](const ExpressionNode * e1, const ExpressionNode * e2, bool canBeInterrupted) { return ExpressionNode::SimplificationOrder(e1, e2, true, canBeInterrupted); }, context, true);
 }

-void MultiplicationExplicite::factorizeSineAndCosine(int i, int j, Context * context, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit) {
+void MultiplicationExplicit::factorizeSineAndCosine(int i, int j, Context * context, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit) {
  /* This function turn sin(x)^p * cos(x)^q into either:
   * - tan(x)^p*cos(x)^(p+q) if |p|<|q|
   * - tan(x)^(-q)*sin(x)^(p+q) otherwise */
@@ -630,7 +630,7 @@ void MultiplicationExplicite::factorizeSineAndCosine(int i, int j, Context * con
  }
 }

-bool MultiplicationExplicite::HaveSameNonNumeralFactors(const Expression & e1, const Expression & e2) {
+bool MultiplicationExplicit::HaveSameNonNumeralFactors(const Expression & e1, const Expression & e2) {
  assert(e1.numberOfChildren() > 0);
  assert(e2.numberOfChildren() > 0);
  int numberOfNonNumeralFactors1 = e1.childAtIndex(0).isNumber() ? e1.numberOfChildren()-1 : e1.numberOfChildren();
@@ -651,26 +651,26 @@ bool MultiplicationExplicite::HaveSameNonNumeralFactors(const Expression & e1, c
  return true;
 }

-const Expression MultiplicationExplicite::CreateExponent(Expression e) {
+const Expression MultiplicationExplicit::CreateExponent(Expression e) {
  Expression result = e.type() == ExpressionNode::Type::Power ? e.childAtIndex(1).clone() : Rational::Builder(1);
  return result;
 }

-bool MultiplicationExplicite::TermsHaveIdenticalBase(const Expression & e1, const Expression & e2) {
+bool MultiplicationExplicit::TermsHaveIdenticalBase(const Expression & e1, const Expression & e2) {
  return Base(e1).isIdenticalTo(Base(e2));
 }

-bool MultiplicationExplicite::TermsHaveIdenticalExponent(const Expression & e1, const Expression & e2) {
+bool MultiplicationExplicit::TermsHaveIdenticalExponent(const Expression & e1, const Expression & e2) {
  /* Note: We will return false for e1=2 and e2=Pi, even though one could argue
   * that these have the same exponent whose value is 1. */
  return e1.type() == ExpressionNode::Type::Power && e2.type() == ExpressionNode::Type::Power && (e1.childAtIndex(1).isIdenticalTo(e2.childAtIndex(1)));
 }

-bool MultiplicationExplicite::TermHasNumeralBase(const Expression & e) {
+bool MultiplicationExplicit::TermHasNumeralBase(const Expression & e) {
  return Base(e).isNumber();
 }

-bool MultiplicationExplicite::TermHasNumeralExponent(const Expression & e) {
+bool MultiplicationExplicit::TermHasNumeralExponent(const Expression & e) {
  if (e.type() != ExpressionNode::Type::Power) {
    return true;
  }
@@ -680,10 +680,10 @@ bool MultiplicationExplicite::TermHasNumeralExponent(const Expression & e) {
  return false;
 }

-Expression MultiplicationExplicite::mergeNegativePower(Context * context, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit) {
+Expression MultiplicationExplicit::mergeNegativePower(Context * context, Preferences::ComplexFormat complexFormat, Preferences::AngleUnit angleUnit) {
  /* mergeNegativePower groups all factors that are power of form a^(-b) together
   * for instance, a^(-1)*b^(-c)*c = c*(a*b^c)^(-1) */
-  MultiplicationExplicite m = MultiplicationExplicite::Builder();
+  MultiplicationExplicit m = MultiplicationExplicit::Builder();
  // Special case for rational p/q: if q != 1, q should be at denominator
  if (childAtIndex(0).type() == ExpressionNode::Type::Rational && !childAtIndex(0).convert<Rational>().isInteger()) {
    Rational r = childAtIndex(0).convert<Rational>();
@@ -724,7 +724,7 @@ Expression MultiplicationExplicite::mergeNegativePower(Context * context, Prefer
  return squashUnaryHierarchyInPlace();
 }

-const Expression MultiplicationExplicite::Base(const Expression e) {
+const Expression MultiplicationExplicit::Base(const Expression e) {
  if (e.type() == ExpressionNode::Type::Power) {
    return e.childAtIndex(0);
  }
--- a/poincare/src/multiplication_implicite.cpp
+++ b/poincare/src/multiplication_implicite.cpp
@@ -1,5 +1,5 @@
-#include <poincare/multiplication_implicite.h>
-#include <poincare/multiplication_explicite.h>
+#include <poincare/multiplication_implicit.h>
+#include <poincare/multiplication_explicit.h>
 #include <poincare/layout_helper.h>
 #include <poincare/serialization_helper.h>
 #include <poincare/rational.h>
@@ -9,19 +9,19 @@

 namespace Poincare {

-Layout MultiplicationImpliciteNode::createLayout(Preferences::PrintFloatMode floatDisplayMode, int numberOfSignificantDigits) const {
-  return LayoutHelper::Infix(MultiplicationImplicite(this), floatDisplayMode, numberOfSignificantDigits, "");
+Layout MultiplicationImplicitNode::createLayout(Preferences::PrintFloatMode floatDisplayMode, int numberOfSignificantDigits) const {
+  return LayoutHelper::Infix(MultiplicationImplicit(this), floatDisplayMode, numberOfSignificantDigits, "");
 }

-int MultiplicationImpliciteNode::serialize(char * buffer, int bufferSize, Preferences::PrintFloatMode floatDisplayMode, int numberOfSignificantDigits) const {
+int MultiplicationImplicitNode::serialize(char * buffer, int bufferSize, Preferences::PrintFloatMode floatDisplayMode, int numberOfSignificantDigits) const {
  return SerializationHelper::Infix(this, buffer, bufferSize, floatDisplayMode, numberOfSignificantDigits, "");
 }

-Expression MultiplicationImpliciteNode::shallowReduce(ReductionContext reductionContext) {
-  return MultiplicationImplicite(this).shallowReduce(reductionContext);
+Expression MultiplicationImplicitNode::shallowReduce(ReductionContext reductionContext) {
+  return MultiplicationImplicit(this).shallowReduce(reductionContext);
 }

-bool MultiplicationImpliciteNode::childNeedsSystemParenthesesAtSerialization(const TreeNode * child) const {
+bool MultiplicationImplicitNode::childNeedsSystemParenthesesAtSerialization(const TreeNode * child) const {
  /*  2
   * ---i --> [2/3]i
   *  3
@@ -34,7 +34,7 @@ bool MultiplicationImpliciteNode::childNeedsSystemParenthesesAtSerialization(con

 /* Multiplication */

-Expression MultiplicationImplicite::shallowReduce(ExpressionNode::ReductionContext reductionContext) {
+Expression MultiplicationImplicit::shallowReduce(ExpressionNode::ReductionContext reductionContext) {
  {
    Expression e = Expression::defaultShallowReduce();
    if (e.isUndefined()) {
@@ -42,7 +42,7 @@ Expression MultiplicationImplicite::shallowReduce(ExpressionNode::ReductionConte
    }
  }
  assert(numberOfChildren() == 2);
-  MultiplicationExplicite m = MultiplicationExplicite::Builder();
+  MultiplicationExplicit m = MultiplicationExplicit::Builder();
  for (int i = 0; i < numberOfChildren(); i++) {
    m.addChildAtIndexInPlace(childAtIndex(i), i, i);
  }
--- a/poincare/src/opposite.cpp
+++ b/poincare/src/opposite.cpp
@@ -4,7 +4,7 @@
 #include <poincare/constant.h>
 #include <poincare/horizontal_layout.h>
 #include <poincare/layout_helper.h>
-#include <poincare/multiplication_explicite.h>
+#include <poincare/multiplication_explicit.h>
 #include <poincare/rational.h>
 #include <poincare/serialization_helper.h>

@@ -79,7 +79,7 @@ Expression Opposite::shallowReduce(ExpressionNode::ReductionContext reductionCon
    return result;
  }
  Expression child = result.childAtIndex(0);
-  result = MultiplicationExplicite::Builder(Rational::Builder(-1), child);
+  result = MultiplicationExplicit::Builder(Rational::Builder(-1), child);
  replaceWithInPlace(result);
  return result.shallowReduce(reductionContext);
 }
--- a/poincare/src/parsing/parser.cpp
+++ b/poincare/src/parsing/parser.cpp
@@ -151,7 +151,7 @@ void Parser::parseNumber(Expression & leftHandSide, Token::Type stoppingType) {
  }
  leftHandSide = m_currentToken.expression();
  if (m_nextToken.is(Token::Number)) {
-    m_status = Status::Error; // No implicite multiplication between two numbers
+    m_status = Status::Error; // No implicit multiplication between two numbers
    return;
  }
  isThereImplicitMultiplication();
@@ -196,11 +196,11 @@ void Parser::parseMinus(Expression & leftHandSide, Token::Type stoppingType) {
 void Parser::parseTimes(Expression & leftHandSide, Token::Type stoppingType) {
  Expression rightHandSide;
  if (parseBinaryOperator(leftHandSide, rightHandSide, Token::Times)) {
-    if (leftHandSide.type() == ExpressionNode::Type::MultiplicationExplicite) {
+    if (leftHandSide.type() == ExpressionNode::Type::MultiplicationExplicit) {
      int childrenCount = leftHandSide.numberOfChildren();
-      static_cast<MultiplicationExplicite &>(leftHandSide).addChildAtIndexInPlace(rightHandSide, childrenCount, childrenCount);
+      static_cast<MultiplicationExplicit &>(leftHandSide).addChildAtIndexInPlace(rightHandSide, childrenCount, childrenCount);
    } else {
-      leftHandSide = MultiplicationExplicite::Builder(leftHandSide, rightHandSide);
+      leftHandSide = MultiplicationExplicit::Builder(leftHandSide, rightHandSide);
    }
  }
 }
@@ -215,7 +215,7 @@ void Parser::parseSlash(Expression & leftHandSide, Token::Type stoppingType) {
 void Parser::parseImplicitTimes(Expression & leftHandSide, Token::Type stoppingType) {
  Expression rightHandSide;
  if (parseBinaryOperator(leftHandSide, rightHandSide, Token::Slash)) {
-    leftHandSide = MultiplicationImplicite::Builder(leftHandSide, rightHandSide);
+    leftHandSide = MultiplicationImplicit::Builder(leftHandSide, rightHandSide);
  }
 }

--- a/poincare/src/power.cpp
+++ b/poincare/src/power.cpp
@@ -109,7 +109,7 @@ bool PowerNode::childNeedsUserParentheses(const Expression & child) const {
      return true;
    }
    // ^(2+3,4) --> (2+3)^{4}
-    Type types[] = {Type::Power, Type::Subtraction, Type::Opposite, Type::MultiplicationExplicite, Type::MultiplicationImplicite, Type::Division, Type::Addition};
+    Type types[] = {Type::Power, Type::Subtraction, Type::Opposite, Type::MultiplicationExplicit, Type::MultiplicationImplicit, Type::Division, Type::Addition};
    return child.isOfType(types, 7);
  }
  return false;
@@ -169,7 +169,7 @@ bool PowerNode::childNeedsSystemParenthesesAtSerialization(const TreeNode * chil
  if (static_cast<const ExpressionNode *>(child)->type() == Type::Rational && !static_cast<const RationalNode *>(child)->isInteger()) {
    return true;
  }
-  Type types[] = {Type::Power, Type::Subtraction, Type::Opposite, Type::MultiplicationExplicite, Type::MultiplicationImplicite, Type::Division, Type::Addition};
+  Type types[] = {Type::Power, Type::Subtraction, Type::Opposite, Type::MultiplicationExplicit, Type::MultiplicationImplicit, Type::Division, Type::Addition};
  return static_cast<const ExpressionNode *>(child)->isOfType(types, 7);
 }

@@ -345,7 +345,7 @@ Expression Power::shallowReduce(ExpressionNode::ReductionContext reductionContex
    Expression result = matrixBase.clone();
    // TODO: implement a quick exponentiation
    for (int k = 1; k < exp; k++) {
-      result = MultiplicationExplicite::Builder(result, matrixBase.clone());
+      result = MultiplicationExplicit::Builder(result, matrixBase.clone());
      result = result.shallowReduce(reductionContext);
    }
    assert(!result.isUninitialized());
@@ -515,7 +515,7 @@ Expression Power::shallowReduce(ExpressionNode::ReductionContext reductionContex
      if (base.sign(reductionContext.context()) == ExpressionNode::Sign::Negative) {
        // (-inf)^x --> (-1)^x*inf
        Power p = Power::Builder(Rational::Builder(-1), childAtIndex(1));
-        result = MultiplicationExplicite::Builder(p, result);
+        result = MultiplicationExplicit::Builder(p, result);
        p.shallowReduce(reductionContext);
      }
    }
@@ -553,7 +553,7 @@ Expression Power::shallowReduce(ExpressionNode::ReductionContext reductionContex
      replaceChildAtIndexInPlace(0, m0);
      /* m0 doesn't need to be shallowReduce as
       * makePositiveAnyNegativeNumeralFactor returns a reduced expression */
-      MultiplicationExplicite m1 = MultiplicationExplicite::Builder();
+      MultiplicationExplicit m1 = MultiplicationExplicit::Builder();
      replaceWithInPlace(m1);
      // Multiply m1 by i complex
      Constant i = Constant::Builder(UCodePointMathematicalBoldSmallI);
@@ -567,14 +567,14 @@ Expression Power::shallowReduce(ExpressionNode::ReductionContext reductionContex
  // Step 8: e^(r*i*Pi) with r rational --> cos(pi*r) + i*sin(pi*r)
  if (!letPowerAtRoot && isNthRootOfUnity()) {
    Expression i = index.childAtIndex(index.numberOfChildren()-2);
-    static_cast<MultiplicationExplicite &>(index).removeChildAtIndexInPlace(index.numberOfChildren()-2);
+    static_cast<MultiplicationExplicit &>(index).removeChildAtIndexInPlace(index.numberOfChildren()-2);
    if (reductionContext.angleUnit() == Preferences::AngleUnit::Degree) {
      index.replaceChildAtIndexInPlace(index.numberOfChildren()-1, Rational::Builder(180));
    }
    Expression cos = Cosine::Builder(index);
    index = index.shallowReduce(reductionContext);
    Expression sin = Sine::Builder(index.clone());
-    Expression complexPart = MultiplicationExplicite::Builder(sin, i);
+    Expression complexPart = MultiplicationExplicit::Builder(sin, i);
    sin.shallowReduce(reductionContext);
    Expression a = Addition::Builder(cos, complexPart);
    cos.shallowReduce(reductionContext);
@@ -643,8 +643,8 @@ Expression Power::shallowReduce(ExpressionNode::ReductionContext reductionContex
    }
  }
  // Step 11: (a*b*c*...)^r ?
-  if (!letPowerAtRoot && baseType == ExpressionNode::Type::MultiplicationExplicite) {
-    MultiplicationExplicite multiplicationBase = static_cast<MultiplicationExplicite &>(base);
+  if (!letPowerAtRoot && baseType == ExpressionNode::Type::MultiplicationExplicit) {
+    MultiplicationExplicit multiplicationBase = static_cast<MultiplicationExplicit &>(base);
    // Case 1: (a*b*c*...)^n = a^n*b^n*c^n*... if n integer
    if (indexType == ExpressionNode::Type::Rational && static_cast<Rational &>(index).isInteger()) {
      return simplifyPowerMultiplication(reductionContext);
@@ -674,7 +674,7 @@ Expression Power::shallowReduce(ExpressionNode::ReductionContext reductionContex

        // |a|^r*(sign(a)*b*...)^r
        Power thisRef = *this;
-        MultiplicationExplicite root = MultiplicationExplicite::Builder(p);
+        MultiplicationExplicit root = MultiplicationExplicit::Builder(p);
        replaceWithInPlace(root);
        root.addChildAtIndexInPlace(thisRef, 1, 1);
        p.shallowReduce(reductionContext);
@@ -718,7 +718,7 @@ Expression Power::shallowReduce(ExpressionNode::ReductionContext reductionContex
      additionIndex.removeChildAtIndexInPlace(0); // p2 = a^(c+...)
      // if addition had only 2 children
      additionIndex.squashUnaryHierarchyInPlace();
-      MultiplicationExplicite m = MultiplicationExplicite::Builder(p1);
+      MultiplicationExplicit m = MultiplicationExplicit::Builder(p1);
      replaceWithInPlace(m);
      m.addChildAtIndexInPlace(thisRef, 1, 1);
      p1.simplifyRationalRationalPower(reductionContext);
@@ -762,7 +762,7 @@ Expression Power::shallowReduce(ExpressionNode::ReductionContext reductionContex
        // We need a 'double' distribution and newA will hold the new expanded form
        Expression newA = Addition::Builder();
        for (int j = 0; j < a.numberOfChildren(); j++) {
-          Expression m = MultiplicationExplicite::Builder(result.clone(), a.childAtIndex(j).clone()).distributeOnOperandAtIndex(0, reductionContext);
+          Expression m = MultiplicationExplicit::Builder(result.clone(), a.childAtIndex(j).clone()).distributeOnOperandAtIndex(0, reductionContext);
          if (newA.type() == ExpressionNode::Type::Addition) {
            static_cast<Addition &>(newA).addChildAtIndexInPlace(m, newA.numberOfChildren(), newA.numberOfChildren());
          } else {
@@ -774,7 +774,7 @@ Expression Power::shallowReduce(ExpressionNode::ReductionContext reductionContex
        result = newA;
      } else {
        // Just distribute result on a
-        MultiplicationExplicite m = MultiplicationExplicite::Builder(a.clone(), result.clone());
+        MultiplicationExplicit m = MultiplicationExplicit::Builder(a.clone(), result.clone());
        Expression distributedM = m.distributeOnOperandAtIndex(0, reductionContext);
        result.replaceWithInPlace(distributedM);
        result = distributedM;
@@ -809,7 +809,7 @@ Expression Power::shallowReduce(ExpressionNode::ReductionContext reductionContex
      Power * p0 = new Power::Builder(x0->clone(), new Rational::Builder(i), false);
      Power * p1 = new Power::Builder(x1->clone(), new Rational::Builder(clippedN-i), false);
      const Expression * operands[3] = {r, p0, p1};
-      MultiplicationExplicite * m = new MultiplicationExplicite::Builder(operands, 3, false);
+      MultiplicationExplicit * m = new MultiplicationExplicit::Builder(operands, 3, false);
      p0->shallowReduce(reductionContext);
      p1->shallowReduce(reductionContext);
      a->addOperand(m);
@@ -890,7 +890,7 @@ Expression Power::denominator(Context * context, Preferences::ComplexFormat comp
 Expression Power::simplifyPowerPower(ExpressionNode::ReductionContext reductionContext) {
  // this is p^e = (a^b)^e, we want a^(b*e)
  Expression p = childAtIndex(0);
-  MultiplicationExplicite m = MultiplicationExplicite::Builder(p.childAtIndex(1), childAtIndex(1));
+  MultiplicationExplicit m = MultiplicationExplicit::Builder(p.childAtIndex(1), childAtIndex(1));
  replaceChildAtIndexInPlace(0, p.childAtIndex(0));
  replaceChildAtIndexInPlace(1, m);
  m.shallowReduce(reductionContext);
@@ -932,7 +932,7 @@ Expression Power::simplifyRationalRationalPower(ExpressionNode::ReductionContext
    n = CreateSimplifiedIntegerRationalPower(a.signedIntegerNumerator(), b, false, reductionContext);
    d = CreateSimplifiedIntegerRationalPower(a.integerDenominator(), b, true, reductionContext);
  }
-  MultiplicationExplicite m = MultiplicationExplicite::Builder(n, d);
+  MultiplicationExplicit m = MultiplicationExplicit::Builder(n, d);
  replaceWithInPlace(m);
  return m.shallowReduce(reductionContext);
 }
@@ -975,7 +975,7 @@ Expression Power::CreateSimplifiedIntegerRationalPower(Integer i, Rational r, bo
  }
  Integer one(1);
  Rational r3 = isDenominator ? Rational::Builder(one, r1) : Rational::Builder(r1);
-  MultiplicationExplicite m = MultiplicationExplicite::Builder();
+  MultiplicationExplicit m = MultiplicationExplicit::Builder();
  m.addChildAtIndexInPlace(r3, 0, 0);
  if (!r2.isOne()) {
    m.addChildAtIndexInPlace(p, 1, 1);
@@ -1028,9 +1028,9 @@ Expression Power::removeSquareRootsFromDenominator(ExpressionNode::ReductionCont
      Power sqrt = Power::Builder(Rational::Builder(pq), Rational::Builder(1, 2));
      Integer one(1);
      if (castedChild1.isHalf()) {
-        result = MultiplicationExplicite::Builder(Rational::Builder(one, q), sqrt);
+        result = MultiplicationExplicit::Builder(Rational::Builder(one, q), sqrt);
      } else {
-        result = MultiplicationExplicite::Builder(Rational::Builder(one, p), sqrt); // We use here the assertion that p != 0
+        result = MultiplicationExplicit::Builder(Rational::Builder(one, p), sqrt); // We use here the assertion that p != 0
      }
      sqrt.shallowReduce(reductionContext);
    }
@@ -1085,11 +1085,11 @@ Expression Power::removeSquareRootsFromDenominator(ExpressionNode::ReductionCont
    Integer factor1 = Integer::Multiplication(
        Integer::Multiplication(n1, d1),
        Integer::Multiplication(Integer::Power(d2, Integer(2)), q2));
-    Multiplication m1 = MultiplicationExplicite::Builder(Rational::Builder(factor1), sqrt1);
+    Multiplication m1 = MultiplicationExplicit::Builder(Rational::Builder(factor1), sqrt1);
    Integer factor2 = Integer::Multiplication(
        Integer::Multiplication(n2, d2),
        Integer::Multiplication(Integer::Power(d1, Integer(2)), q1));
-    Multiplication m2 = MultiplicationExplicite::Builder(Rational::Builder(factor2), sqrt2);
+    Multiplication m2 = MultiplicationExplicit::Builder(Rational::Builder(factor2), sqrt2);
    Expression numerator;
    if (denominator.isNegative()) {
      numerator = Subtraction::Builder(m2, m1);
@@ -1102,7 +1102,7 @@ Expression Power::removeSquareRootsFromDenominator(ExpressionNode::ReductionCont
    }
    numerator = numerator.deepReduce(reductionContext);
    Integer one(1);
-    result = MultiplicationExplicite::Builder(numerator, Rational::Builder(one, denominator));
+    result = MultiplicationExplicit::Builder(numerator, Rational::Builder(one, denominator));
  }

  if (!result.isUninitialized()) {
@@ -1147,7 +1147,7 @@ bool Power::isNthRootOfUnity() const {
  if (childAtIndex(0).type() != ExpressionNode::Type::Constant || !childAtIndex(0).convert<Constant>().isExponential()) {
    return false;
  }
-  if (childAtIndex(1).type() != ExpressionNode::Type::MultiplicationExplicite) {
+  if (childAtIndex(1).type() != ExpressionNode::Type::MultiplicationExplicit) {
    return false;
  }
  if (childAtIndex(1).numberOfChildren() < 2 || childAtIndex(1).numberOfChildren() > 3) {
@@ -1190,7 +1190,7 @@ Expression Power::CreateComplexExponent(const Expression & r, ExpressionNode::Re
  const Constant exp = Constant::Builder(UCodePointScriptSmallE);
  Constant iComplex = Constant::Builder(UCodePointMathematicalBoldSmallI);
  const Constant pi = Constant::Builder(UCodePointGreekSmallLetterPi);
-  MultiplicationExplicite mExp = MultiplicationExplicite::Builder(iComplex, pi, r.clone());
+  MultiplicationExplicit mExp = MultiplicationExplicit::Builder(iComplex, pi, r.clone());
  iComplex.shallowReduce(reductionContext);
  Power p = Power::Builder(exp, mExp);
  mExp.shallowReduce(reductionContext);
@@ -1198,10 +1198,10 @@ Expression Power::CreateComplexExponent(const Expression & r, ExpressionNode::Re
 #if 0
  const Constant iComplex = Constant::Builder(UCodePointMathematicalBoldSmallI);
  const Constant pi = Constant::Builder(UCodePointGreekSmallLetterPi);
-  Expression op = MultiplicationExplicite::Builder(pi, r).shallowReduce(context, complexFormat, angleUnit, false);
+  Expression op = MultiplicationExplicit::Builder(pi, r).shallowReduce(context, complexFormat, angleUnit, false);
  Cosine cos = Cosine(op).shallowReduce(context, complexFormat, angleUnit, false);;
  Sine sin = Sine(op).shallowReduce(context, complexFormat, angleUnit, false);
-  Expression m = MultiplicationExplicite::Builder(iComplex, sin);
+  Expression m = MultiplicationExplicit::Builder(iComplex, sin);
  Expression a = Addition::Builder(cos, m);
  const Expression * multExpOperands[3] = {pi, r->clone()};
 #endif
@@ -1218,7 +1218,7 @@ bool Power::TermIsARationalSquareRootOrRational(const Expression & e) {
  {
    return true;
  }
-  if (e.type() == ExpressionNode::Type::MultiplicationExplicite
+  if (e.type() == ExpressionNode::Type::MultiplicationExplicit
      && e.numberOfChildren() == 2
      && e.childAtIndex(0).type() == ExpressionNode::Type::Rational
      && e.childAtIndex(1).type() == ExpressionNode::Type::Power
@@ -1239,7 +1239,7 @@ const Rational Power::RadicandInExpression(const Expression & e) {
    assert(e.childAtIndex(0).type() == ExpressionNode::Type::Rational);
    return e.childAtIndex(0).convert<Rational>();
  } else {
-    assert(e.type() == ExpressionNode::Type::MultiplicationExplicite);
+    assert(e.type() == ExpressionNode::Type::MultiplicationExplicit);
    assert(e.childAtIndex(1).type() == ExpressionNode::Type::Power);
    assert(e.childAtIndex(1).childAtIndex(0).type() == ExpressionNode::Type::Rational);
    return e.childAtIndex(1).childAtIndex(0).convert<Rational>();
@@ -1252,7 +1252,7 @@ const Rational Power::RationalFactorInExpression(const Expression & e) {
  } else if (e.type() == ExpressionNode::Type::Power) {
    return Rational::Builder(1);
  } else {
-    assert(e.type() == ExpressionNode::Type::MultiplicationExplicite);
+    assert(e.type() == ExpressionNode::Type::MultiplicationExplicit);
    assert(e.childAtIndex(0).type() == ExpressionNode::Type::Rational);
    return e.childAtIndex(0).convert<Rational>();
  }
--- a/poincare/src/prediction_interval.cpp
+++ b/poincare/src/prediction_interval.cpp
@@ -1,7 +1,7 @@
 #include <poincare/prediction_interval.h>
 #include <poincare/matrix.h>
 #include <poincare/addition.h>
-#include <poincare/multiplication_explicite.h>
+#include <poincare/multiplication_explicit.h>
 #include <poincare/power.h>
 #include <poincare/undefined.h>
 #include <poincare/division.h>
@@ -89,9 +89,9 @@ Expression PredictionInterval::shallowReduce(ExpressionNode::ReductionContext re
  }
  // Compute sqr = sqrt(r0*(1-r0)/r1)
  Expression sqr = Power::Builder(Division::Builder(numerator, r1), Rational::Builder(1, 2));
-  Expression m = MultiplicationExplicite::Builder(Rational::Builder(196, 100), sqr);
+  Expression m = MultiplicationExplicit::Builder(Rational::Builder(196, 100), sqr);
  Matrix matrix = Matrix::Builder();
-  matrix.addChildAtIndexInPlace(Addition::Builder(r0.clone(), MultiplicationExplicite::Builder(Rational::Builder(-1), m.clone())), 0, 0);
+  matrix.addChildAtIndexInPlace(Addition::Builder(r0.clone(), MultiplicationExplicit::Builder(Rational::Builder(-1), m.clone())), 0, 0);
  matrix.addChildAtIndexInPlace(Addition::Builder(r0.clone(), m), 1, 1);
  matrix.setDimensions(1, 2);
  replaceWithInPlace(matrix);
--- a/poincare/src/sign_function.cpp
+++ b/poincare/src/sign_function.cpp
@@ -84,7 +84,7 @@ Expression SignFunction::shallowReduce(ExpressionNode::ReductionContext reductio
          return *this;
        }
        Expression sign = *this;
-        Multiplication m = MultiplicationExplicite::Builder(Rational::Builder(-1));
+        Multiplication m = MultiplicationExplicit::Builder(Rational::Builder(-1));
        replaceWithInPlace(m);
        m.addChildAtIndexInPlace(sign, 1, 1); // sign does not need to be shallowReduced because -x = NAN --> x = NAN
        return m; // m does not need to be shallowReduced, -1*sign cannot be reduced
--- a/poincare/src/subtraction.cpp
+++ b/poincare/src/subtraction.cpp
@@ -2,7 +2,7 @@
 #include <poincare/layout_helper.h>
 #include <poincare/serialization_helper.h>
 #include <poincare/addition.h>
-#include <poincare/multiplication_explicite.h>
+#include <poincare/multiplication_explicit.h>
 #include <poincare/opposite.h>
 #include <poincare/rational.h>
 #include <assert.h>
@@ -54,7 +54,7 @@ Expression Subtraction::shallowReduce(ExpressionNode::ReductionContext reduction
  if (e.isUndefined()) {
    return e;
  }
-  Expression m = MultiplicationExplicite::Builder(Rational::Builder(-1), childAtIndex(1));
+  Expression m = MultiplicationExplicit::Builder(Rational::Builder(-1), childAtIndex(1));
  Addition a = Addition::Builder(childAtIndex(0), m);
  m = m.shallowReduce(reductionContext);
  replaceWithInPlace(a);
--- a/poincare/src/tree_handle.cpp
+++ b/poincare/src/tree_handle.cpp
@@ -314,8 +314,8 @@ template MatrixIdentity TreeHandle::FixedArityBuilder<MatrixIdentity, MatrixIden
 template MatrixInverse TreeHandle::FixedArityBuilder<MatrixInverse, MatrixInverseNode>(TreeHandle*, size_t);
 template MatrixTrace TreeHandle::FixedArityBuilder<MatrixTrace, MatrixTraceNode>(TreeHandle*, size_t);
 template MatrixTranspose TreeHandle::FixedArityBuilder<MatrixTranspose, MatrixTransposeNode>(TreeHandle*, size_t);
-template MultiplicationExplicite TreeHandle::NAryBuilder<MultiplicationExplicite, MultiplicationExpliciteNode>(TreeHandle*, size_t);
-template MultiplicationImplicite TreeHandle::NAryBuilder<MultiplicationImplicite, MultiplicationImpliciteNode>(TreeHandle*, size_t);
+template MultiplicationExplicit TreeHandle::NAryBuilder<MultiplicationExplicit, MultiplicationExplicitNode>(TreeHandle*, size_t);
+template MultiplicationImplicit TreeHandle::NAryBuilder<MultiplicationImplicit, MultiplicationImplicitNode>(TreeHandle*, size_t);
 template NaperianLogarithm TreeHandle::FixedArityBuilder<NaperianLogarithm, NaperianLogarithmNode>(TreeHandle*, size_t);
 template NthRoot TreeHandle::FixedArityBuilder<NthRoot, NthRootNode>(TreeHandle*, size_t);
 template Opposite TreeHandle::FixedArityBuilder<Opposite, OppositeNode>(TreeHandle*, size_t);
--- a/poincare/src/trigonometry.cpp
+++ b/poincare/src/trigonometry.cpp
@@ -4,7 +4,7 @@
 #include <poincare/decimal.h>
 #include <poincare/derivative.h>
 #include <poincare/float.h>
-#include <poincare/multiplication_explicite.h>
+#include <poincare/multiplication_explicit.h>
 #include <poincare/power.h>
 #include <poincare/preferences.h>
 #include <poincare/rational.h>
@@ -82,7 +82,7 @@ bool Trigonometry::AreInverseFunctions(const Expression & directFunction, const
 bool Trigonometry::ExpressionIsEquivalentToTangent(const Expression & e) {
  // We look for (cos^-1 * sin)
  assert(ExpressionNode::Type::Power < ExpressionNode::Type::Sine);
-  if (e.type() == ExpressionNode::Type::MultiplicationExplicite
+  if (e.type() == ExpressionNode::Type::MultiplicationExplicit
      && e.childAtIndex(1).type() == ExpressionNode::Type::Sine
      && e.childAtIndex(0).type() == ExpressionNode::Type::Power
      && e.childAtIndex(0).childAtIndex(0).type() == ExpressionNode::Type::Cosine
@@ -125,7 +125,7 @@ Expression Trigonometry::shallowReduceDirectFunction(Expression & e, ExpressionN
      Power::Builder(
        Addition::Builder(
          Rational::Builder(1),
-          MultiplicationExplicite::Builder(
+          MultiplicationExplicit::Builder(
            Rational::Builder(-1),
            Power::Builder(e.childAtIndex(0).childAtIndex(0), Rational::Builder(2))
          )
@@ -166,7 +166,7 @@ Expression Trigonometry::shallowReduceDirectFunction(Expression & e, ExpressionN
    // reduce 1+*x^2
    res.childAtIndex(0).shallowReduce(reductionContext);
    if (e.type() == ExpressionNode::Type::Sine) {
-      res = MultiplicationExplicite::Builder(x, res);
+      res = MultiplicationExplicit::Builder(x, res);
      // reduce (1+x^2)^(-1/2)
      res.childAtIndex(0).shallowReduce(reductionContext);
    }
@@ -184,7 +184,7 @@ Expression Trigonometry::shallowReduceDirectFunction(Expression & e, ExpressionN
      return e.shallowReduce(reductionContext);
    } else {
      // sin(-a) = -sin(a) or tan(-a) = -tan(a)
-      MultiplicationExplicite m = MultiplicationExplicite::Builder(Rational::Builder(-1));
+      MultiplicationExplicit m = MultiplicationExplicit::Builder(Rational::Builder(-1));
      e.replaceWithInPlace(m);
      m.addChildAtIndexInPlace(e, 1, 1);
      e.shallowReduce(reductionContext);
@@ -197,7 +197,7 @@ Expression Trigonometry::shallowReduceDirectFunction(Expression & e, ExpressionN
   * multiply the cos/sin/tan by -1 if needed.
   * We know thanks to Step 3 that p/q > 0. */
  if ((reductionContext.angleUnit() == Preferences::AngleUnit::Radian
-        && e.childAtIndex(0).type() == ExpressionNode::Type::MultiplicationExplicite
+        && e.childAtIndex(0).type() == ExpressionNode::Type::MultiplicationExplicit
        && e.childAtIndex(0).numberOfChildren() == 2
        && e.childAtIndex(0).childAtIndex(1).type() == ExpressionNode::Type::Constant
        && e.childAtIndex(0).childAtIndex(1).convert<Constant>().isPi()
@@ -250,7 +250,7 @@ Expression Trigonometry::shallowReduceDirectFunction(Expression & e, ExpressionN
        unaryCoefficient *= -1;
      }
      Expression simplifiedCosine = e.shallowReduce(reductionContext); // recursive
-      MultiplicationExplicite m = MultiplicationExplicite::Builder(Rational::Builder(unaryCoefficient));
+      MultiplicationExplicit m = MultiplicationExplicit::Builder(Rational::Builder(unaryCoefficient));
      simplifiedCosine.replaceWithInPlace(m);
      m.addChildAtIndexInPlace(simplifiedCosine, 1, 1);
      return m.shallowReduce(reductionContext);
@@ -303,12 +303,12 @@ Expression Trigonometry::shallowReduceInverseFunction(Expression & e,  Expressio
     *   reduced to undef) */
    if (reductionContext.target() == ExpressionNode::ReductionTarget::User || x.isNumber()) {
      Expression sign = SignFunction::Builder(x.clone());
-      MultiplicationExplicite m0 = MultiplicationExplicite::Builder(Rational::Builder(1,2), sign, Constant::Builder(UCodePointGreekSmallLetterPi));
+      MultiplicationExplicit m0 = MultiplicationExplicit::Builder(Rational::Builder(1,2), sign, Constant::Builder(UCodePointGreekSmallLetterPi));
      sign.shallowReduce(reductionContext);
      e.replaceChildAtIndexInPlace(0, x);
      Addition a = Addition::Builder(m0);
      e.replaceWithInPlace(a);
-      MultiplicationExplicite m1 = MultiplicationExplicite::Builder(Rational::Builder(-1), e);
+      MultiplicationExplicit m1 = MultiplicationExplicit::Builder(Rational::Builder(-1), e);
      e.shallowReduce(reductionContext);
      a.addChildAtIndexInPlace(m1, 1, 1);
      return a.shallowReduce(reductionContext);
@@ -348,7 +348,7 @@ Expression Trigonometry::shallowReduceInverseFunction(Expression & e,  Expressio
        return s.shallowReduce(reductionContext);
      } else {
        // asin(-x) = -asin(x) or atan(-x) = -atan(x)
-        MultiplicationExplicite m = MultiplicationExplicite::Builder(Rational::Builder(-1));
+        MultiplicationExplicit m = MultiplicationExplicit::Builder(Rational::Builder(-1));
        e.replaceWithInPlace(m);
        m.addChildAtIndexInPlace(e, 1, 1);
        e.shallowReduce(reductionContext);
--- a/poincare/src/trigonometry_cheat_table.cpp
+++ b/poincare/src/trigonometry_cheat_table.cpp
@@ -41,11 +41,11 @@ Expression TrigonometryCheatTable::simplify(const Expression e, ExpressionNode::
        && e.type() != ExpressionNode::Type::Rational)
      || (inputType == Type::AngleInRadians
        && e.type() != ExpressionNode::Type::Rational
-        && e.type() != ExpressionNode::Type::MultiplicationExplicite
+        && e.type() != ExpressionNode::Type::MultiplicationExplicit
        && e.type() != ExpressionNode::Type::Constant)
      || (inputType > Type::AngleInRadians
        && e.type() != ExpressionNode::Type::Rational
-        && e.type() != ExpressionNode::Type::MultiplicationExplicite
+        && e.type() != ExpressionNode::Type::MultiplicationExplicit
        && e.type() != ExpressionNode::Type::Power
        && e.type() != ExpressionNode::Type::Addition))
  {
--- a/poincare/test/expression_order.cpp
+++ b/poincare/test/expression_order.cpp
@@ -35,8 +35,8 @@ QUIZ_CASE(poincare_expression_order_rational) {

 void assert_multiplication_or_addition_is_ordered_as(Expression e1, Expression e2) {
  Shared::GlobalContext globalContext;
-  if (e1.type() == ExpressionNode::Type::MultiplicationExplicite) {
-    static_cast<MultiplicationExplicite&>(e1).sortChildrenInPlace(
+  if (e1.type() == ExpressionNode::Type::MultiplicationExplicit) {
+    static_cast<MultiplicationExplicit&>(e1).sortChildrenInPlace(
        [](const ExpressionNode * e1, const ExpressionNode * e2, bool canBeInterrupted) { return ExpressionNode::SimplificationOrder(e1, e2, true, canBeInterrupted); },
        &globalContext,
        true);
@@ -53,13 +53,13 @@ void assert_multiplication_or_addition_is_ordered_as(Expression e1, Expression e
 QUIZ_CASE(poincare_expression_order_addition_multiplication) {
  {
    // 2 * 5 -> 2 * 5
-    Expression e1 = MultiplicationExplicite::Builder(Rational::Builder(2), Rational::Builder(5));
+    Expression e1 = MultiplicationExplicit::Builder(Rational::Builder(2), Rational::Builder(5));
    assert_multiplication_or_addition_is_ordered_as(e1, e1);
  }
  {
    // 5 * 2 -> 2 * 5
-    Expression e1 = MultiplicationExplicite::Builder(Rational::Builder(5), Rational::Builder(2));
-    Expression e2 = MultiplicationExplicite::Builder(Rational::Builder(2), Rational::Builder(5));
+    Expression e1 = MultiplicationExplicit::Builder(Rational::Builder(5), Rational::Builder(2));
+    Expression e2 = MultiplicationExplicit::Builder(Rational::Builder(2), Rational::Builder(5));
    assert_multiplication_or_addition_is_ordered_as(e1, e2);
  }
  {
@@ -85,8 +85,8 @@ QUIZ_CASE(poincare_expression_order_addition_multiplication) {
  }
  {
    // root(3) $ 2 -> 2 * root(3)
-    Expression e1 = MultiplicationExplicite::Builder(SquareRoot::Builder(Rational::Builder(3)), Rational::Builder(2));
-    Expression e2 = MultiplicationExplicite::Builder(Rational::Builder(2), SquareRoot::Builder(Rational::Builder(3)));
+    Expression e1 = MultiplicationExplicit::Builder(SquareRoot::Builder(Rational::Builder(3)), Rational::Builder(2));
+    Expression e2 = MultiplicationExplicit::Builder(Rational::Builder(2), SquareRoot::Builder(Rational::Builder(3)));
    assert_multiplication_or_addition_is_ordered_as(e1, e2);
  }
  {
@@ -110,16 +110,16 @@ QUIZ_CASE(poincare_expression_order_addition_multiplication) {
  }
  {
    // 3*x^2 + 2*x^3 -> 2*x^3 + 3*x^2
-    Expression child1 = MultiplicationExplicite::Builder(Rational::Builder(2), Power::Builder(Symbol::Builder('x'), Rational::Builder(3)));
-    Expression child2 = MultiplicationExplicite::Builder(Rational::Builder(3), Power::Builder(Symbol::Builder('x'), Rational::Builder(2)));
+    Expression child1 = MultiplicationExplicit::Builder(Rational::Builder(2), Power::Builder(Symbol::Builder('x'), Rational::Builder(3)));
+    Expression child2 = MultiplicationExplicit::Builder(Rational::Builder(3), Power::Builder(Symbol::Builder('x'), Rational::Builder(2)));
    Expression e1 = Addition::Builder(child2.clone(), child1.clone());
    Expression e2 = Addition::Builder(child1, child2);
    assert_multiplication_or_addition_is_ordered_as(e1, e2);
  }
  {
    // 2*x + 3*x -> 3*x + 2*x
-    Expression child1 = MultiplicationExplicite::Builder(Rational::Builder(3), Symbol::Builder('x'));
-    Expression child2 = MultiplicationExplicite::Builder(Rational::Builder(2), Symbol::Builder('x'));
+    Expression child1 = MultiplicationExplicit::Builder(Rational::Builder(3), Symbol::Builder('x'));
+    Expression child2 = MultiplicationExplicit::Builder(Rational::Builder(2), Symbol::Builder('x'));
    Expression e1 = Addition::Builder(child2.clone(), child1.clone());
    Expression e2 = Addition::Builder(child1, child2);
    assert_multiplication_or_addition_is_ordered_as(e1, e2);
@@ -128,16 +128,16 @@ QUIZ_CASE(poincare_expression_order_addition_multiplication) {
    // pi^b * pi^a -> pi^a * pi^b
    Expression child1 = Power::Builder(Constant::Builder(UCodePointGreekSmallLetterPi), Symbol::Builder('a'));
    Expression child2 = Power::Builder(Constant::Builder(UCodePointGreekSmallLetterPi), Symbol::Builder('b'));
-    Expression e1 = MultiplicationExplicite::Builder(child2.clone(), child1.clone());
-    Expression e2 = MultiplicationExplicite::Builder(child1, child2);
+    Expression e1 = MultiplicationExplicit::Builder(child2.clone(), child1.clone());
+    Expression e2 = MultiplicationExplicit::Builder(child1, child2);
    assert_multiplication_or_addition_is_ordered_as(e1, e2);
  }
  {
    // pi^3 * pi^2 -> pi^2 * pi^3
    Expression child1 = Power::Builder(Constant::Builder(UCodePointGreekSmallLetterPi), Rational::Builder(2));
    Expression child2 = Power::Builder(Constant::Builder(UCodePointGreekSmallLetterPi), Rational::Builder(3));
-    Expression e1 = MultiplicationExplicite::Builder(child2.clone(), child1.clone());
-    Expression e2 = MultiplicationExplicite::Builder(child1, child2);
+    Expression e1 = MultiplicationExplicit::Builder(child2.clone(), child1.clone());
+    Expression e2 = MultiplicationExplicit::Builder(child1, child2);
    assert_multiplication_or_addition_is_ordered_as(e1, e2);
  }
  {
@@ -146,8 +146,8 @@ QUIZ_CASE(poincare_expression_order_addition_multiplication) {
    Expression child2 = Rational::Builder(2);
    Expression childMatrix = Matrix::Builder();
    static_cast<Matrix &>(childMatrix).addChildAtIndexInPlace(Rational::Builder(3), 0, 0);
-    Expression e1 = MultiplicationExplicite::Builder(child2.clone(), childMatrix.clone(), child1.clone());
-    Expression e2 = MultiplicationExplicite::Builder(child1.clone(), child2.clone(), childMatrix.clone());
+    Expression e1 = MultiplicationExplicit::Builder(child2.clone(), childMatrix.clone(), child1.clone());
+    Expression e2 = MultiplicationExplicit::Builder(child1.clone(), child2.clone(), childMatrix.clone());
    assert_multiplication_or_addition_is_ordered_as(e1, e2);
  }

@@ -173,8 +173,8 @@ QUIZ_CASE(poincare_expression_order_addition_multiplication) {
      childMatrix1.clone(),
      childMatrix2.clone()
    };
-    Expression e1 = MultiplicationExplicite::Builder(children, numberOfChildren);
-    Expression e2 = MultiplicationExplicite::Builder(childrenSorted, numberOfChildren);
+    Expression e1 = MultiplicationExplicit::Builder(children, numberOfChildren);
+    Expression e2 = MultiplicationExplicit::Builder(childrenSorted, numberOfChildren);
    assert_multiplication_or_addition_is_ordered_as(e1, e2);
  }

--- a/poincare/test/expression_properties.cpp
+++ b/poincare/test/expression_properties.cpp
@@ -108,17 +108,17 @@ QUIZ_CASE(poincare_properties_characteristic_range) {
  // cos(-x), radian
  assert_reduced_expression_has_characteristic_range(Cosine::Builder(Opposite::Builder(Symbol::Builder(UCodePointUnknownX))), 2.0f*M_PI, Preferences::AngleUnit::Radian);
  // sin(9x+10), degree
-  assert_reduced_expression_has_characteristic_range(Sine::Builder(Addition::Builder(MultiplicationExplicite::Builder(Rational::Builder(9),Symbol::Builder(UCodePointUnknownX)),Rational::Builder(10))), 40.0f);
+  assert_reduced_expression_has_characteristic_range(Sine::Builder(Addition::Builder(MultiplicationExplicit::Builder(Rational::Builder(9),Symbol::Builder(UCodePointUnknownX)),Rational::Builder(10))), 40.0f);
  // sin(9x+10)+cos(x/2), degree
-  assert_reduced_expression_has_characteristic_range(Addition::Builder(Sine::Builder(Addition::Builder(MultiplicationExplicite::Builder(Rational::Builder(9),Symbol::Builder(UCodePointUnknownX)),Rational::Builder(10))),Cosine::Builder(Division::Builder(Symbol::Builder(UCodePointUnknownX),Rational::Builder(2)))), 720.0f);
+  assert_reduced_expression_has_characteristic_range(Addition::Builder(Sine::Builder(Addition::Builder(MultiplicationExplicit::Builder(Rational::Builder(9),Symbol::Builder(UCodePointUnknownX)),Rational::Builder(10))),Cosine::Builder(Division::Builder(Symbol::Builder(UCodePointUnknownX),Rational::Builder(2)))), 720.0f);
  // sin(9x+10)+cos(x/2), radian
-  assert_reduced_expression_has_characteristic_range(Addition::Builder(Sine::Builder(Addition::Builder(MultiplicationExplicite::Builder(Rational::Builder(9),Symbol::Builder(UCodePointUnknownX)),Rational::Builder(10))),Cosine::Builder(Division::Builder(Symbol::Builder(UCodePointUnknownX),Rational::Builder(2)))), 4.0f*M_PI, Preferences::AngleUnit::Radian);
+  assert_reduced_expression_has_characteristic_range(Addition::Builder(Sine::Builder(Addition::Builder(MultiplicationExplicit::Builder(Rational::Builder(9),Symbol::Builder(UCodePointUnknownX)),Rational::Builder(10))),Cosine::Builder(Division::Builder(Symbol::Builder(UCodePointUnknownX),Rational::Builder(2)))), 4.0f*M_PI, Preferences::AngleUnit::Radian);
  // x, degree
  assert_reduced_expression_has_characteristic_range(Symbol::Builder(UCodePointUnknownX), NAN);
  // cos(3)+2, degree
  assert_reduced_expression_has_characteristic_range(Addition::Builder(Cosine::Builder(Rational::Builder(3)),Rational::Builder(2)), 0.0f);
  // log(cos(40x), degree
-  assert_reduced_expression_has_characteristic_range(CommonLogarithm::Builder(Cosine::Builder(MultiplicationExplicite::Builder(Rational::Builder(40),Symbol::Builder(UCodePointUnknownX)))), 9.0f);
+  assert_reduced_expression_has_characteristic_range(CommonLogarithm::Builder(Cosine::Builder(MultiplicationExplicit::Builder(Rational::Builder(40),Symbol::Builder(UCodePointUnknownX)))), 9.0f);
  // cos(cos(x)), degree
  assert_reduced_expression_has_characteristic_range(Cosine::Builder((Expression)Cosine::Builder(Symbol::Builder(UCodePointUnknownX))), 360.0f);
  // f(x) with f : x --> cos(x), degree
--- a/poincare/test/layout_to_expression.cpp
+++ b/poincare/test/layout_to_expression.cpp
@@ -285,9 +285,9 @@ QUIZ_CASE(poincare_layout_to_expression_parsable) {
          CodePointLayout::Builder('+'),
          CodePointLayout::Builder('5'))),
      CodePointLayout::Builder('3'));
-  e = MultiplicationImplicite::Builder(
+  e = MultiplicationImplicit::Builder(
      Rational::Builder(5),
-      MultiplicationImplicite::Builder(
+      MultiplicationImplicit::Builder(
        Division::Builder(
          Rational::Builder(6),
          Addition::Builder(
@@ -348,6 +348,6 @@ QUIZ_CASE(poincare_layout_to_expression_parsable) {
      VerticalOffsetLayout::Builder(
        CodePointLayout::Builder('3'),
        VerticalOffsetLayoutNode::Position::Superscript));
-  e = MultiplicationImplicite::Builder(Rational::Builder(2),Power::Builder(Constant::Builder(UCodePointScriptSmallE), Rational::Builder(3)));
+  e = MultiplicationImplicit::Builder(Rational::Builder(2),Power::Builder(Constant::Builder(UCodePointScriptSmallE), Rational::Builder(3)));
  assert_parsed_layout_is(l, e);
 }
--- a/poincare/test/parsing.cpp
+++ b/poincare/test/parsing.cpp
@@ -157,16 +157,16 @@ QUIZ_CASE(poincare_parsing_parse) {
  assert_parsed_expression_is("(1+2)", Parenthesis::Builder(Addition::Builder(Rational::Builder(1),Rational::Builder(2))));
  assert_parsed_expression_is("1+2+3", Addition::Builder(Addition::Builder(Rational::Builder(1),Rational::Builder(2)),Rational::Builder(3)));
  assert_parsed_expression_is("1+2+(3+4)", Addition::Builder(Addition::Builder(Rational::Builder(1),Rational::Builder(2)),Parenthesis::Builder(Addition::Builder(Rational::Builder(3),Rational::Builder(4)))));
-  assert_parsed_expression_is("1×2", MultiplicationExplicite::Builder(Rational::Builder(1),Rational::Builder(2)));
-  assert_parsed_expression_is("1×2×3", MultiplicationExplicite::Builder(MultiplicationExplicite::Builder(Rational::Builder(1),Rational::Builder(2)),Rational::Builder(3)));
-  assert_parsed_expression_is("1+2×3", Addition::Builder(Rational::Builder(1), MultiplicationExplicite::Builder(Rational::Builder(2), Rational::Builder(3))));
+  assert_parsed_expression_is("1×2", MultiplicationExplicit::Builder(Rational::Builder(1),Rational::Builder(2)));
+  assert_parsed_expression_is("1×2×3", MultiplicationExplicit::Builder(MultiplicationExplicit::Builder(Rational::Builder(1),Rational::Builder(2)),Rational::Builder(3)));
+  assert_parsed_expression_is("1+2×3", Addition::Builder(Rational::Builder(1), MultiplicationExplicit::Builder(Rational::Builder(2), Rational::Builder(3))));
  assert_parsed_expression_is("1/2", Division::Builder(Rational::Builder(1),Rational::Builder(2)));
  assert_parsed_expression_is("(1/2)", Parenthesis::Builder(Division::Builder(Rational::Builder(1),Rational::Builder(2))));
  assert_parsed_expression_is("1/2/3", Division::Builder(Division::Builder(Rational::Builder(1),Rational::Builder(2)),Rational::Builder(3)));
-  assert_parsed_expression_is("1/2×3", MultiplicationExplicite::Builder(Division::Builder(Rational::Builder(1),Rational::Builder(2)),Rational::Builder(3)));
-  assert_parsed_expression_is("(1/2×3)", Parenthesis::Builder(MultiplicationExplicite::Builder(Division::Builder(Rational::Builder(1),Rational::Builder(2)),Rational::Builder(3))));
-  assert_parsed_expression_is("1×2/3", MultiplicationExplicite::Builder(Rational::Builder(1),Division::Builder(Rational::Builder(2),Rational::Builder(3))));
-  assert_parsed_expression_is("(1×2/3)", Parenthesis::Builder(MultiplicationExplicite::Builder(Rational::Builder(1),Division::Builder(Rational::Builder(2),Rational::Builder(3)))));
+  assert_parsed_expression_is("1/2×3", MultiplicationExplicit::Builder(Division::Builder(Rational::Builder(1),Rational::Builder(2)),Rational::Builder(3)));
+  assert_parsed_expression_is("(1/2×3)", Parenthesis::Builder(MultiplicationExplicit::Builder(Division::Builder(Rational::Builder(1),Rational::Builder(2)),Rational::Builder(3))));
+  assert_parsed_expression_is("1×2/3", MultiplicationExplicit::Builder(Rational::Builder(1),Division::Builder(Rational::Builder(2),Rational::Builder(3))));
+  assert_parsed_expression_is("(1×2/3)", Parenthesis::Builder(MultiplicationExplicit::Builder(Rational::Builder(1),Division::Builder(Rational::Builder(2),Rational::Builder(3)))));
  assert_parsed_expression_is("(1/2/3)", Parenthesis::Builder(Division::Builder(Division::Builder(Rational::Builder(1),Rational::Builder(2)),Rational::Builder(3))));
  assert_parsed_expression_is("1^2", Power::Builder(Rational::Builder(1),Rational::Builder(2)));
  assert_parsed_expression_is("1^2^3", Power::Builder(Rational::Builder(1),Power::Builder(Rational::Builder(2),Rational::Builder(3))));
@@ -182,24 +182,24 @@ QUIZ_CASE(poincare_parsing_parse) {
  assert_parsed_expression_is("1+-2", Addition::Builder(Rational::Builder(1),Opposite::Builder(Rational::Builder(2))));
  assert_parsed_expression_is("--1", Opposite::Builder((Expression)Opposite::Builder(Rational::Builder(1))));
  assert_parsed_expression_is("(1+2)-3", Subtraction::Builder(Parenthesis::Builder(Addition::Builder(Rational::Builder(1),Rational::Builder(2))),Rational::Builder(3)));
-  assert_parsed_expression_is("(2×-3)", Parenthesis::Builder(MultiplicationExplicite::Builder(Rational::Builder(2),Opposite::Builder(Rational::Builder(3)))));
+  assert_parsed_expression_is("(2×-3)", Parenthesis::Builder(MultiplicationExplicit::Builder(Rational::Builder(2),Opposite::Builder(Rational::Builder(3)))));
  assert_parsed_expression_is("1^(2)-3", Subtraction::Builder(Power::Builder(Rational::Builder(1),Parenthesis::Builder(Rational::Builder(2))),Rational::Builder(3)));
  assert_parsed_expression_is("1^2-3", Subtraction::Builder(Power::Builder(Rational::Builder(1),Rational::Builder(2)),Rational::Builder(3)));
  assert_parsed_expression_is("2^-3", Power::Builder(Rational::Builder(2),Opposite::Builder(Rational::Builder(3))));
  assert_parsed_expression_is("2--2+-1", Addition::Builder(Subtraction::Builder(Rational::Builder(2),Opposite::Builder(Rational::Builder(2))),Opposite::Builder(Rational::Builder(1))));
-  assert_parsed_expression_is("2--2×-1", Subtraction::Builder(Rational::Builder(2),Opposite::Builder(MultiplicationExplicite::Builder(Rational::Builder(2),Opposite::Builder(Rational::Builder(1))))));
+  assert_parsed_expression_is("2--2×-1", Subtraction::Builder(Rational::Builder(2),Opposite::Builder(MultiplicationExplicit::Builder(Rational::Builder(2),Opposite::Builder(Rational::Builder(1))))));
  assert_parsed_expression_is("-1^2", Opposite::Builder(Power::Builder(Rational::Builder(1),Rational::Builder(2))));
-  assert_parsed_expression_is("2ℯ^(3)", MultiplicationImplicite::Builder(Rational::Builder(2),Power::Builder(Constant::Builder(UCodePointScriptSmallE),Parenthesis::Builder(Rational::Builder(3)))));
+  assert_parsed_expression_is("2ℯ^(3)", MultiplicationImplicit::Builder(Rational::Builder(2),Power::Builder(Constant::Builder(UCodePointScriptSmallE),Parenthesis::Builder(Rational::Builder(3)))));
  assert_parsed_expression_is("2/-3/-4", Division::Builder(Division::Builder(Rational::Builder(2),Opposite::Builder(Rational::Builder(3))),Opposite::Builder(Rational::Builder(4))));
-  assert_parsed_expression_is("1×2-3×4", Subtraction::Builder(MultiplicationExplicite::Builder(Rational::Builder(1),Rational::Builder(2)),MultiplicationExplicite::Builder(Rational::Builder(3),Rational::Builder(4))));
-  assert_parsed_expression_is("-1×2", Opposite::Builder(MultiplicationExplicite::Builder(Rational::Builder(1), Rational::Builder(2))));
+  assert_parsed_expression_is("1×2-3×4", Subtraction::Builder(MultiplicationExplicit::Builder(Rational::Builder(1),Rational::Builder(2)),MultiplicationExplicit::Builder(Rational::Builder(3),Rational::Builder(4))));
+  assert_parsed_expression_is("-1×2", Opposite::Builder(MultiplicationExplicit::Builder(Rational::Builder(1), Rational::Builder(2))));
  assert_parsed_expression_is("1!", Factorial::Builder(Rational::Builder(1)));
  assert_parsed_expression_is("1+2!", Addition::Builder(Rational::Builder(1),Factorial::Builder(Rational::Builder(2))));
  assert_parsed_expression_is("1!+2", Addition::Builder(Factorial::Builder(Rational::Builder(1)),Rational::Builder(2)));
  assert_parsed_expression_is("1!+2!", Addition::Builder(Factorial::Builder(Rational::Builder(1)),Factorial::Builder(Rational::Builder(2))));
-  assert_parsed_expression_is("1×2!", MultiplicationExplicite::Builder(Rational::Builder(1),Factorial::Builder(Rational::Builder(2))));
-  assert_parsed_expression_is("1!×2", MultiplicationExplicite::Builder(Factorial::Builder(Rational::Builder(1)),Rational::Builder(2)));
-  assert_parsed_expression_is("1!×2!", MultiplicationExplicite::Builder(Factorial::Builder(Rational::Builder(1)),Factorial::Builder(Rational::Builder(2))));
+  assert_parsed_expression_is("1×2!", MultiplicationExplicit::Builder(Rational::Builder(1),Factorial::Builder(Rational::Builder(2))));
+  assert_parsed_expression_is("1!×2", MultiplicationExplicit::Builder(Factorial::Builder(Rational::Builder(1)),Rational::Builder(2)));
+  assert_parsed_expression_is("1!×2!", MultiplicationExplicit::Builder(Factorial::Builder(Rational::Builder(1)),Factorial::Builder(Rational::Builder(2))));
  assert_parsed_expression_is("1-2!", Subtraction::Builder(Rational::Builder(1),Factorial::Builder(Rational::Builder(2))));
  assert_parsed_expression_is("1!-2", Subtraction::Builder(Factorial::Builder(Rational::Builder(1)),Rational::Builder(2)));
  assert_parsed_expression_is("1!-2!", Subtraction::Builder(Factorial::Builder(Rational::Builder(1)),Factorial::Builder(Rational::Builder(2))));
@@ -399,27 +399,27 @@ QUIZ_CASE(poincare_parsing_parse_store) {
 QUIZ_CASE(poincare_parsing_implicit_multiplication) {
  assert_text_not_parsable(".1.2");
  assert_text_not_parsable("1 2");
-  assert_parsed_expression_is("1x", MultiplicationImplicite::Builder(Rational::Builder(1),Symbol::Builder("x", 1)));
-  assert_parsed_expression_is("1ans", MultiplicationImplicite::Builder(Rational::Builder(1),Symbol::Builder("ans", 3)));
+  assert_parsed_expression_is("1x", MultiplicationImplicit::Builder(Rational::Builder(1),Symbol::Builder("x", 1)));
+  assert_parsed_expression_is("1ans", MultiplicationImplicit::Builder(Rational::Builder(1),Symbol::Builder("ans", 3)));
  assert_parsed_expression_is("x1", Symbol::Builder("x1", 2));
-  assert_parsed_expression_is("1x+2", Addition::Builder(MultiplicationImplicite::Builder(Rational::Builder(1),Symbol::Builder("x", 1)),Rational::Builder(2)));
-  assert_parsed_expression_is("1π", MultiplicationImplicite::Builder(Rational::Builder(1),Constant::Builder(UCodePointGreekSmallLetterPi)));
-  assert_parsed_expression_is("1x-2", Subtraction::Builder(MultiplicationImplicite::Builder(Rational::Builder(1),Symbol::Builder("x", 1)),Rational::Builder(2)));
-  assert_parsed_expression_is("-1x", Opposite::Builder(MultiplicationImplicite::Builder(Rational::Builder(1),Symbol::Builder("x", 1))));
-  assert_parsed_expression_is("2×1x", MultiplicationExplicite::Builder(Rational::Builder(2),MultiplicationImplicite::Builder(Rational::Builder(1),Symbol::Builder("x", 1))));
-  assert_parsed_expression_is("2^1x", MultiplicationImplicite::Builder(Power::Builder(Rational::Builder(2),Rational::Builder(1)),Symbol::Builder("x", 1)));
-  assert_parsed_expression_is("1x^2", MultiplicationImplicite::Builder(Rational::Builder(1),Power::Builder(Symbol::Builder("x", 1),Rational::Builder(2))));
-  assert_parsed_expression_is("2/1x", Division::Builder(Rational::Builder(2),MultiplicationImplicite::Builder(Rational::Builder(1),Symbol::Builder("x", 1))));
-  assert_parsed_expression_is("1x/2", Division::Builder(MultiplicationImplicite::Builder(Rational::Builder(1),Symbol::Builder("x", 1)),Rational::Builder(2)));
-  assert_parsed_expression_is("(1)2", MultiplicationImplicite::Builder(Parenthesis::Builder(Rational::Builder(1)),Rational::Builder(2)));
-  assert_parsed_expression_is("1(2)", MultiplicationImplicite::Builder(Rational::Builder(1),Parenthesis::Builder(Rational::Builder(2))));
-  assert_parsed_expression_is("sin(1)2", MultiplicationImplicite::Builder(Sine::Builder(Rational::Builder(1)),Rational::Builder(2)));
-  assert_parsed_expression_is("1cos(2)", MultiplicationImplicite::Builder(Rational::Builder(1),Cosine::Builder(Rational::Builder(2))));
-  assert_parsed_expression_is("1!2", MultiplicationImplicite::Builder(Factorial::Builder(Rational::Builder(1)),Rational::Builder(2)));
-  assert_parsed_expression_is("2ℯ^(3)", MultiplicationImplicite::Builder(Rational::Builder(2),Power::Builder(Constant::Builder(UCodePointScriptSmallE),Parenthesis::Builder(Rational::Builder(3)))));
+  assert_parsed_expression_is("1x+2", Addition::Builder(MultiplicationImplicit::Builder(Rational::Builder(1),Symbol::Builder("x", 1)),Rational::Builder(2)));
+  assert_parsed_expression_is("1π", MultiplicationImplicit::Builder(Rational::Builder(1),Constant::Builder(UCodePointGreekSmallLetterPi)));
+  assert_parsed_expression_is("1x-2", Subtraction::Builder(MultiplicationImplicit::Builder(Rational::Builder(1),Symbol::Builder("x", 1)),Rational::Builder(2)));
+  assert_parsed_expression_is("-1x", Opposite::Builder(MultiplicationImplicit::Builder(Rational::Builder(1),Symbol::Builder("x", 1))));
+  assert_parsed_expression_is("2×1x", MultiplicationExplicit::Builder(Rational::Builder(2),MultiplicationImplicit::Builder(Rational::Builder(1),Symbol::Builder("x", 1))));
+  assert_parsed_expression_is("2^1x", MultiplicationImplicit::Builder(Power::Builder(Rational::Builder(2),Rational::Builder(1)),Symbol::Builder("x", 1)));
+  assert_parsed_expression_is("1x^2", MultiplicationImplicit::Builder(Rational::Builder(1),Power::Builder(Symbol::Builder("x", 1),Rational::Builder(2))));
+  assert_parsed_expression_is("2/1x", Division::Builder(Rational::Builder(2),MultiplicationImplicit::Builder(Rational::Builder(1),Symbol::Builder("x", 1))));
+  assert_parsed_expression_is("1x/2", Division::Builder(MultiplicationImplicit::Builder(Rational::Builder(1),Symbol::Builder("x", 1)),Rational::Builder(2)));
+  assert_parsed_expression_is("(1)2", MultiplicationImplicit::Builder(Parenthesis::Builder(Rational::Builder(1)),Rational::Builder(2)));
+  assert_parsed_expression_is("1(2)", MultiplicationImplicit::Builder(Rational::Builder(1),Parenthesis::Builder(Rational::Builder(2))));
+  assert_parsed_expression_is("sin(1)2", MultiplicationImplicit::Builder(Sine::Builder(Rational::Builder(1)),Rational::Builder(2)));
+  assert_parsed_expression_is("1cos(2)", MultiplicationImplicit::Builder(Rational::Builder(1),Cosine::Builder(Rational::Builder(2))));
+  assert_parsed_expression_is("1!2", MultiplicationImplicit::Builder(Factorial::Builder(Rational::Builder(1)),Rational::Builder(2)));
+  assert_parsed_expression_is("2ℯ^(3)", MultiplicationImplicit::Builder(Rational::Builder(2),Power::Builder(Constant::Builder(UCodePointScriptSmallE),Parenthesis::Builder(Rational::Builder(3)))));
  Expression m1[] = {Rational::Builder(1)}; Matrix M1 = BuildMatrix(1,1,m1);
  Expression m2[] = {Rational::Builder(2)}; Matrix M2 = BuildMatrix(1,1,m2);
-  assert_parsed_expression_is("[[1]][[2]]", MultiplicationImplicite::Builder(M1,M2));
+  assert_parsed_expression_is("[[1]][[2]]", MultiplicationImplicit::Builder(M1,M2));
 }

 QUIZ_CASE(poincare_parsing_adding_missing_parentheses) {
@@ -427,9 +427,9 @@ QUIZ_CASE(poincare_parsing_adding_missing_parentheses) {
  assert_parsed_expression_with_user_parentheses_is("1--2", Subtraction::Builder(Rational::Builder(1),Parenthesis::Builder(Opposite::Builder(Rational::Builder(2)))));
  assert_parsed_expression_with_user_parentheses_is("1+conj(-2)", Addition::Builder(Rational::Builder(1),Parenthesis::Builder(Conjugate::Builder(Opposite::Builder(Rational::Builder(2))))));
  assert_parsed_expression_with_user_parentheses_is("1-conj(-2)", Subtraction::Builder(Rational::Builder(1),Parenthesis::Builder(Conjugate::Builder(Opposite::Builder(Rational::Builder(2))))));
-  assert_parsed_expression_with_user_parentheses_is("3conj(1+𝐢)", MultiplicationImplicite::Builder(Rational::Builder(3), Parenthesis::Builder(Conjugate::Builder(Addition::Builder(Rational::Builder(1), Constant::Builder(UCodePointMathematicalBoldSmallI))))));
-  assert_parsed_expression_with_user_parentheses_is("2×-3", MultiplicationExplicite::Builder(Rational::Builder(2), Parenthesis::Builder(Opposite::Builder(Rational::Builder(3)))));
-  assert_parsed_expression_with_user_parentheses_is("2×-3", MultiplicationExplicite::Builder(Rational::Builder(2), Parenthesis::Builder(Opposite::Builder(Rational::Builder(3)))));
+  assert_parsed_expression_with_user_parentheses_is("3conj(1+𝐢)", MultiplicationImplicit::Builder(Rational::Builder(3), Parenthesis::Builder(Conjugate::Builder(Addition::Builder(Rational::Builder(1), Constant::Builder(UCodePointMathematicalBoldSmallI))))));
+  assert_parsed_expression_with_user_parentheses_is("2×-3", MultiplicationExplicit::Builder(Rational::Builder(2), Parenthesis::Builder(Opposite::Builder(Rational::Builder(3)))));
+  assert_parsed_expression_with_user_parentheses_is("2×-3", MultiplicationExplicit::Builder(Rational::Builder(2), Parenthesis::Builder(Opposite::Builder(Rational::Builder(3)))));
  assert_parsed_expression_with_user_parentheses_is("--2", Opposite::Builder(Parenthesis::Builder(Opposite::Builder(Rational::Builder(2)))));
  assert_parsed_expression_with_user_parentheses_is("\u00122/3\u0013^2", Power::Builder(Parenthesis::Builder(Division::Builder(Rational::Builder(2), Rational::Builder(3))), Rational::Builder(2)));
 }