/*
  Copyright (c) 2013 Microsoft Corporation.
  Copyright (c) 2013 Carnegie Mellon University.
  All rights reserved.
  Released under Apache 2.0 license as described in the file LICENSE.

  Author: Soonho Kong
*/
#include "kernel/abstract.h"
#include "kernel/builtin.h"
#include "kernel/context.h"
#include "kernel/environment.h"
#include "kernel/expr.h"
#include "kernel/printer.h"
#include "kernel/replace.h"
#include "library/basic_thms.h"
#include "library/rewriter/fo_match.h"
#include "library/rewriter/rewriter.h"
#include "library/type_inferer.h"
#include "util/buffer.h"
#include "util/trace.h"

using std::cout;
using std::endl;
using std::initializer_list;
using std::make_pair;
using std::ostream;
using std::pair;

namespace lean {

/**
   \brief For a lambda term v = \f$(\lambda n : ty. body)\f$ and the rewriting result
   for ty, it constructs a new rewriting result for v' = \f$(\lambda n : ty'.
   body)\f$ with the proof of v = v'.

   \param env environment
   \param ctx context
   \param v \f$(\lambda n : ty. body)\f$
   \param result_ty rewriting result of ty -- pair of ty'
          rewritten type of ty and pf_ty the proof of (ty = ty')
   \return pair of v' = \f$(\lambda n : ty'. body)\f$, and proof of v = v'
*/
pair<expr, expr> rewrite_lambda_type(environment const & env, context & ctx, expr const & v, pair<expr, expr> const & result_ty) {
    lean_assert(is_lambda(v));
    type_inferer ti(env);
    expr const & ty     = abst_domain(v);
    expr const & new_ty = result_ty.first;
    expr const & ty_v   = ti(v, ctx);
    if (ty == new_ty) {
        return make_pair(v, Refl(ty_v, v));
    } else {
        name const & n         = abst_name(v);
        expr const & body      = abst_body(v);
        expr const & pf_ty     = result_ty.second;
        expr const & new_v     = mk_lambda(n, new_ty, body);
        expr const & ty_ty     = ti(ty, ctx);
        lean_assert_eq(ty_ty, ti(new_ty, ctx)); // TODO(soonhok): generalize for hetreogeneous types
        expr const & proof     = Subst(ty_ty, ty, new_ty,
                                       Fun({Const("T"), ty_ty},
                                           mk_eq(v, mk_lambda(n, Const("T"), body))),
                                       Refl(ty_v, v), pf_ty);
        return make_pair(new_v, proof);
    }
}

/**
   \brief For a lambda term v = \f$(\lambda n : ty. body)\f$ and the rewriting result
   for body, it constructs a new rewriting result for v' = \f$(\lambda n : ty.
   body')\f$ with the proof of v = v'.

   \param env environment
   \param ctx context
   \param v \f$(\lambda n : ty. body)\f$
   \param result_body rewriting result of body -- pair of \c body'
          rewritten term of body and \c pf_body the proof of (body =
          body')
   \return pair of v' = \f$(\lambda n : ty. body')\f$, and proof of v = v'
*/
pair<expr, expr> rewrite_lambda_body(environment const & env, context & ctx, expr const & v, pair<expr, expr> const & result_body) {
    lean_assert(is_lambda(v));
    type_inferer ti(env);
    expr const & body     = abst_body(v);
    expr const & new_body = result_body.first;
    expr const & ty_v     = ti(v, ctx);
    if (body == new_body) {
        return make_pair(v, Refl(ty_v, v));
    } else {
        name const & n       = abst_name(v);
        expr const & ty      = abst_domain(v);
        expr const & pf_body = result_body.second;
        expr const & new_v   = mk_lambda(n, ty, new_body);
        expr const & ty_body = ti(body, extend(ctx, n, ty));
        lean_assert_eq(ty_body, ti(new_body, ctx)); // TODO(soonhok): generalize for hetreogeneous types
        expr const & proof = Abst(ty, mk_lambda(n, ty, ty_body), v, new_v, mk_lambda(n, ty, pf_body));
        return make_pair(new_v, proof);
    }
}

/**
   \brief For a lambda term v = \f$(\lambda n : ty. body)\f$ and the rewriting
   result for ty and body, it constructs a new rewriting result for v'
   = \f$(\lambda n : ty'. body')\f$ with the proof of v = v'.

   \param env environment
   \param ctx context
   \param v \f$(\lambda n : ty. body)\f$
   \param result_ty rewriting result of ty -- pair of ty'
          rewritten type of ty and pf_ty the proof of (ty = ty')
   \param result_body rewriting result of body -- pair of body'
          rewritten term of body and \c pf_body the proof of (body =
          body')
   \return pair of v' = \f$(\lambda n : ty'. body')\f$, and proof of v = v'
*/
pair<expr, expr> rewrite_lambda(environment const & env, context & ctx, expr const & v, pair<expr, expr> const & result_ty, pair<expr, expr> const & result_body) {
    lean_assert(is_lambda(v));
    type_inferer ti(env);
    name const & n         = abst_name(v);
    expr const & ty        = abst_domain(v);
    expr const & body      = abst_body(v);
    expr const & new_ty    = result_ty.first;
    expr const & pf_ty     = result_ty.second;
    expr const & new_body  = result_body.first;
    expr const & pf_body   = result_body.second;
    expr const & ty_ty     = ti(ty, ctx);
    expr const & ty_body   = ti(body, ctx);
    expr const & ty_v      = ti(v, ctx);
    expr const & new_v1    = mk_lambda(n, new_ty, body);
    expr const & ty_new_v1 = ti(v, ctx);
    expr const & new_v2    = mk_lambda(n, new_ty, new_body);
    // proof1 : v = new_v1
    expr const & proof1    = Subst(ty_ty, ty, new_ty,
                                   Fun({Const("T"), ty_ty},
                                       mk_eq(v, mk_lambda(n, Const("T"), body))),
                                   Refl(ty_v, v),
                                   pf_ty);
    // proof2 : new_v1 = new_v2
    expr const & proof2    = Subst(ty_body, body, new_body,
                                   Fun({Const("e"), ty_body},
                                       mk_eq(new_v1, mk_lambda(n, new_ty, Const("e")))),
                                   Refl(ty_new_v1, new_v1),
                                   pf_body);
    expr const & proof     = Trans(ty_v, v, new_v1, new_v2, proof1, proof2);
    return make_pair(new_v2, proof);
}

/**
   \brief For a Pi term v = \f$(\Pi n : ty. body)\f$ and the rewriting
   result for ty, it constructs a new rewriting result for v'
   = \f$(\Pi n : ty'. body)\f$ with the proof of v = v'.

   \param env environment
   \param ctx context
   \param v \f$(\Pi n : ty. body)\f$
   \param result_ty rewriting result of ty -- pair of ty'
          rewritten type of ty and pf_ty the proof of (ty = ty')
   \return pair of v' = \f$(\Pi n : ty'. body)\f$, and proof of v = v'
*/
pair<expr, expr> rewrite_pi_type(environment const & env, context & ctx, expr const & v, pair<expr, expr> const & result_ty) {
    lean_assert(is_pi(v));
    type_inferer ti(env);
    name const & n      = abst_name(v);
    expr const & ty     = abst_domain(v);
    expr const & body   = abst_body(v);
    expr const & new_ty = result_ty.first;
    expr const & pf     = result_ty.second;
    expr const & new_v  = mk_pi(n, new_ty, body);
    expr const & ty_ty  = ti(ty, ctx);
    expr const & ty_v   = ti(v, ctx);
    expr const & proof  = Subst(ty_ty, ty, new_ty,
                                Fun({Const("T"), ty_ty},
                                    mk_eq(v, mk_pi(n, Const("T"), body))),
                                Refl(ty_v, v),
                                pf);
    return make_pair(new_v, proof);
}

/**
   \brief For a Pi term v = \f$(\Pi n : ty. body)\f$ and the rewriting
   result for body, it constructs a new rewriting result for v'
   = \f$(\Pi n : ty. body')\f$ with the proof of v = v'.

   \param env environment
   \param ctx context
   \param v \f$(\Pi n : ty. body)\f$
   \param result_body rewriting result of body -- pair of body'
          rewritten term of body and \c pf_body the proof of (body =
          body')
   \return pair of v' = \f$(\Pi n : ty. body')\f$, and proof of v = v'
*/
pair<expr, expr> rewrite_pi_body(environment const & env, context & ctx, expr const & v, pair<expr, expr> const & result_body) {
    lean_assert(is_pi(v));
    type_inferer ti(env);
    name const & n        = abst_name(v);
    expr const & ty       = abst_domain(v);
    expr const & body     = abst_body(v);
    expr const & new_body = result_body.first;
    expr const & pf       = result_body.second;
    expr const & new_v    = mk_pi(n, ty, new_body);
    expr const & ty_body  = ti(body, extend(ctx, n, ty));
    expr const & ty_v     = ti(v, ctx);
    expr const & proof    = Subst(ty_body, body, new_body,
                                  Fun({Const("e"), ty_body},
                                      mk_eq(v, mk_pi(n, ty, Const("e")))),
                                  Refl(ty_v, v),
                                  pf);
    return make_pair(new_v, proof);
}

/**
   \brief For a Pi term v = \f$(\Pi n : ty. body)\f$ and the rewriting
   result for ty and body, it constructs a new rewriting result for v'
   = \f$(\Pi n : ty'. body')\f$ with the proof of v = v'.

   \param env environment
   \param ctx context
   \param v \f$(\Pi n : ty. body)\f$
   \param result_ty rewriting result of ty -- pair of ty'
          rewritten type of ty and pf_ty the proof of (ty = ty')
   \param result_body rewriting result of body -- pair of body'
          rewritten term of body and \c pf_body the proof of (body =
          body')
   \return pair of v' = \f$(\Pi n : ty'. body')\f$, and proof of v = v'
*/
pair<expr, expr> rewrite_pi(environment const & env, context & ctx, expr const & v, pair<expr, expr> const & result_ty, pair<expr, expr> const & result_body) {
    lean_assert(is_pi(v));
    type_inferer ti(env);
    name const & n         = abst_name(v);
    expr const & ty        = abst_domain(v);
    expr const & body      = abst_body(v);
    expr const & new_ty    = result_ty.first;
    expr const & pf_ty     = result_ty.second;
    expr const & new_body  = result_body.first;
    expr const & pf_body   = result_body.second;
    expr const & ty_ty     = ti(ty, ctx);
    expr const & ty_body   = ti(body, ctx);
    expr const & ty_v      = ti(v, ctx);
    expr const & new_v1    = mk_pi(n, new_ty, body);
    expr const & ty_new_v1 = ti(v, ctx);
    expr const & new_v2    = mk_pi(n, new_ty, new_body);
    expr const & proof1    = Subst(ty_ty, ty, new_ty,
                                   Fun({Const("T"), ty_ty},
                                       mk_eq(v, mk_pi(n, Const("T"), body))),
                                   Refl(ty_v, v),
                                   pf_ty);
    expr const & proof2    = Subst(ty_body, body, new_body,
                                   Fun({Const("e"), ty_body},
                                       mk_eq(new_v1, mk_pi(n, new_ty, Const("e")))),
                                   Refl(ty_new_v1, new_v1),
                                   pf_body);
    expr const & proof     = Trans(ty_v, v, new_v1, new_v2, proof1, proof2);
    return make_pair(new_v2, proof);
}

/**
   \brief For a Eq term v = (lhs = rhs) and the rewriting result for
   lhs, it constructs a new rewriting result for v' = (lhs' = rhs)
   with the proof of v = v'.

   \param env environment
   \param ctx context
   \param v (lhs = rhs)
   \param result_lhs rewriting result of lhs -- pair of lhs'
          rewritten term of lhs and pf_lhs the proof of (lhs = lhs')
   \return pair of v' = (lhs' = rhs), and proof of v = v'
*/
pair<expr, expr> rewrite_eq_lhs(environment const & env, context & ctx, expr const & v, pair<expr, expr> const & result_lhs) {
    lean_assert(is_eq(v));
    type_inferer ti(env);
    expr const & lhs     = eq_lhs(v);
    expr const & rhs     = eq_rhs(v);
    expr const & new_lhs = result_lhs.first;
    expr const & pf      = result_lhs.second;
    expr const & new_v   = mk_eq(new_lhs, rhs);
    expr const & ty_lhs  = ti(lhs, ctx);
    expr const & ty_v    = ti(v, ctx);
    expr const & proof   = Subst(ty_lhs, lhs, new_lhs,
                                 Fun({Const("x"), ty_lhs},
                                     mk_eq(v, mk_eq(Const("x"), rhs))),
                                 Refl(ty_v, v),
                                 pf);
    return make_pair(new_v, proof);
}

/**
   \brief For a Eq term v = (lhs = rhs)and the rewriting
   result for rhs, it constructs a new rewriting result for v'
   = (lhs = rhs') with the proof of v = v'.

   \param env environment
   \param ctx context
   \param v (lhs = rhs)
   \param result_rhs rewriting result of rhs -- pair of rhs'
          rewritten term of rhs and pf_rhs the proof of (rhs = rhs')
   \return pair of v' = (lhs = rhs'), and proof of v = v'
*/
pair<expr, expr> rewrite_eq_rhs(environment const & env, context & ctx, expr const & v, pair<expr, expr> const & result_rhs) {
    lean_assert(is_eq(v));
    type_inferer ti(env);
    expr const & lhs     = eq_lhs(v);
    expr const & rhs     = eq_rhs(v);
    expr const & new_rhs = result_rhs.first;
    expr const & pf      = result_rhs.second;
    expr const & new_v   = mk_eq(rhs, new_rhs);
    expr const & ty_rhs  = ti(rhs, ctx);
    expr const & ty_v    = ti(v, ctx);
    expr const & proof   = Subst(ty_rhs, rhs, new_rhs,
                                 Fun({Const("x"), ty_rhs},
                                     mk_eq(v, mk_eq(lhs, Const("x")))),
                                 Refl(ty_v, v),
                                 pf);
    return make_pair(new_v, proof);
}

/**
   \brief For a Eq term v = (lhs = rhs)and the rewriting result for
   lhs and rhs, it constructs a new rewriting result for v' = (lhs' =
   rhs') with the proof of v = v'.

   \param env environment
   \param ctx context
   \param v (lhs = rhs)
   \param result_lhs rewriting result of lhs -- pair of lhs'
          rewritten term of lhs and pf_lhs the proof of (lhs = lhs')
   \param result_rhs rewriting result of rhs -- pair of rhs'
          rewritten term of rhs and pf_rhs the proof of (rhs = rhs')
   \return pair of v' = (lhs' = rhs'), and proof of v = v'
*/
pair<expr, expr> rewrite_eq(environment const & env, context & ctx, expr const & v, pair<expr, expr> const & result_lhs, pair<expr, expr> const & result_rhs) {
    lean_assert(is_eq(v));
    type_inferer ti(env);
    expr const & lhs       = eq_lhs(v);
    expr const & rhs       = eq_rhs(v);
    expr const & new_lhs   = result_lhs.first;
    expr const & pf_lhs    = result_lhs.second;
    expr const & new_rhs   = result_rhs.first;
    expr const & pf_rhs    = result_rhs.second;
    expr const & new_v1    = mk_eq(new_lhs, rhs);
    expr const & new_v2    = mk_eq(new_lhs, new_rhs);
    expr const & ty_lhs    = ti(lhs, ctx);
    expr const & ty_rhs    = ti(rhs, ctx);
    expr const & ty_v      = ti(v, ctx);
    expr const & ty_new_v1 = ti(new_v1, ctx);
    expr const & proof1 = Subst(ty_lhs, lhs, new_lhs,
                                Fun({Const("x"), ty_lhs},
                                    mk_eq(v, mk_eq(Const("x"), rhs))),
                                Refl(ty_v, v),
                                pf_lhs);
    expr const & proof2 = Subst(ty_rhs, rhs, new_rhs,
                                Fun({Const("x"), ty_rhs},
                                    mk_eq(v, mk_eq(lhs, Const("x")))),
                                Refl(ty_new_v1, new_v1),
                                pf_rhs);
    expr const & proof  = Trans(ty_v, v, new_v1, new_v2, proof1, proof2);
    return make_pair(new_v2, proof);
}

/**
   \brief For a lambda term v = (let n : ty = val in body) and the rewriting result
   for ty, it constructs a new rewriting result for v' = (let n : ty'
   = val in body) with the proof of v = v'.

   \param env environment
   \param ctx context
   \param v (let n : ty = val in body)
   \param result_ty rewriting result of ty -- pair of ty'
          rewritten type of ty and \c pf_ty the proof of (ty = ty')
   \return pair of v' = (let n : ty' = val in body), and proof of v = v'
*/
pair<expr, expr> rewrite_let_type(environment const & env, context & ctx, expr const & v, pair<expr, expr> const & result_ty) {
    lean_assert(is_let(v));
    type_inferer ti(env);
    name const & n       = let_name(v);
    expr const & ty      = let_type(v);
    expr const & val     = let_value(v);
    expr const & body    = let_body(v);
    expr const & new_ty  = result_ty.first;
    expr const & pf      = result_ty.second;
    expr const & new_v   = mk_let(n, new_ty, val, body);
    expr const & ty_ty   = ti(ty, ctx);
    expr const & ty_v    = ti(v, ctx);
    expr const & proof   = Subst(ty_ty, ty, new_ty,
                                 Fun({Const("x"), ty_ty},
                                     mk_eq(v, mk_let(n, Const("x"), val, body))),
                                 Refl(ty_v, v),
                                 pf);
    return make_pair(new_v, proof);
}

/**
   \brief For a lambda term v = (let n : ty = val in body) and the rewriting result
   for val, it constructs a new rewriting result for v' = (let n : ty
   = val' in body) with the proof of v = v'.

   \param env environment
   \param ctx context
   \param v (let n : ty = val in body)
   \param result_value rewriting result of val -- pair of val'
          rewritten term of val and \c pf_val the proof of (val = val')
   \return pair of v' = (let n : ty = val' in body), and proof of v = v'
*/
pair<expr, expr> rewrite_let_value(environment const & env, context & ctx, expr const & v, pair<expr, expr> const & result_value) {
    lean_assert(is_let(v));
    type_inferer ti(env);
    name const & n       = let_name(v);
    expr const & ty      = let_type(v);
    expr const & val     = let_value(v);
    expr const & body    = let_body(v);
    expr const & new_val = result_value.first;
    expr const & pf      = result_value.second;
    expr const & new_v   = mk_let(n, ty, new_val, body);
    expr const & ty_val  = ti(val, ctx);
    expr const & ty_v    = ti(v, ctx);
    expr const & proof   = Subst(ty_val, val, new_val,
                                 Fun({Const("x"), ty_val},
                                     mk_eq(v, mk_let(n, ty, Const("x"), body))),
                                 Refl(ty_v, v),
                                 pf);
    return make_pair(new_v, proof);
}

/**
   \brief For a lambda term v = (let n : ty = val in body) and the rewriting result
   for body, it constructs a new rewriting result for v' = (let n : ty
   = val in body') with the proof of v = v'.

   \param env environment
   \param ctx context
   \param v (let n : ty = val in body)
   \param result_body rewriting result of body -- pair of \c body'
          rewritten term of body and \c pf_body the proof of (body =
          body')
   \return pair of v' = (let n : ty = val in body'), and proof of v = v'
*/
pair<expr, expr> rewrite_let_body(environment const & env, context & ctx, expr const & v, pair<expr, expr> const & result_body) {
    lean_assert(is_let(v));
    type_inferer ti(env);
    name const & n        = let_name(v);
    expr const & ty       = let_type(v);
    expr const & val      = let_value(v);
    expr const & body     = let_body(v);
    expr const & new_body = result_body.first;
    expr const & pf       = result_body.second;
    expr const & new_v    = mk_let(n, ty, val, new_body);
    expr const & ty_body  = ti(body, extend(ctx, n, ty, body));
    expr const & ty_v     = ti(v, ctx);
    expr const & proof    = Subst(ty_body, body, new_body,
                                  Fun({Const("e"), ty_body},
                                      mk_eq(v, mk_let(n, ty, val, Const("e")))),
                                  Refl(ty_v, v),
                                  pf);
    return make_pair(new_v, proof);
}

/**
   \brief For a lambda term v = (e_0 e_1 ... e_n) and the rewriting results
   for each e_i, it constructs a new rewriting result for v' = (e'_0
   e'_1 ... e'_n) with the proof of v = v'.

   \param env environment
   \param ctx context
   \param v (e_0 e_1 ... e_n)
   \param results rewriting result foe each e_i -- pair of e'_i
          rewritten term of e_i and \c pf_e_i the proof of (e_i = e'_i)
   \return pair of v' = (e'_0 e'_1 ... e'_n), and proof of v = v'
*/
pair<expr, expr> rewrite_app(environment const & env, context & ctx, expr const & v, buffer<pair<expr, expr>> const & results ) {
    type_inferer ti(env);
    expr f = arg(v, 0);
    expr new_f = results[0].first;
    expr pf = results[0].second;
    for (unsigned i = 1; i < results.size(); i++) {
        expr const & f_ty = ti(f, ctx);
        lean_assert(is_pi(f_ty));
        expr const & f_ty_domain = abst_domain(f_ty); // A
        expr f_ty_body = mk_lambda(abst_name(f_ty), f_ty_domain, abst_body(f_ty)); // B
        expr const & e_i = arg(v, i);
        expr const & new_e_i = results[i].first;
        expr const & pf_e_i  = results[i].second;
        bool f_changed = f != new_f;
        if (f_changed) {
            if (arg(v, i) != results[i].first) {
                // Congr : Pi (A : Type u) (B : A -> Type u) (f g : Pi
                // (x : A) B x) (a b : A) (H1 : f = g) (H2 : a = b), f
                // a = g b
                pf = Congr(f_ty_domain, f_ty_body, f, new_f, e_i, new_e_i, pf, pf_e_i);
            } else {
                // Congr1 : Pi (A : Type u) (B : A -> Type u) (f g: Pi
                // (x : A) B x) (a : A) (H : f = g), f a = g a
                pf = Congr1(f_ty_domain, f_ty_body, f, new_f, e_i, pf);
            }
        } else {
            if (arg(v, i) != results[i].first) {
                // Congr2 : Pi (A : Type u) (B : A -> Type u)  (a b : A) (f : Pi (x : A) B x) (H : a = b), f a = f b
                pf = Congr2(f_ty_domain, f_ty_body, e_i, new_e_i, f, pf_e_i);
            } else {
                // Refl
                pf = Refl(ti(f(e_i), ctx), f(e_i));
            }
        }
        f = f (e_i);
        new_f = new_f (new_e_i);
    }
    return make_pair(new_f, pf);
}

void rewriter_cell::dealloc() {
    delete this;
}
rewriter_cell::rewriter_cell(rewriter_kind k):m_kind(k), m_rc(1) { }
rewriter_cell::~rewriter_cell() {
}

// Theorem Rewriter
theorem_rewriter_cell::theorem_rewriter_cell(expr const & type, expr const & body)
    : rewriter_cell(rewriter_kind::Theorem), m_type(type), m_body(body), m_num_args(0) {
    lean_trace("rewriter", tout << "Type = " << m_type << endl;);
    lean_trace("rewriter", tout << "Body = " << m_body << endl;);

    // We expect the theorem is in the form of
    // Pi (x_1 : t_1 ... x_n : t_n), pattern = rhs
    m_pattern = m_type;
    while (is_pi(m_pattern)) {
        m_pattern = abst_body(m_pattern);
        m_num_args++;
    }
    if (!is_eq(m_pattern)) {
        lean_trace("rewriter", tout << "Theorem " << m_type << " is not in the form of "
                   << "Pi (x_1 : t_1 ... x_n : t_n), pattern = rhs" << endl;);
    }
    m_rhs = eq_rhs(m_pattern);
    m_pattern = eq_lhs(m_pattern);

    lean_trace("rewriter", tout << "Number of Arg = " << m_num_args << endl;);
}
theorem_rewriter_cell::~theorem_rewriter_cell() { }
pair<expr, expr> theorem_rewriter_cell::operator()(environment const &, context &, expr const & v) const throw(rewriter_exception) {
    // lean_trace("rewriter", tout << "Context = " << ctx << endl;);
    lean_trace("rewriter", tout << "Term = " << v << endl;);
    lean_trace("rewriter", tout << "Pattern = " << m_pattern << endl;);
    lean_trace("rewriter", tout << "Num Args = " << m_num_args << endl;);

    fo_match fm;
    subst_map s;
    if (!fm.match(m_pattern, v, 0, s)) {
        throw rewriter_exception();
    }
    lean_trace("rewriter", tout << "Subst = " << s << endl;);

    // apply s to rhs
    auto f = [&s](expr const & e, unsigned offset) -> expr {
        if (!is_var(e)) {
            return e;
        }
        unsigned idx = var_idx(e);
        if (idx < offset) {
            return e;
        }

        lean_trace("rewriter", tout << "Inside of apply : offset = " << offset
                   << ", e = " << e
                   << ", idx = " << var_idx(e)  << endl;);
        auto it = s.find(idx);
        if (it != s.end()) {
            lean_trace("rewriter", tout << "Inside of apply : s[" << idx << "] = " << it->second << endl;);
            return it->second;
        }
        return e;
    };

    expr new_rhs = replace_fn<decltype(f)>(f)(m_rhs);
    lean_trace("rewriter", tout << "New RHS = " << new_rhs << endl;);

    expr proof = m_body;
    for (int i = m_num_args -1 ; i >= 0; i--) {
        auto it = s.find(i);
        lean_assert(it != s.end());
        proof = proof(it->second);
        lean_trace("rewriter", tout << "proof: " << i << "\t" << it->second << "\t" << proof << endl;);
    }
    lean_trace("rewriter", tout << "Proof   = " << proof << endl;);
    return make_pair(new_rhs, proof);
}
ostream & theorem_rewriter_cell::display(ostream & out) const {
    out << "Thm_RW(" << m_type << ", " << m_body << ")";
    return out;
}

// OrElse Rewriter
orelse_rewriter_cell::orelse_rewriter_cell(rewriter const & rw1, rewriter const & rw2)
    :rewriter_cell(rewriter_kind::OrElse), m_rwlist({rw1, rw2}) { }
orelse_rewriter_cell::orelse_rewriter_cell(initializer_list<rewriter> const & l)
    :rewriter_cell(rewriter_kind::OrElse), m_rwlist(l) {
    lean_assert(l.size() >= 2);
}
orelse_rewriter_cell::~orelse_rewriter_cell() { }
pair<expr, expr> orelse_rewriter_cell::operator()(environment const & env, context & ctx, expr const & v) const throw(rewriter_exception) {
    for (rewriter const & rw : m_rwlist) {
        try {
            return rw(env, ctx, v);
        } catch (rewriter_exception & ) {
            // Do nothing
        }
    }
    // If the execution reaches here, it means every rewriter failed.
    throw rewriter_exception();
}
ostream & orelse_rewriter_cell::display(ostream & out) const {
    out << "Or_RW({";
    for (rewriter const & rw : m_rwlist) { out << rw << "; "; }
    out << "})";
    return out;
}

// Then Rewriter
then_rewriter_cell::then_rewriter_cell(rewriter const & rw1, rewriter const & rw2)
    :rewriter_cell(rewriter_kind::Then), m_rwlist({rw1, rw2}) { }
then_rewriter_cell::then_rewriter_cell(initializer_list<rewriter> const & l)
    :rewriter_cell(rewriter_kind::Then), m_rwlist(l) {
    lean_assert(l.size() >= 2);
}
then_rewriter_cell::~then_rewriter_cell() { }
pair<expr, expr> then_rewriter_cell::operator()(environment const & env, context & ctx, expr const & v) const throw(rewriter_exception) {
    pair<expr, expr> result = car(m_rwlist)(env, ctx, v);
    pair<expr, expr> new_result = result;
    for (rewriter const & rw : cdr(m_rwlist)) {
        new_result = rw(env, ctx, result.first);
        expr const & ty = type_inferer(env)(v, ctx);
        if (v != new_result.first) {
            result = make_pair(new_result.first,
                               Trans(ty, v, result.first, new_result.first, result.second, new_result.second));
        }
    }
    return result;
}
ostream & then_rewriter_cell::display(ostream & out) const {
    out << "Then_RW({";
    for (rewriter const & rw : m_rwlist) { out << rw << "; "; }
    out << "})";
    return out;
}

// Try Rewriter
try_rewriter_cell::try_rewriter_cell(rewriter const & rw1, rewriter const & rw2)
    :rewriter_cell(rewriter_kind::Try), m_rwlist({rw1, rw2}) { }
try_rewriter_cell::try_rewriter_cell(initializer_list<rewriter> const & l)
    :rewriter_cell(rewriter_kind::Try), m_rwlist(l) {
    lean_assert(l.size() >= 1);
}
try_rewriter_cell::~try_rewriter_cell() { }
pair<expr, expr> try_rewriter_cell::operator()(environment const & env, context & ctx, expr const & v) const throw(rewriter_exception) {
    for (rewriter const & rw : m_rwlist) {
        try {
            return rw(env, ctx, v);
        } catch (rewriter_exception & ) {
            // Do nothing
        }
    }
    // If the execution reaches here, it means every rewriter failed.
    expr const & t = type_inferer(env)(v, ctx);
    return make_pair(v, Refl(t, v));
}
ostream & try_rewriter_cell::display(ostream & out) const {
    out << "Try_RW({";
    for (rewriter const & rw : m_rwlist) { out << rw << "; "; }
    out << "})";
    return out;
}

// App Rewriter
app_rewriter_cell::app_rewriter_cell(rewriter const & rw)
    :rewriter_cell(rewriter_kind::App), m_rw(rw) { }
app_rewriter_cell::~app_rewriter_cell() { }
pair<expr, expr> app_rewriter_cell::operator()(environment const & env, context & ctx, expr const & v) const throw(rewriter_exception) {
    if (!is_app(v))
        throw rewriter_exception();

    buffer<pair<expr, expr>> results;
    for (unsigned i = 0; i < num_args(v); i++) {
        results.push_back(m_rw(env, ctx, arg(v, i)));
    }
    return rewrite_app(env, ctx, v, results);
}

ostream & app_rewriter_cell::display(ostream & out) const {
    out << "App_RW(" << m_rw << ")";
    return out;
}

// Lambda Type Rewriter
lambda_type_rewriter_cell::lambda_type_rewriter_cell(rewriter const & rw)
    :rewriter_cell(rewriter_kind::LambdaType), m_rw(rw) { }
lambda_type_rewriter_cell::~lambda_type_rewriter_cell() { }

pair<expr, expr> lambda_type_rewriter_cell::operator()(environment const & env, context & ctx, expr const & v) const throw(rewriter_exception) {
    if (!is_lambda(v))
        throw rewriter_exception();
    expr const & ty = abst_domain(v);
    type_inferer ti(env);
    pair<expr, expr> result_ty = m_rw(env, ctx, ty);
    if (ty != result_ty.first) {
        return rewrite_lambda_type(env, ctx, v, result_ty);
    } else {
        // nothing changed
        return make_pair(v, Refl(ti(v, ctx), v));
    }
}
ostream & lambda_type_rewriter_cell::display(ostream & out) const {
    out << "Lambda_Type_RW(" << m_rw << ")";
    return out;
}

// Lambda Body Rewriter
lambda_body_rewriter_cell::lambda_body_rewriter_cell(rewriter const & rw)
    :rewriter_cell(rewriter_kind::LambdaBody), m_rw(rw) { }
lambda_body_rewriter_cell::~lambda_body_rewriter_cell() { }

pair<expr, expr> lambda_body_rewriter_cell::operator()(environment const & env, context & ctx, expr const & v) const throw(rewriter_exception) {
    if (!is_lambda(v))
        throw rewriter_exception();

    name const & n = abst_name(v);
    expr const & ty = abst_domain(v);
    expr const & body = abst_body(v);
    context new_ctx = extend(ctx, n, ty);
    pair<expr, expr> result_body = m_rw(env, new_ctx, body);
    if (body != result_body.first) {
        // body changed
        return rewrite_lambda_body(env, ctx, v, result_body);
    } else {
        // nothing changed
        type_inferer ti(env);
        return make_pair(v, Refl(ti(v, ctx), v));
    }
}
ostream & lambda_body_rewriter_cell::display(ostream & out) const {
    out << "Lambda_Body_RW(" << m_rw << ")";
    return out;
}

// Lambda Rewriter
lambda_rewriter_cell::lambda_rewriter_cell(rewriter const & rw)
    :rewriter_cell(rewriter_kind::Lambda), m_rw(rw) { }
lambda_rewriter_cell::~lambda_rewriter_cell() { }

pair<expr, expr> lambda_rewriter_cell::operator()(environment const & env, context & ctx, expr const & v) const throw(rewriter_exception) {
    if (!is_lambda(v))
        throw rewriter_exception();
    rewriter rw = mk_then_rewriter(mk_lambda_type_rewriter(m_rw),
                                   mk_lambda_body_rewriter(m_rw));
    return rw(env, ctx, v);
}
ostream & lambda_rewriter_cell::display(ostream & out) const {
    out << "Lambda_RW(" << m_rw << ")";
    return out;
}

// Pi Type Rewriter
pi_type_rewriter_cell::pi_type_rewriter_cell(rewriter const & rw)
    :rewriter_cell(rewriter_kind::PiType), m_rw(rw) { }
pi_type_rewriter_cell::~pi_type_rewriter_cell() { }

pair<expr, expr> pi_type_rewriter_cell::operator()(environment const & env, context & ctx, expr const & v) const throw(rewriter_exception) {
    if (!is_pi(v))
        throw rewriter_exception();

    expr const & ty = abst_domain(v);
    pair<expr, expr> result_ty = m_rw(env, ctx, ty);
    if (ty != result_ty.first) {
        return rewrite_pi_type(env, ctx, v, result_ty);
    } else {
        // nothing changed
        type_inferer ti(env);
        return make_pair(v, Refl(ti(v, ctx), v));
    }
}
ostream & pi_type_rewriter_cell::display(ostream & out) const {
    out << "Pi_Type_RW(" << m_rw << ")";
    return out;
}

// Pi Body Rewriter
pi_body_rewriter_cell::pi_body_rewriter_cell(rewriter const & rw)
    :rewriter_cell(rewriter_kind::PiBody), m_rw(rw) { }
pi_body_rewriter_cell::~pi_body_rewriter_cell() { }

pair<expr, expr> pi_body_rewriter_cell::operator()(environment const & env, context & ctx, expr const & v) const throw(rewriter_exception) {
    if (!is_pi(v))
        throw rewriter_exception();

    name const & n = abst_name(v);
    expr const & ty = abst_domain(v);
    expr const & body = abst_body(v);
    context new_ctx = extend(ctx, n, ty);
    pair<expr, expr> result_body = m_rw(env, new_ctx, body);
    if (body != result_body.first) {
        // body changed
        return rewrite_pi_body(env, ctx, v, result_body);
    } else {
        // nothing changed
        type_inferer ti(env);
        return make_pair(v, Refl(ti(v, ctx), v));
    }
}
ostream & pi_body_rewriter_cell::display(ostream & out) const {
    out << "Pi_Body_RW(" << m_rw << ")";
    return out;
}

// Pi Rewriter
pi_rewriter_cell::pi_rewriter_cell(rewriter const & rw)
    :rewriter_cell(rewriter_kind::Pi), m_rw(rw) { }
pi_rewriter_cell::~pi_rewriter_cell() { }
pair<expr, expr> pi_rewriter_cell::operator()(environment const & env, context & ctx, expr const & v) const throw(rewriter_exception) {
    if (!is_pi(v))
        throw rewriter_exception();
    rewriter rw = mk_then_rewriter(mk_pi_type_rewriter(m_rw),
                                   mk_pi_body_rewriter(m_rw));
    return rw(env, ctx, v);
}
ostream & pi_rewriter_cell::display(ostream & out) const {
    out << "Pi_RW(" << m_rw << ")";
    return out;
}

// Let Type rewriter
let_type_rewriter_cell::let_type_rewriter_cell(rewriter const & rw)
    :rewriter_cell(rewriter_kind::LetType), m_rw(rw) { }
let_type_rewriter_cell::~let_type_rewriter_cell() { }
pair<expr, expr> let_type_rewriter_cell::operator()(environment const & env, context & ctx, expr const & v) const throw(rewriter_exception) {
    if (!is_let(v))
        throw rewriter_exception();

    expr const & ty = let_type(v);
    pair<expr, expr> result_ty = m_rw(env, ctx, ty);
    if (ty != result_ty.first) {
        // ty changed
        return rewrite_let_type(env, ctx, v, result_ty);
    } else {
        type_inferer ti(env);
        return make_pair(v, Refl(ti(v, ctx), v));
    }
}
ostream & let_type_rewriter_cell::display(ostream & out) const {
    out << "Let_Type_RW(" << m_rw << ")";
    return out;
}

// Let Value rewriter
let_value_rewriter_cell::let_value_rewriter_cell(rewriter const & rw)
    :rewriter_cell(rewriter_kind::LetValue), m_rw(rw) { }
let_value_rewriter_cell::~let_value_rewriter_cell() { }
pair<expr, expr> let_value_rewriter_cell::operator()(environment const & env, context & ctx, expr const & v) const throw(rewriter_exception) {
    if (!is_let(v))
        throw rewriter_exception();

    expr const & val  = let_value(v);
    pair<expr, expr> result_val = m_rw(env, ctx, val);
    if (val != result_val.first) {
        // ty changed
        return rewrite_let_value(env, ctx, v, result_val);
    } else {
        type_inferer ti(env);
        return make_pair(v, Refl(ti(v, ctx), v));
    }
}
ostream & let_value_rewriter_cell::display(ostream & out) const {
    out << "Let_Value_RW(" << m_rw << ")";
    return out;
}

// Let Body rewriter
let_body_rewriter_cell::let_body_rewriter_cell(rewriter const & rw)
    :rewriter_cell(rewriter_kind::LetBody), m_rw(rw) { }
let_body_rewriter_cell::~let_body_rewriter_cell() { }
pair<expr, expr> let_body_rewriter_cell::operator()(environment const & env, context & ctx, expr const & v) const throw(rewriter_exception) {
    if (!is_let(v))
        throw rewriter_exception();

    name const & n    = let_name(v);
    expr const & ty   = let_type(v);
    expr const & body = let_body(v);
    context new_ctx = extend(ctx, n, ty);
    pair<expr, expr> result_body = m_rw(env, new_ctx, body);
    if (body != result_body.first) {
        return rewrite_let_body(env, ctx, v, result_body);
    } else {
        type_inferer ti(env);
        return make_pair(v, Refl(ti(v, ctx), v));
    }
}
ostream & let_body_rewriter_cell::display(ostream & out) const {
    out << "Let_Body_RW(" << m_rw << ")";
    return out;
}

// Let rewriter
let_rewriter_cell::let_rewriter_cell(rewriter const & rw)
    :rewriter_cell(rewriter_kind::Let), m_rw(rw) { }
let_rewriter_cell::~let_rewriter_cell() { }
pair<expr, expr> let_rewriter_cell::operator()(environment const & env, context & ctx, expr const & v) const throw(rewriter_exception) {
    if (!is_let(v))
        throw rewriter_exception();
    rewriter rw = mk_then_rewriter({mk_let_type_rewriter(m_rw),
                                    mk_let_value_rewriter(m_rw),
                                    mk_let_body_rewriter(m_rw)});
    return rw(env, ctx, v);
}
ostream & let_rewriter_cell::display(ostream & out) const {
    out << "Let_RW(" << m_rw << ")";
    return out;
}

// Fail rewriter
fail_rewriter_cell::fail_rewriter_cell():rewriter_cell(rewriter_kind::Fail) { }
fail_rewriter_cell::~fail_rewriter_cell() { }
pair<expr, expr> fail_rewriter_cell::operator()(environment const &, context &, expr const &) const throw(rewriter_exception) {
    throw rewriter_exception();
}
ostream & fail_rewriter_cell::display(ostream & out) const {
    out << "Fail_RW()";
    return out;
}

// Success rewriter (trivial)
success_rewriter_cell::success_rewriter_cell():rewriter_cell(rewriter_kind::Success) { }
success_rewriter_cell::~success_rewriter_cell() { }
pair<expr, expr> success_rewriter_cell::operator()(environment const & env, context & ctx, expr const & v) const throw(rewriter_exception) {
    expr const & t = type_inferer(env)(v, ctx);
    return make_pair(v, Refl(t, v));
}
ostream & success_rewriter_cell::display(ostream & out) const {
    out << "Success_RW()";
    return out;
}

// Repeat rewriter
repeat_rewriter_cell::repeat_rewriter_cell(rewriter const & rw):rewriter_cell(rewriter_kind::Repeat), m_rw(rw) { }
repeat_rewriter_cell::~repeat_rewriter_cell() { }
pair<expr, expr> repeat_rewriter_cell::operator()(environment const & env, context & ctx, expr const & v) const throw(rewriter_exception) {
    pair<expr, expr> result = mk_success_rewriter()(env, ctx, v);
    type_inferer ti(env);
    try {
        while (true) {
            pair<expr, expr> new_result = m_rw(env, ctx, result.first);
            if (result.first == new_result.first)
                break;
            expr const & ty = ti(v, ctx);
            result = make_pair(new_result.first,
                               Trans(ty, v, result.first, new_result.first, result.second, new_result.second));
        }
    } catch (rewriter_exception &) {
        return result;
    }
    return result;
}
ostream & repeat_rewriter_cell::display(ostream & out) const {
    out << "Repeat_RW(" << m_rw << ")";
    return out;
}

// Depth rewriter
depth_rewriter_cell::depth_rewriter_cell(rewriter const & rw):rewriter_cell(rewriter_kind::Depth), m_rw(rw) { }
depth_rewriter_cell::~depth_rewriter_cell() { }
pair<expr, expr> depth_rewriter_cell::operator()(environment const & env, context & ctx, expr const & v) const throw(rewriter_exception) {
    return apply_rewriter_fn<decltype(m_rw)>(m_rw)(env, ctx, v);
}
ostream & depth_rewriter_cell::display(ostream & out) const {
    out << "Depth_RW(" << m_rw << ")";
    return out;
}

rewriter mk_theorem_rewriter(expr const & type, expr const & body) {
    return rewriter(new theorem_rewriter_cell(type, body));
}
rewriter mk_then_rewriter(rewriter const & rw1, rewriter const & rw2) {
    return rewriter(new then_rewriter_cell(rw1, rw2));
}
rewriter mk_then_rewriter(initializer_list<rewriter> const & l) {
    return rewriter(new then_rewriter_cell(l));
}
rewriter mk_try_rewriter(rewriter const & rw) {
    return rewriter(new try_rewriter_cell({rw}));
}
rewriter mk_try_rewriter(rewriter const & rw1, rewriter const & rw2) {
    return rewriter(new try_rewriter_cell(rw1, rw2));
}
rewriter mk_try_rewriter(initializer_list<rewriter> const & l) {
    return rewriter(new try_rewriter_cell(l));
}
rewriter mk_orelse_rewriter(rewriter const & rw1, rewriter const & rw2) {
    return rewriter(new orelse_rewriter_cell(rw1, rw2));
}
rewriter mk_orelse_rewriter(initializer_list<rewriter> const & l) {
    return rewriter(new orelse_rewriter_cell(l));
}
rewriter mk_app_rewriter(rewriter const & rw) {
    return rewriter(new app_rewriter_cell(rw));
}
rewriter mk_lambda_type_rewriter(rewriter const & rw) {
    return rewriter(new lambda_type_rewriter_cell(rw));
}
rewriter mk_lambda_body_rewriter(rewriter const & rw) {
    return rewriter(new lambda_body_rewriter_cell(rw));
}
rewriter mk_lambda_rewriter(rewriter const & rw) {
    return rewriter(new lambda_rewriter_cell(rw));
}
rewriter mk_pi_type_rewriter(rewriter const & rw) {
    return rewriter(new pi_type_rewriter_cell(rw));
}
rewriter mk_pi_body_rewriter(rewriter const & rw) {
    return rewriter(new pi_body_rewriter_cell(rw));
}
rewriter mk_pi_rewriter(rewriter const & rw) {
    return rewriter(new pi_rewriter_cell(rw));
}
rewriter mk_let_type_rewriter(rewriter const & rw) {
    return rewriter(new let_type_rewriter_cell(rw));
}
rewriter mk_let_value_rewriter(rewriter const & rw) {
    return rewriter(new let_value_rewriter_cell(rw));
}
rewriter mk_let_body_rewriter(rewriter const & rw) {
    return rewriter(new let_body_rewriter_cell(rw));
}
rewriter mk_let_rewriter(rewriter const & rw) {
    return rewriter(new let_rewriter_cell(rw));
}
rewriter mk_fail_rewriter() {
    return rewriter(new fail_rewriter_cell());
}
rewriter mk_success_rewriter() {
    return rewriter(new success_rewriter_cell());
}
rewriter mk_repeat_rewriter(rewriter const & rw) {
    return rewriter(new repeat_rewriter_cell(rw));
}
rewriter mk_depth_rewriter(rewriter const & rw) {
    return rewriter(new depth_rewriter_cell(rw));
}
}