diff --git a/poincare/src/simplification/Makefile b/poincare/src/simplification/Makefile
index 474238e1b..1e62dadac 100644
--- a/poincare/src/simplification/Makefile
+++ b/poincare/src/simplification/Makefile
@@ -18,7 +18,9 @@ objs += $(addprefix $(prefix)/,\
   selector/combination.o \
   selector/selector.o \
   selector/type_selector.o \
+  transform/fraction_transform.o \
+  transform/subtraction_transform.o \
   transform/integer_addition_transform.o \
   transform/merge_dynamic_hierarchy_transform.o \
-  transform/subtraction_transform.o \
 )
+
diff --git a/poincare/src/simplification/demo_ruleset.prs b/poincare/src/simplification/demo_ruleset.prs
index 865f1de19..77715d902 100644
--- a/poincare/src/simplification/demo_ruleset.prs
+++ b/poincare/src/simplification/demo_ruleset.prs
@@ -4,7 +4,7 @@ DemoRuleset
 Subtraction.a -> SubtractionTransform(a);
 
 // a/b -> a*b^-1
-//Division.a -> ReplaceDivisionTransform(a);
+Fraction.a -> FractionTransform(a);
 
 // (a+b)+c -> a+b+c
 Addition.a(Addition.b) -> MergeDynamicHierarchyTransform(a,b);
diff --git a/poincare/src/simplification/expression_simplify.cpp b/poincare/src/simplification/expression_simplify.cpp
index 1a472cf7b..be341aa91 100644
--- a/poincare/src/simplification/expression_simplify.cpp
+++ b/poincare/src/simplification/expression_simplify.cpp
@@ -2,7 +2,6 @@
 #include "../expression_debug.h"
 #include <iostream>
 #include <poincare/static_hierarchy.h>
