2014-11-11 20:26:26 +00:00
|
|
|
/*
|
|
|
|
Copyright (c) 2014 Microsoft Corporation. All rights reserved.
|
|
|
|
Released under Apache 2.0 license as described in the file LICENSE.
|
|
|
|
|
|
|
|
Author: Leonardo de Moura
|
|
|
|
*/
|
|
|
|
#include "kernel/find_fn.h"
|
|
|
|
#include "kernel/inductive/inductive.h"
|
|
|
|
|
|
|
|
namespace lean {
|
2014-11-11 21:53:41 +00:00
|
|
|
/** \brief Return true if environment has a constructor named \c c that returns
|
|
|
|
an element of the inductive datatype named \c I, and \c c must have \c nparams parameters.
|
|
|
|
*/
|
|
|
|
bool has_constructor(environment const & env, name const & c, name const & I, unsigned nparams) {
|
|
|
|
auto d = env.find(c);
|
|
|
|
if (!d || d->is_definition())
|
2014-11-11 21:46:36 +00:00
|
|
|
return false;
|
2014-11-11 21:53:41 +00:00
|
|
|
expr type = d->get_type();
|
|
|
|
unsigned i = 0;
|
|
|
|
while (is_pi(type)) {
|
|
|
|
i++;
|
|
|
|
type = binding_body(type);
|
|
|
|
}
|
|
|
|
if (i != nparams)
|
2014-11-11 21:46:36 +00:00
|
|
|
return false;
|
2014-11-11 21:53:41 +00:00
|
|
|
type = get_app_fn(type);
|
|
|
|
return is_constant(type) && const_name(type) == I;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool has_unit_decls(environment const & env) {
|
|
|
|
return has_constructor(env, name{"unit", "star"}, "unit", 0);
|
2014-11-11 21:46:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
bool has_eq_decls(environment const & env) {
|
2014-11-11 21:53:41 +00:00
|
|
|
return has_constructor(env, name{"eq", "refl"}, "eq", 2);
|
2014-11-11 21:46:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
bool has_heq_decls(environment const & env) {
|
2014-11-11 21:53:41 +00:00
|
|
|
return has_constructor(env, name{"heq", "refl"}, "heq", 2);
|
2014-11-11 21:46:36 +00:00
|
|
|
}
|
|
|
|
|
2014-11-11 20:26:26 +00:00
|
|
|
bool is_recursive_datatype(environment const & env, name const & n) {
|
|
|
|
optional<inductive::inductive_decls> decls = inductive::is_inductive_decl(env, n);
|
|
|
|
if (!decls)
|
|
|
|
return false;
|
|
|
|
for (inductive::inductive_decl const & decl : std::get<2>(*decls)) {
|
|
|
|
for (inductive::intro_rule const & intro : inductive::inductive_decl_intros(decl)) {
|
|
|
|
expr type = inductive::intro_rule_type(intro);
|
|
|
|
while (is_pi(type)) {
|
|
|
|
if (find(binding_domain(type), [&](expr const & e, unsigned) {
|
|
|
|
return is_constant(e) && const_name(e) == n; }))
|
|
|
|
return true;
|
|
|
|
type = binding_body(type);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return false;
|
|
|
|
}
|
2014-11-11 21:24:58 +00:00
|
|
|
|
|
|
|
bool is_inductive_predicate(environment const & env, name const & n) {
|
|
|
|
if (!env.impredicative())
|
|
|
|
return false; // environment does not have Prop
|
|
|
|
if (!inductive::is_inductive_decl(env, n))
|
|
|
|
return false; // n is not inductive datatype
|
|
|
|
expr type = env.get(n).get_type();
|
|
|
|
while (is_pi(type)) {
|
|
|
|
type = binding_body(type);
|
|
|
|
}
|
|
|
|
return is_sort(type) && is_zero(sort_level(type));
|
|
|
|
}
|
2014-11-11 20:26:26 +00:00
|
|
|
}
|