С++ Передать в качестве компаратора метод

Как в качестве компаратора отправить метод из класса?

Когда пытаюсь отправить его, то пишет ошибку:

• Ошибка C3867 "MonomialOrder::compair_less": нестандартный синтаксис; используйте "&", чтобы создать указатель на член;
• Ошибка C2672 "std::sort": не найдена соответствующая перегруженная функция;
• Ошибка C2780 void std::sort(const _RanIt,const _RanIt): требует аргументов: 2, имеется: 3;

Вот конкретный пример:

#include <iostream>
#include <vector>
#include <string>
#include <functional>
#include <algorithm>
class Monomial {
public:
    Monomial(const int& coef_tmp, const std::vector<int>& deegs_tmp) : coef(coef_tmp), deegs(deegs_tmp) {}
    int get_coef() const {
        return coef;
    }
    int operator[](size_t i) const {
        return deegs[i];
    }
    Monomial operator *(const Monomial& other) const {
        std::vector<int> tmp_deegs(26);
        for (size_t i = 0; i < 26; ++i) {
            tmp_deegs[i] = deegs[i] + other[i];
        }
        return { coef * other.get_coef(), tmp_deegs };
    }
    Monomial& operator +=(const Monomial& other) {
        // check for equal
        coef += other.get_coef();
        return *this;
    }
    bool is_equal(const Monomial& other) const {
        for (size_t i = 0; i < 26; ++i) {
            if (deegs[i] != other[i]) {
                return 0;
            }
        }
        return 1;
    }
private:
    int coef;
    std::vector<int> deegs;
};
class MonomialOrder {
public:
    MonomialOrder() {}
    MonomialOrder(std::vector<std::function<bool(Monomial, Monomial)>> tmp_mon_ord) {
        orders = tmp_mon_ord;
    }
    void add_order(const std::function<bool(Monomial, Monomial)> func) {
        orders.push_back(func);
    }
    std::function<bool(const Monomial&, const Monomial&)>operator[](size_t i) const {
        return orders[i];
    }
    bool compair_less(Monomial mon1, Monomial mon2) {
        for (auto func : orders) {
            if (func(mon1, mon2) != func(mon2, mon1)) {
                return func(mon1, mon2);
            }
        }
        return 0;
    }
private:
    std::vector<std::function<bool(Monomial, Monomial)>> orders;
};
bool lexicograph(Monomial mon1, Monomial mon2) {
    for (size_t i = 0; i < 26; ++i) {
        if (mon1[i] != mon2[i]) {
            return mon1[i] < mon2[i];
        }
    }
    return 0;
}
class Polynomial {
public:
    Polynomial() {}
    Polynomial& operator +=(const Monomial& other) {
        bool diff = true;
        for (auto& monom : monoms) {
            if (monom.is_equal(other)) {
                monom += other;
                diff = false;
            }
        }
        if (diff) {
            monoms.push_back(other);
        }
        return *this;
    }
    void sort_pol(const MonomialOrder& ord) {
        std::sort(monoms.begin(), monoms.end(), ord.compair_less);
    }
private:
    std::vector<Monomial> monoms;
};
int main() {
    std::vector<int> aa(26);
    aa[0] = 1;
    aa[1] = 5;
    std::vector<int> bb(26);
    bb[1] = 3;
    bb[2] = 1;
    Monomial a(4, aa), b(-5, bb);
    Monomial ab = a * b;
    MonomialOrder lex;
    lex.add_order(lexicograph);
    std::cout << lex.compair_less(b, a);
    Polynomial p;
    p += a;
    p += b;
    p += ab;
    p.sort_pol(lex);
    return 0;
}