-#include "transform/integer_addition_transform.h"
 #include "demo_ruleset.h"
 
 namespace Poincare {
diff --git a/poincare/src/simplification/rule.cpp b/poincare/src/simplification/rule.cpp
index 1c8bdb66a..1e4f707d3 100644
--- a/poincare/src/simplification/rule.cpp
+++ b/poincare/src/simplification/rule.cpp
@@ -22,7 +22,7 @@ bool Rule::apply(Expression * e) const {
 bool Rule::immediateApply(Expression * e) const {
   Expression * m[5]; // En fait, 5 est un upper-bound très facilement calculable par notre compilateur de regle. C'est le max du nombre de capture de toutes les règles. Oui, on pourrait faire un truc dynamique qui n'alloue que ce dont le selecteur actuel a besoin, mais bon...
   if (m_selector->match(e, m)) {
-    m_transform->apply(m);
+    m_transform(m);
     return true;
   }
   return false;
diff --git a/poincare/src/simplification/rule.h b/poincare/src/simplification/rule.h
index 8e0bf0bc0..de08280eb 100644
--- a/poincare/src/simplification/rule.h
+++ b/poincare/src/simplification/rule.h
@@ -9,14 +9,14 @@ namespace Simplification {
 
 class Rule {
 public:
-  constexpr Rule(const Selector * s, const Transform * t) :
+  constexpr Rule(const Selector * s, Transform t) :
     m_selector(s), m_transform(t) {
     };
   bool apply(Expression * e) const;
 private:
   bool immediateApply(Expression * e) const;
   const Selector * m_selector;
-  const Transform * m_transform;
+  Transform m_transform;
 };
 
 }
diff --git a/poincare/src/simplification/rulegen/node.cpp b/poincare/src/simplification/rulegen/node.cpp
index eb51c636a..52ad943f9 100644
--- a/poincare/src/simplification/rulegen/node.cpp
+++ b/poincare/src/simplification/rulegen/node.cpp
@@ -50,10 +50,6 @@ void Node::generateSelector(Rule * rule) {
   std::cout << ");" << std::endl;
 }
 
-void Node::generateTransform() {
-  std::cout << "constexpr " << *m_name  << " transform;" << std::endl;
-}
-
 int Node::indexOfChildrenWithIdentifier(std::string identifier) {
   for (int i=0; i<m_children->size(); i++) {
     if (*(m_children->at(i)->m_identifier) == identifier) {
diff --git a/poincare/src/simplification/rulegen/node.h b/poincare/src/simplification/rulegen/node.h
index 4fb61e81c..ad11d762b 100644
--- a/poincare/src/simplification/rulegen/node.h
+++ b/poincare/src/simplification/rulegen/node.h
@@ -18,9 +18,9 @@ public:
   void identifyAnonymousChildren(int * index);
 
   void generateSelector(Rule * rule);
-  void generateTransform();
   int indexOfChildrenWithIdentifier(std::string identifier);
   std::string identifier();
+  std::string name() { return *m_name; }
 private:
   int selectorCaptureIndexInRule(Rule * rule);
   int selectorIndexInRule(Rule * rule);
diff --git a/poincare/src/simplification/rulegen/rule.cpp b/poincare/src/simplification/rulegen/rule.cpp
index 5daa832e0..f276db4a1 100644
--- a/poincare/src/simplification/rulegen/rule.cpp
+++ b/poincare/src/simplification/rulegen/rule.cpp
@@ -6,10 +6,9 @@ void Rule::generate(int index) {
   int selectorIndex = 0;
   m_selector->identifyAnonymousChildren(&selectorIndex);
   m_selector->generateSelector(this);
-  m_transform->generateTransform();
   std::cout << "constexpr Rule rule(&"
-    << m_selector->identifier()
-    << ", &transform);" << std::endl;
+    << m_selector->identifier() << ", "
+    << m_transform->name() << ");" << std::endl;
   std::cout << "}" << std::endl;
 }
 
diff --git a/poincare/src/simplification/rulegen/rules_parser.y b/poincare/src/simplification/rulegen/rules_parser.y
index 17f4e496f..d71bcdb83 100644
--- a/poincare/src/simplification/rulegen/rules_parser.y
+++ b/poincare/src/simplification/rulegen/rules_parser.y
@@ -108,6 +108,7 @@ int main(void) {
   yyparse(&result);
 
   std::cout << "#include \"ruleset.h\"" << std::endl << std::endl;
+  std::cout << "#include \"transform/transform.h\"" << std::endl << std::endl;
 
   std::cout << "namespace Poincare {" << std::endl;
   std::cout << "namespace Simplification {" << std::endl << std::endl;
diff --git a/poincare/src/simplification/ruleset.h b/poincare/src/simplification/ruleset.h
index e32e93591..048786345 100644
--- a/poincare/src/simplification/ruleset.h
+++ b/poincare/src/simplification/ruleset.h
@@ -3,9 +3,6 @@
 
 #include "rule.h"
 #include "selector/type_selector.h"
-#include "transform/subtraction_transform.h"
-#include "transform/integer_addition_transform.h"
-#include "transform/merge_dynamic_hierarchy_transform.h"
 
 namespace Poincare {
 namespace Simplification {
diff --git a/poincare/src/simplification/transform/fraction_transform.cpp b/poincare/src/simplification/transform/fraction_transform.cpp
new file mode 100644
index 000000000..c682c2045
--- /dev/null
+++ b/poincare/src/simplification/transform/fraction_transform.cpp
@@ -0,0 +1,25 @@
+#include "transform.h"
+#include <assert.h>
+#include <poincare/addition.h>
+#include <poincare/fraction.h>
+#include <poincare/integer.h>
+#include <poincare/multiplication.h>
+#include <poincare/power.h>
+
+void Poincare::Simplification::FractionTransform(Expression * captures[]) {
+  assert(captures[0]->type() == Expression::Type::Fraction);
+
+  Fraction * d = static_cast<Fraction *>(captures[0]);
+  assert(d->numberOfOperands() == 2);
+
+  const Integer * minusOne = new Integer(-1);
+  const Expression * powerOperands[2] = {d->operand(1), minusOne};
+  const Power * p = new Power(powerOperands, false);
+  const Expression * multiplicationOperands[2] = {d->operand(0), p};
+  Multiplication * m = new Multiplication(multiplicationOperands, 2, false);
+
+  static_cast<Hierarchy *>(d->parent())->replaceOperand(d, m, false);
+
+  d->detachOperands();
+  delete d;
+}
diff --git a/poincare/src/simplification/transform/integer_addition_transform.cpp b/poincare/src/simplification/transform/integer_addition_transform.cpp
index 071131af3..85d37a394 100644
--- a/poincare/src/simplification/transform/integer_addition_transform.cpp
+++ b/poincare/src/simplification/transform/integer_addition_transform.cpp
@@ -1,13 +1,10 @@
-#include "integer_addition_transform.h"
+#include "transform.h"
 #include <assert.h>
 #include <poincare/addition.h>
 #include <poincare/integer.h>
 #include <utility>
 
-namespace Poincare {
-namespace Simplification {
-
-void IntegerAdditionTransform::apply(Expression * captures[]) const {
+void Poincare::Simplification::IntegerAdditionTransform(Expression * captures[]) {
   assert(captures[0]->type() == Expression::Type::Addition);
   assert(captures[1]->type() == Expression::Type::Integer);
   assert(captures[2]->type() == Expression::Type::Integer);
@@ -29,6 +26,3 @@ void IntegerAdditionTransform::apply(Expression * captures[]) const {
     a->removeOperand(i2);
   }
 }
-
-}
-}
diff --git a/poincare/src/simplification/transform/integer_addition_transform.h b/poincare/src/simplification/transform/integer_addition_transform.h
deleted file mode 100644
index a4e9e12ef..000000000
--- a/poincare/src/simplification/transform/integer_addition_transform.h
+++ /dev/null
@@ -1,18 +0,0 @@
-#ifndef POINCARE_SIMPLIFICATION_TRANSFORM_INTEGER_ADDITION_TRANSFORM_H
-#define POINCARE_SIMPLIFICATION_TRANSFORM_INTEGER_ADDITION_TRANSFORM_H
-
-#include "transform.h"
-
-namespace Poincare {
-namespace Simplification {
-
-class IntegerAdditionTransform : public Transform {
-public:
-  constexpr IntegerAdditionTransform() {};
-  void apply(Expression * captures[]) const override;
-};
-
-}
-}
-
-#endif
diff --git a/poincare/src/simplification/transform/integer_pair_transform.h b/poincare/src/simplification/transform/integer_pair_transform.h
deleted file mode 100644
index 82c03cdef..000000000
--- a/poincare/src/simplification/transform/integer_pair_transform.h
+++ /dev/null
@@ -1,17 +0,0 @@
-#ifndef POINCARE_SIMPLIFICATION_INTEGER_PAIR_TRANSFORM_H
-#define POINCARE_SIMPLIFICATION_INTEGER_PAIR_TRANSFORM_H
-
-#include "transform.h"
-
-namespace Poincare {
-
-class IntegerPairTransform : public Transform {
-public:
-  constexpr IntegerPairTransform() {};
-  void apply(Expression * root, Expression * captures[]) const override;
-  virtual Integer process(const Integer & a, const Integer & b) const = 0;
-};
-
-}
-
-#endif
diff --git a/poincare/src/simplification/transform/merge_dynamic_hierarchy_transform.cpp b/poincare/src/simplification/transform/merge_dynamic_hierarchy_transform.cpp
index a7cb82500..b0226a805 100644
--- a/poincare/src/simplification/transform/merge_dynamic_hierarchy_transform.cpp
+++ b/poincare/src/simplification/transform/merge_dynamic_hierarchy_transform.cpp
@@ -1,11 +1,8 @@
-#include "merge_dynamic_hierarchy_transform.h"
+#include "transform.h"
 #include <assert.h>
 #include <poincare/dynamic_hierarchy.h>
 
-namespace Poincare {
-namespace Simplification {
-
-void MergeDynamicHierarchyTransform::apply(Expression * captures[]) const {
+void Poincare::Simplification::MergeDynamicHierarchyTransform(Expression * captures[]) {
   DynamicHierarchy * h0 = static_cast<DynamicHierarchy *>(captures[0]);
   DynamicHierarchy * h1 = static_cast<DynamicHierarchy *>(captures[1]);
   h0->removeOperand(h1, false);
@@ -13,6 +10,3 @@ void MergeDynamicHierarchyTransform::apply(Expression * captures[]) const {
   h1->detachOperands();
   delete h1;
 }
-
-}
-}
diff --git a/poincare/src/simplification/transform/merge_dynamic_hierarchy_transform.h b/poincare/src/simplification/transform/merge_dynamic_hierarchy_transform.h
deleted file mode 100644
index 92fa3da66..000000000
--- a/poincare/src/simplification/transform/merge_dynamic_hierarchy_transform.h
+++ /dev/null
@@ -1,21 +0,0 @@
-#ifndef POINCARE_SIMPLIFICATION_TRANSFORM_MERGE_HIERARCHY_TRANSFORM_H
-#define POINCARE_SIMPLIFICATION_TRANSFORM_MERGE_HIERARCHY_TRANSFORM_H
-
-#include "transform.h"
-
-namespace Poincare {
-namespace Simplification {
-
-// This transform expects two DynamicHierarchy in its captures.
-// It will remove the second one, and put all its operands in the first.
-
-class MergeDynamicHierarchyTransform : public Transform {
-public:
-  constexpr MergeDynamicHierarchyTransform() {};
-  void apply(Expression * captures[]) const override;
-};
-
-}
-}
-
-#endif
diff --git a/poincare/src/simplification/transform/subtraction_transform.cpp b/poincare/src/simplification/transform/subtraction_transform.cpp
index 584c5f265..bd29c4a67 100644
--- a/poincare/src/simplification/transform/subtraction_transform.cpp
+++ b/poincare/src/simplification/transform/subtraction_transform.cpp
@@ -1,14 +1,11 @@
-#include "subtraction_transform.h"
+#include "transform.h"
 #include <assert.h>
 #include <poincare/addition.h>
 #include <poincare/integer.h>
 #include <poincare/multiplication.h>
 #include <poincare/subtraction.h>
 
-namespace Poincare {
-namespace Simplification {
-
-void SubtractionTransform::apply(Expression * captures[]) const {
+void Poincare::Simplification::SubtractionTransform(Expression * captures[]) {
   assert(captures[0]->type() == Expression::Type::Subtraction);
 
   Subtraction * s = static_cast<Subtraction *>(captures[0]);
@@ -26,6 +23,3 @@ void SubtractionTransform::apply(Expression * captures[]) const {
   s->detachOperands();
   delete s;
 }
-
-}
-}
diff --git a/poincare/src/simplification/transform/subtraction_transform.h b/poincare/src/simplification/transform/subtraction_transform.h
deleted file mode 100644
index 3a53259c7..000000000
--- a/poincare/src/simplification/transform/subtraction_transform.h
+++ /dev/null
@@ -1,18 +0,0 @@
-#ifndef POINCARE_SIMPLIFICATION_TRANSFORM_SUBTRACTION_TRANSFORM_H
-#define POINCARE_SIMPLIFICATION_TRANSFORM_SUBTRACTION_TRANSFORM_H
-
-#include "transform.h"
-
-namespace Poincare {
-namespace Simplification {
-
-class SubtractionTransform : public Transform {
-public:
-  constexpr SubtractionTransform() {};
-  void apply(Expression * captures[]) const override;
-};
-
-}
-}
-
-#endif
diff --git a/poincare/src/simplification/transform/transform.h b/poincare/src/simplification/transform/transform.h
index a36edae70..f9e9eb0d0 100644
--- a/poincare/src/simplification/transform/transform.h
+++ b/poincare/src/simplification/transform/transform.h
@@ -6,10 +6,13 @@
 namespace Poincare {
 namespace Simplification {
 
-class Transform {
-public:
-  virtual void apply(Expression * captures[]) const = 0;
-};
+using Transform = void (*)(Expression * captures[]);
+
+void SubtractionTransform(Expression * captures[]);
+void FractionTransform(Expression * captures[]);
+void MergeDynamicHierarchyTransform(Expression * captures[]);
+void IntegerAdditionTransform(Expression * captures[]);
+void PowerPowerTransform(Expression * captures[]);
 
 }
 }