tactic clear_tactic(name const & n) {
auto fn = [=](environment const &, io_state const &, proof_state const & _s) -> optional<proof_state> {
if (!_s.get_goals()) {
throw_no_goal_if_enabled(_s);
return none_proof_state();
}
proof_state s = apply_substitution(_s);
goals const & gs = s.get_goals();
goal g = head(gs);
goals tail_gs = tail(gs);
if (auto p = g.find_hyp(n)) {
expr const & h = p->first;
unsigned i = p->second;
buffer<expr> hyps;
g.get_hyps(hyps);
hyps.erase(hyps.size() - i - 1);
if (depends_on(g.get_type(), h)) {
throw_tactic_exception_if_enabled(s, sstream() << "invalid 'clear' tactic, conclusion depends on '"
<< n << "'");
return none_proof_state();
}
if (auto h2 = depends_on(i, hyps.end() - i, h)) {
throw_tactic_exception_if_enabled(s, sstream() << "invalid 'clear' tactic, hypothesis '" << *h2
<< "' depends on '" << n << "'");
return none_proof_state();
}
name_generator ngen = s.get_ngen();
expr new_type = g.get_type();
expr new_meta = mk_app(mk_metavar(ngen.next(), Pi(hyps, new_type)), hyps);
goal new_g(new_meta, new_type);
substitution new_subst = s.get_subst();
assign(new_subst, g, new_meta);
proof_state new_s(s, goals(new_g, tail_gs), new_subst, ngen);
return some_proof_state(new_s);
} else {
throw_tactic_exception_if_enabled(s, sstream() << "invalid 'clear' tactic, goal does not have a hypothesis "
<< " named '" << n << "'");
return none_proof_state();
}
};
return tactic01(fn);
}
tactic revert_tactic(name const & n) {
auto fn = [=](environment const &, io_state const &, proof_state const & s) -> optional<proof_state> {
goals const & gs = s.get_goals();
if (empty(gs)) {
throw_no_goal_if_enabled(s);
return none_proof_state();
}
goal g = head(gs);
goals tail_gs = tail(gs);
if (auto p = g.find_hyp(n)) {
expr const & h = p->first;
unsigned i = p->second;
buffer<expr> hyps;
g.get_hyps(hyps);
hyps.erase(hyps.size() - i - 1);
if (optional<expr> other_h = depends_on(i, hyps.end() - i, h)) {
throw_tactic_exception_if_enabled(s, sstream() << "invalid 'revert' tactic, hypothesis '" << local_pp_name(*other_h)
<< "' depends on '" << local_pp_name(h) << "'");
return none_proof_state(); // other hypotheses depend on h
}
name_generator ngen = s.get_ngen();
expr new_type = Pi(h, g.get_type());
expr new_meta = mk_app(mk_metavar(ngen.next(), Pi(hyps, new_type)), hyps);
goal new_g(new_meta, new_type);
substitution new_subst = s.get_subst();
assign(new_subst, g, mk_app(new_meta, h));
proof_state new_s(s, goals(new_g, tail_gs), new_subst, ngen);
return some_proof_state(new_s);
} else {
throw_tactic_exception_if_enabled(s, sstream() << "invalid 'revert' tactic, unknown hypothesis '" << n << "'");
return none_proof_state();
}
};
return tactic01(fn);
}
void XZHydrostatic_GeoPotential<EvalT, Traits>::
evaluateFields(typename Traits::EvalData workset)
{
#ifndef ALBANY_KOKKOS_UNDER_DEVELOPMENT
for (int cell=0; cell < workset.numCells; ++cell) {
for (int node=0; node < numNodes; ++node) {
for (int level=0; level < numLevels; ++level) {
ScalarT sum =
PhiSurf(cell,node) +
0.5 * Pi(cell,node,level) * E.delta(level) / density(cell,node,level);
for (int j=level+1; j < numLevels; ++j) sum += Pi(cell,node,j) * E.delta(j) / density(cell,node,j);
Phi(cell,node,level) = sum;
//std::cout <<"Inside GeoP, cell, node, PhiSurf(cell,node)="<<cell<<
//", "<<node<<", "<<PhiSurf(cell,node) <<std::endl;
}
}
}
/* OG Debugging statements
std::cout << "Printing PHI at level 0 ----------------------------------------- \n";
//for(int level=0; level < numLevels; ++level){
for (int node=0; node < numNodes; ++node) {
//std::cout << "lev= " << level << ", phi = " << Phi(23,0,level) <<"\n";
std::cout << "node = " << node << ", phi = " << Phi(23,node,0) <<"\n";
}
//}*/
#else
Kokkos::parallel_for(XZHydrostatic_GeoPotential_Policy(0,workset.numCells),*this);
cudaCheckError();
#endif
}
Angle RestrictPhi(Angle phi)
{
if (std::isnan(phi.value())) {
ERROR("function called with NaN");
return phi;
}
while (phi >= Pi()) phi -= TwoPi();
while (phi < -Pi()) phi += TwoPi();
return phi;
}
double site::patch_weight(double time_start, double time) {
switch(type){
default:case(0):// Single patch
return 1.0;
case(1):case(2): // Weibull / exponential distribution
return Pi(time)/ Pi(time_start);
}
return 0.0;
}
KOKKOS_INLINE_FUNCTION
void XZHydrostatic_GeoPotential<EvalT, Traits>::
operator() (const XZHydrostatic_GeoPotential_Tag& tag, const int& cell) const{
for (int node=0; node < numNodes; ++node) {
for (int level=0; level < numLevels; ++level) {
ScalarT sum =
PhiSurf(cell,node) +
0.5 * Pi(cell,node,level) * delta(level) / density(cell,node,level);
for (int j=level+1; j < numLevels; ++j) sum += Pi(cell,node,j) * delta(j) / density(cell,node,j);
Phi(cell,node,level) = sum;
}
}
}
void test_pi(void)
{
std::vector<real> angles;
std::vector<Vector> pos;
Angdict angdict;
Posdict posdict;
Vector a, b, c, d;
a.x = 1.; a.y = 2.;
b.x = 2.; b.y = 2.;
c.x = 2.; c.y = 0.;
d.x = 4.; d.y = 4.;
angles = {real(0), real(PI/4), real(-PI/4), real(0)};
pos = {a, b, c, d};
angdict[0] = angles;
posdict[0] = pos;
Pi pi(angdict);
assert(pi.Get(0, 0).Compare(Vector(0., 0.)));
assert(pi.Get(0, 1).Compare(Vector(0., std::sqrt(real(2.))/2.)));
assert(pi.Get(0, 2).Compare(Vector(0., -std::sqrt(real(2.))/2.)));
assert(pi.Get(0, 3).Compare(Vector(0., 0.)));
angles = {PI/2., 3. * PI/4., PI/4., PI/2.};
angdict[0] = angles;
posdict[0] = pos;
pi = Pi(angdict);
assert(pi.Get(0, 0).Compare(Vector(0., 0.)));
assert(pi.Get(0, 1).Compare(Vector(-std::sqrt(real(2.))/2., 0.)));
assert(pi.Get(0, 2).Compare(Vector(std::sqrt(real(2.))/2., 0.)));
assert(pi.Get(0, 3).Compare(Vector(0., 0.)));
angles = {PI/4, PI/2, 0, PI/4};
angdict[0] = angles;
posdict[0] = pos;
pi = Pi(angdict);
assert(pi.Get(0, 0).Compare(Vector(0., 0.)));
assert(pi.Get(0, 1).Compare(Vector(-0.5, 0.5)));
assert(pi.Get(0, 2).Compare(Vector(0.5, -0.5)));
assert(pi.Get(0, 3).Compare(Vector(0., 0.)));
}
void SlidingTilePuzzle::GetRankFromState(const SlidingTilePuzzleState& state, uint64_t& rank)
{
//make a copy of the state
SlidingTilePuzzleState Pi(state);
int size = width*height;
//caculate Pi^-1
std::vector<int> dual;
dual.resize(size);
for (int i = 0; i < size; i++)
{
dual[Pi.puzzle[i]] = i;
}
rank = 0;
int s = 0;
for (int n = size; n > 0; n--)
{
s = Pi.puzzle[n - 1];
//swap Pi[n-1], Pi[Pi^-1[n-1]]
std::swap(Pi.puzzle[n - 1], Pi.puzzle[dual[n - 1]]);
//swap Pi^-1[s], Pi^-1[n-1]
std::swap(dual[n - 1], dual[s]);
rank += s*Factorial(n - 1);
}
#ifdef ASGS
rank = rank << 8;
rank = rank + (int)state.hCost;
#endif
}
void XZHydrostatic_Pressure<EvalT, Traits>::
evaluateFields(typename Traits::EvalData workset)
{
const Eta<EvalT> &E = Eta<EvalT>::self();
for (int cell=0; cell < workset.numCells; ++cell) {
for (int node=0; node < numNodes; ++node) {
/*
if(cell == 0 && node == 0){
std::cout << "Etatop = " << E.etatop() <<"\n";
for (int level=0; level < numLevels; ++level) {
std::cout << "Here we are level, eta " << level << " " << E.eta(level) << "\n";
}
for (int level=0; level < numLevels; ++level) {
std::cout << "Here we are A, B " << level << " " << E.A(level) << " " << E.B(level) << "\n";
}
}
*/
for (int level=0; level < numLevels; ++level) {
Pressure(cell,node,level) = E.A(level)*E.p0() + E.B(level)*Ps(cell,node);
//std::cout <<"In Pressure "<< " Ps" << Ps(cell,node) <<" workset time" << workset.current_time << "\n";
}
//here instead of computing eta, A, B, and pressure at level interfaces directly,
//averages are used to approx. pressure at level interfaces.
for (int level=0; level < numLevels; ++level) {
const ScalarT pm = level ? 0.5*( Pressure(cell,node,level) + Pressure(cell,node,level-1) ) : E.ptop();
const ScalarT pp = level<numLevels-1 ? 0.5*( Pressure(cell,node,level) + Pressure(cell,node,level+1) ) : ScalarT(Ps(cell,node));
Pi(cell,node,level) = (pp - pm) /E.delta(level);
}
}
}
}
Foam::tmp<Foam::vector2DField> Foam::waveModels::solitary::velocity
(
const scalar t,
const scalar u,
const vector2DField& xz
) const
{
const scalar A = alpha(t);
const scalarField Z(max(scalar(0), 1 - mag(xz.component(1)/depth())));
const scalarField P(Pi(t, u, xz.component(0)));
return
celerity(t)
*zip
(
A/4
*(
(4 + 2*A - 6*A*sqr(Z))*P
+ (- 7*A + 9*A*sqr(Z))*sqr(P)
),
- A*Z*depth()*k(t)*tanh(parameter(t, u, xz.component(0)))
*(
(2 + A - A*sqr(Z))*P
+ (- 7*A + 3*A*sqr(Z))*sqr(P)
)
);
}
Foam::tmp<Foam::scalarField> Foam::waveModels::solitary::elevation
(
const scalar t,
const scalar u,
const scalarField& x
) const
{
return amplitude(t)*Pi(t, u, x);
}
double site::patch_age_density_freq(double age) {
switch(type){
default:case(0): // Single patch
return 1.0;
case(1):case(2): // Weibull + exponential distribution
return p0*Pi(age);
}
return 0.0;
}
Vector* PolyColl::BuildBlob(int iNumVertices, float radius)
{
Vector* axVertices = new Vector[iNumVertices];
for(int i = 0; i < iNumVertices; i ++)
{
float a = 2.0f * Pi() * (i / (float) iNumVertices);
axVertices[i] = Vector(cos(a), sin(a)) * radius;
}
return axVertices;
}
bool getCamPrj(const ResourceFinder &rf, const string &type, Matrix **Prj)
{
ResourceFinder &_rf=const_cast<ResourceFinder&>(rf);
*Prj=NULL;
if (!_rf.isConfigured())
return false;
string camerasFile=_rf.findFile("from").c_str();
if (!camerasFile.empty())
{
Bottle parType=_rf.findGroup(type.c_str());
string warning="Intrinsic parameters for "+type+" group not found";
if (parType.check("cx") && parType.check("cy") &&
parType.check("fx") && parType.check("fy"))
{
double cx=parType.find("cx").asDouble();
double cy=parType.find("cy").asDouble();
double fx=parType.find("fx").asDouble();
double fy=parType.find("fy").asDouble();
Matrix K=eye(3,3);
Matrix Pi=zeros(3,4);
K(0,0)=fx; K(1,1)=fy;
K(0,2)=cx; K(1,2)=cy;
Pi(0,0)=Pi(1,1)=Pi(2,2)=1.0;
*Prj=new Matrix;
**Prj=K*Pi;
return true;
}
else
fprintf(stdout,"%s\n",warning.c_str());
}
return false;
}
void
apply_proj_inv(
vsip::Matrix<T, Block1> P,
T x,
T y,
T& u,
T& v)
{
vsip::Matrix<T> Pi(3, 3);
invert_proj(P, Pi);
apply_proj(Pi, x, y, u, v);
}
void XZHydrostatic_GeoPotential<EvalT, Traits>::
evaluateFields(typename Traits::EvalData workset)
{
const Eta<EvalT> &E = Eta<EvalT>::self();
ScalarT sum;
for (int cell=0; cell < workset.numCells; ++cell) {
for (int node=0; node < numNodes; ++node) {
for (int level=0; level < numLevels; ++level) {
sum =
PhiSurf(cell,node) +
0.5 * Pi(cell,node,level) * E.delta(level) / density(cell,node,level);
for (int j=level+1; j < numLevels; ++j) sum += Pi(cell,node,j) * E.delta(j) / density(cell,node,j);
Phi(cell,node,level) = sum;
//std::cout <<"Inside GeoP, cell, node, PhiSurf(cell,node)="<<cell<<
//", "<<node<<", "<<PhiSurf(cell,node) <<std::endl;
}
}
}
}
environment mk_rec_on(environment const & env, name const & n) {
if (!inductive::is_inductive_decl(env, n))
throw exception(sstream() << "error in 'rec_on' generation, '" << n << "' is not an inductive datatype");
name rec_on_name(n, "rec_on");
name_generator ngen;
declaration rec_decl = env.get(inductive::get_elim_name(n));
buffer<expr> locals;
expr rec_type = rec_decl.get_type();
while (is_pi(rec_type)) {
expr local = mk_local(ngen.next(), binding_name(rec_type), binding_domain(rec_type), binding_info(rec_type));
rec_type = instantiate(binding_body(rec_type), local);
locals.push_back(local);
}
// locals order
// A C minor_premises indices major-premise
// new_locals order
// A C indices major-premise minor-premises
buffer<expr> new_locals;
unsigned idx_major_sz = *inductive::get_num_indices(env, n) + 1;
unsigned minor_sz = *inductive::get_num_minor_premises(env, n);
unsigned AC_sz = locals.size() - minor_sz - idx_major_sz;
for (unsigned i = 0; i < AC_sz; i++)
new_locals.push_back(locals[i]);
for (unsigned i = 0; i < idx_major_sz; i++)
new_locals.push_back(locals[AC_sz + minor_sz + i]);
unsigned rec_on_major_idx = new_locals.size() - 1;
for (unsigned i = 0; i < minor_sz; i++)
new_locals.push_back(locals[AC_sz + i]);
expr rec_on_type = Pi(new_locals, rec_type);
levels ls = param_names_to_levels(rec_decl.get_univ_params());
expr rec = mk_constant(rec_decl.get_name(), ls);
expr rec_on_val = Fun(new_locals, mk_app(rec, locals));
bool use_conv_opt = true;
environment new_env = module::add(env,
check(env, mk_definition(env, rec_on_name, rec_decl.get_univ_params(),
rec_on_type, rec_on_val, use_conv_opt)));
new_env = set_reducible(new_env, rec_on_name, reducible_status::Reducible);
new_env = add_unfold_hint(new_env, rec_on_name, rec_on_major_idx);
new_env = add_aux_recursor(new_env, rec_on_name);
return add_protected(new_env, rec_on_name);
}
//----------------------------------------------------------------------
bool observer::Contract(box& P) {
vector<box> L;
vector<box> Pi(N_window);
Pi[N_window-1]=P;
// Dans ce qui suit, on recopie les listes dans des vecteurs pour avoir un accès direct (c'est pas terrible, mais je ne sais pas faire autrement)
// Je sais qu'il existe une classe qui permet de faire une liste-vecteur, mais je ne sais pas son nom.
vector<double> Vu1(N_window); list<double>::iterator iLu1=Lu1.begin(); for(int i=0;i<N_window;i++) {Vu1[i]=*iLu1; iLu1++;};
vector<double> Vu2(N_window); list<double>::iterator iLu2=Lu2.begin(); for(int i=0;i<N_window;i++) {Vu2[i]=*iLu2; iLu2++;};
vector<double> Valpha(N_window); list<double>::iterator iLalpha=Lalpha.begin(); for(int i=0;i<N_window;i++) {Valpha[i]=*iLalpha; iLalpha++;}
vector<interval> Vd(N_window); list <interval>::iterator iLd=Ld.begin(); for(int i=0;i<N_window;i++) {Vd[i]=*iLd; iLd++;}
vector<box> VXhat(N_window-1); list <box>::iterator iLXhat=LXhat.begin(); for(int i=0;i<N_window-1;i++){VXhat[i]=*iLXhat; iLXhat++;}
for (int i=N_window-2;i>=0;i--) {
Pi[i]=box(4);
Decremente(Pi[i+1][1],Pi[i+1][2],Pi[i+1][3],Pi[i+1][4],Pi[i][1],Pi[i][2],Pi[i][3],Pi[i][4],Vu1[i],Vu2[i]);
Pi[i]=Inter(Pi[i],VXhat[i]);
}
for (int i=0;i<N_window;i++) {
interval xi=Pi[i][1]; interval yi=Pi[i][2];
interval thetai=Pi[i][3]; interval vi=Pi[i][4];
interval betai=Valpha[i]+thetai;
interval di=Vd[i];
CLegOnWallsOrCircles(di,xi,yi,betai,murs_xa,murs_ya,murs_xb,murs_yb,cercles_x,cercles_y,cercles_r);
Cplus(betai,Valpha[i],thetai,-1);
interval xip,yip,thetaip,vip;
for (int i1=i;i1<N_window-1;i1++) {
Incremente(xip,yip,thetaip,vip,xi,yi,thetai,vi,Vu1[i1],Vu2[i1]);
xip=Inter(xip,Pi[i1+1][1]);yip=Inter(yip,Pi[i1+1][2]);
thetaip=Inter(thetaip,Pi[i1+1][3]);vip=Inter(vip,Pi[i1+1][4]);
xi=xip; yi=yip; thetai=thetaip; vi=vip;
}
box Pb(P);
Pb[1]=xi; Pb[2]=yi; Pb[3]=thetai; Pb[4]=vi;
L.push_back(Pb);
}
vector<box> Lv=L;
C_q_in(P,N_window-N_outliers,Lv);
return true;
}
void initialise() {
PI = Pi();
frameCap = 60;
inputCap = 60;
updateCap = 240;
play = false;
drawing = false;
verts = 50;
speed = 4;
circleColour = vec4(0.4, 0.3, 0.8, 1);
mark = Marker(vec4(0.0, 0.6, 0.8, 1));
glPointSize(10.0f);
float theta[NUMBER] = {1,2,3,4,0,0};
float radii[NUMBER] = {300,150,100,50,20,10};
float rates[NUMBER] = {1,2,3,4*PI,5,6};
initCircles(vec2(500,500),radii, rates, theta);
}
static environment mk_brec_on(environment const & env, name const & n, bool ind) {
if (!is_recursive_datatype(env, n))
return env;
if (is_inductive_predicate(env, n))
return env;
inductive::inductive_decls decls = *inductive::is_inductive_decl(env, n);
type_checker tc(env);
name_generator ngen;
unsigned nparams = std::get<1>(decls);
declaration ind_decl = env.get(n);
declaration rec_decl = env.get(inductive::get_elim_name(n));
// declaration below_decl = env.get(name(n, ind ? "ibelow" : "below"));
unsigned nindices = *inductive::get_num_indices(env, n);
unsigned nminors = *inductive::get_num_minor_premises(env, n);
unsigned ntypeformers = length(std::get<2>(decls));
level_param_names lps = rec_decl.get_univ_params();
bool is_reflexive = is_reflexive_datatype(tc, n);
level lvl = mk_param_univ(head(lps));
levels lvls = param_names_to_levels(tail(lps));
level rlvl;
level_param_names blps;
levels blvls; // universe level parameters of brec_on/binduction_on
// The arguments of brec_on (binduction_on) are the ones in the recursor - minor premises.
// The universe we map to is also different (l+1 for below of reflexive types) and (0 fo ibelow).
expr ref_type;
if (ind) {
// we are eliminating to Prop
blps = tail(lps);
blvls = lvls;
rlvl = mk_level_zero();
ref_type = instantiate_univ_param(rec_decl.get_type(), param_id(lvl), mk_level_zero());
} else if (is_reflexive) {
blps = lps;
blvls = cons(lvl, lvls);
rlvl = get_datatype_level(ind_decl.get_type());
// if rlvl is of the form (max 1 l), then rlvl <- l
if (is_max(rlvl) && is_one(max_lhs(rlvl)))
rlvl = max_rhs(rlvl);
rlvl = mk_max(mk_succ(lvl), rlvl);
// inner_prod, inner_prod_intro, pr1, pr2 do not use the same universe levels for
// reflective datatypes.
ref_type = instantiate_univ_param(rec_decl.get_type(), param_id(lvl), mk_succ(lvl));
} else {
// we can simplify the universe levels for non-reflexive datatypes
blps = lps;
blvls = cons(lvl, lvls);
rlvl = mk_max(mk_level_one(), lvl);
ref_type = rec_decl.get_type();
}
buffer<expr> ref_args;
to_telescope(ngen, ref_type, ref_args);
if (ref_args.size() != nparams + ntypeformers + nminors + nindices + 1)
throw_corrupted(n);
// args contains the brec_on/binduction_on arguments
buffer<expr> args;
buffer<name> typeformer_names;
// add parameters and typeformers
for (unsigned i = 0; i < nparams; i++)
args.push_back(ref_args[i]);
for (unsigned i = nparams; i < nparams + ntypeformers; i++) {
args.push_back(ref_args[i]);
typeformer_names.push_back(mlocal_name(ref_args[i]));
}
// add indices and major premise
for (unsigned i = nparams + ntypeformers + nminors; i < ref_args.size(); i++)
args.push_back(ref_args[i]);
// create below terms (one per datatype)
// (below.{lvls} params type-formers)
// Remark: it also creates the result type
buffer<expr> belows;
expr result_type;
unsigned k = 0;
for (auto const & decl : std::get<2>(decls)) {
name const & n1 = inductive::inductive_decl_name(decl);
if (n1 == n) {
result_type = ref_args[nparams + k];
for (unsigned i = nparams + ntypeformers + nminors; i < ref_args.size(); i++)
result_type = mk_app(result_type, ref_args[i]);
}
k++;
name bname = name(n1, ind ? "ibelow" : "below");
expr below = mk_constant(bname, blvls);
for (unsigned i = 0; i < nparams; i++)
below = mk_app(below, ref_args[i]);
for (unsigned i = nparams; i < nparams + ntypeformers; i++)
below = mk_app(below, ref_args[i]);
belows.push_back(below);
}
// create functionals (one for each type former)
// Pi idxs t, below idxs t -> C idxs t
buffer<expr> Fs;
name F_name("F");
for (unsigned i = nparams, j = 0; i < nparams + ntypeformers; i++, j++) {
expr const & C = ref_args[i];
buffer<expr> F_args;
to_telescope(ngen, mlocal_type(C), F_args);
expr F_result = mk_app(C, F_args);
expr F_below = mk_app(belows[j], F_args);
F_args.push_back(mk_local(ngen.next(), "f", F_below, binder_info()));
expr F_type = Pi(F_args, F_result);
expr F = mk_local(ngen.next(), F_name.append_after(j+1), F_type, binder_info());
Fs.push_back(F);
args.push_back(F);
}
// We define brec_on/binduction_on using the recursor for this type
levels rec_lvls = cons(rlvl, lvls);
expr rec = mk_constant(rec_decl.get_name(), rec_lvls);
// add parameters to rec
for (unsigned i = 0; i < nparams; i++)
rec = mk_app(rec, ref_args[i]);
// add type formers to rec
// Pi indices t, prod (C ... t) (below ... t)
for (unsigned i = nparams, j = 0; i < nparams + ntypeformers; i++, j++) {
expr const & C = ref_args[i];
buffer<expr> C_args;
to_telescope(ngen, mlocal_type(C), C_args);
expr C_t = mk_app(C, C_args);
expr below_t = mk_app(belows[j], C_args);
expr prod = mk_prod(tc, C_t, below_t, ind);
rec = mk_app(rec, Fun(C_args, prod));
}
// add minor premises to rec
for (unsigned i = nparams + ntypeformers, j = 0; i < nparams + ntypeformers + nminors; i++, j++) {
expr minor = ref_args[i];
expr minor_type = mlocal_type(minor);
buffer<expr> minor_args;
minor_type = to_telescope(ngen, minor_type, minor_args);
buffer<expr> pairs;
for (expr & minor_arg : minor_args) {
buffer<expr> minor_arg_args;
expr minor_arg_type = to_telescope(tc, mlocal_type(minor_arg), minor_arg_args);
if (auto k = is_typeformer_app(typeformer_names, minor_arg_type)) {
buffer<expr> C_args;
get_app_args(minor_arg_type, C_args);
expr new_minor_arg_type = mk_prod(tc, minor_arg_type, mk_app(belows[*k], C_args), ind);
minor_arg = update_mlocal(minor_arg, Pi(minor_arg_args, new_minor_arg_type));
if (minor_arg_args.empty()) {
pairs.push_back(minor_arg);
} else {
expr r = mk_app(minor_arg, minor_arg_args);
expr r_1 = Fun(minor_arg_args, mk_pr1(tc, r, ind));
expr r_2 = Fun(minor_arg_args, mk_pr2(tc, r, ind));
pairs.push_back(mk_pair(tc, r_1, r_2, ind));
}
}
}
expr b = foldr([&](expr const & a, expr const & b) { return mk_pair(tc, a, b, ind); },
[&]() { return mk_unit_mk(rlvl, ind); },
pairs.size(), pairs.data());
unsigned F_idx = *is_typeformer_app(typeformer_names, minor_type);
expr F = Fs[F_idx];
buffer<expr> F_args;
get_app_args(minor_type, F_args);
F_args.push_back(b);
expr new_arg = mk_pair(tc, mk_app(F, F_args), b, ind);
rec = mk_app(rec, Fun(minor_args, new_arg));
}
// add indices and major to rec
for (unsigned i = nparams + ntypeformers + nminors; i < ref_args.size(); i++)
rec = mk_app(rec, ref_args[i]);
name brec_on_name = name(n, ind ? "binduction_on" : "brec_on");
expr brec_on_type = Pi(args, result_type);
expr brec_on_value = Fun(args, mk_pr1(tc, rec, ind));
bool use_conv_opt = true;
declaration new_d = mk_definition(env, brec_on_name, blps, brec_on_type, brec_on_value,
use_conv_opt);
environment new_env = module::add(env, check(env, new_d));
new_env = set_reducible(new_env, brec_on_name, reducible_status::Reducible);
if (!ind)
new_env = add_unfold_hint(new_env, brec_on_name, nparams + nindices + ntypeformers);
return add_protected(new_env, brec_on_name);
}
static environment mk_below(environment const & env, name const & n, bool ibelow) {
if (!is_recursive_datatype(env, n))
return env;
if (is_inductive_predicate(env, n))
return env;
inductive::inductive_decls decls = *inductive::is_inductive_decl(env, n);
type_checker tc(env);
name_generator ngen;
unsigned nparams = std::get<1>(decls);
declaration ind_decl = env.get(n);
declaration rec_decl = env.get(inductive::get_elim_name(n));
unsigned nindices = *inductive::get_num_indices(env, n);
unsigned nminors = *inductive::get_num_minor_premises(env, n);
unsigned ntypeformers = length(std::get<2>(decls));
level_param_names lps = rec_decl.get_univ_params();
bool is_reflexive = is_reflexive_datatype(tc, n);
level lvl = mk_param_univ(head(lps));
levels lvls = param_names_to_levels(tail(lps));
level_param_names blvls; // universe level parameters of ibelow/below
level rlvl; // universe level of the resultant type
// The arguments of below (ibelow) are the ones in the recursor - minor premises.
// The universe we map to is also different (l+1 for below of reflexive types) and (0 fo ibelow).
expr ref_type;
expr Type_result;
if (ibelow) {
// we are eliminating to Prop
blvls = tail(lps);
rlvl = mk_level_zero();
ref_type = instantiate_univ_param(rec_decl.get_type(), param_id(lvl), mk_level_zero());
} else if (is_reflexive) {
blvls = lps;
rlvl = get_datatype_level(ind_decl.get_type());
// if rlvl is of the form (max 1 l), then rlvl <- l
if (is_max(rlvl) && is_one(max_lhs(rlvl)))
rlvl = max_rhs(rlvl);
rlvl = mk_max(mk_succ(lvl), rlvl);
ref_type = instantiate_univ_param(rec_decl.get_type(), param_id(lvl), mk_succ(lvl));
} else {
// we can simplify the universe levels for non-reflexive datatypes
blvls = lps;
rlvl = mk_max(mk_level_one(), lvl);
ref_type = rec_decl.get_type();
}
Type_result = mk_sort(rlvl);
buffer<expr> ref_args;
to_telescope(ngen, ref_type, ref_args);
if (ref_args.size() != nparams + ntypeformers + nminors + nindices + 1)
throw_corrupted(n);
// args contains the below/ibelow arguments
buffer<expr> args;
buffer<name> typeformer_names;
// add parameters and typeformers
for (unsigned i = 0; i < nparams; i++)
args.push_back(ref_args[i]);
for (unsigned i = nparams; i < nparams + ntypeformers; i++) {
args.push_back(ref_args[i]);
typeformer_names.push_back(mlocal_name(ref_args[i]));
}
// we ignore minor premises in below/ibelow
for (unsigned i = nparams + ntypeformers + nminors; i < ref_args.size(); i++)
args.push_back(ref_args[i]);
// We define below/ibelow using the recursor for this type
levels rec_lvls = cons(mk_succ(rlvl), lvls);
expr rec = mk_constant(rec_decl.get_name(), rec_lvls);
for (unsigned i = 0; i < nparams; i++)
rec = mk_app(rec, args[i]);
// add type formers
for (unsigned i = nparams; i < nparams + ntypeformers; i++) {
buffer<expr> targs;
to_telescope(ngen, mlocal_type(args[i]), targs);
rec = mk_app(rec, Fun(targs, Type_result));
}
// add minor premises
for (unsigned i = nparams + ntypeformers; i < nparams + ntypeformers + nminors; i++) {
expr minor = ref_args[i];
expr minor_type = mlocal_type(minor);
buffer<expr> minor_args;
minor_type = to_telescope(ngen, minor_type, minor_args);
buffer<expr> prod_pairs;
for (expr & minor_arg : minor_args) {
buffer<expr> minor_arg_args;
expr minor_arg_type = to_telescope(tc, mlocal_type(minor_arg), minor_arg_args);
if (is_typeformer_app(typeformer_names, minor_arg_type)) {
expr fst = mlocal_type(minor_arg);
minor_arg = update_mlocal(minor_arg, Pi(minor_arg_args, Type_result));
expr snd = Pi(minor_arg_args, mk_app(minor_arg, minor_arg_args));
prod_pairs.push_back(mk_prod(tc, fst, snd, ibelow));
}
}
expr new_arg = foldr([&](expr const & a, expr const & b) { return mk_prod(tc, a, b, ibelow); },
[&]() { return mk_unit(rlvl, ibelow); },
prod_pairs.size(), prod_pairs.data());
rec = mk_app(rec, Fun(minor_args, new_arg));
}
// add indices and major premise
for (unsigned i = nparams + ntypeformers; i < args.size(); i++) {
rec = mk_app(rec, args[i]);
}
name below_name = ibelow ? name{n, "ibelow"} : name{n, "below"};
expr below_type = Pi(args, Type_result);
expr below_value = Fun(args, rec);
bool use_conv_opt = true;
declaration new_d = mk_definition(env, below_name, blvls, below_type, below_value,
use_conv_opt);
environment new_env = module::add(env, check(env, new_d));
new_env = set_reducible(new_env, below_name, reducible_status::Reducible);
if (!ibelow)
new_env = add_unfold_hint(new_env, below_name, nparams + nindices + ntypeformers);
return add_protected(new_env, below_name);
}
list<expr_pair> lift(expr const & local, list<expr_pair> const & l) {
lean_assert(is_local(local));
return map(l, [&](expr_pair const & e_H) {
return mk_pair(Pi(local, e_H.first), Fun(local, e_H.second));
});
}
expr goal::mk_meta(name const & n, expr const & type) const {
buffer<expr> locals;
expr this_mvar = get_app_args(m_meta, locals);
expr mvar = copy_tag(this_mvar, mk_metavar(n, Pi(locals, type)));
return copy_tag(m_meta, mk_app(mvar, locals));
}
static int PiN(void *u, const XMLCH *t, const XMLCH *d)
{ return Pi(R3AD3R,t,d); }
int main() {
Pi(100000000);
return 0;
}
constexpr float
ToDegrees(angle Angle)
{
return { Angle.InternalData * (180.0f / Pi()) };
}
constexpr angle
Degrees(float DegreesValue)
{
return { DegreesValue * (Pi() / 180.0f) };
}
environment mk_projections(environment const & env, name const & n, buffer<name> const & proj_names,
implicit_infer_kind infer_k, bool inst_implicit) {
// Given an inductive datatype C A (where A represent parameters)
// intro : Pi A (x_1 : B_1[A]) (x_2 : B_2[A, x_1]) ..., C A
//
// we generate projections of the form
// proj_i A (c : C A) : B_i[A, (proj_1 A n), ..., (proj_{i-1} A n)]
// C.rec A (fun (x : C A), B_i[A, ...]) (fun (x_1 ... x_n), x_i) c
auto p = get_nparam_intro_rule(env, n);
name_generator ngen;
unsigned nparams = p.first;
inductive::intro_rule intro = p.second;
expr intro_type = inductive::intro_rule_type(intro);
name rec_name = inductive::get_elim_name(n);
declaration ind_decl = env.get(n);
if (env.impredicative() && is_prop(ind_decl.get_type()))
throw exception(sstream() << "projection generation, '" << n << "' is a proposition");
declaration rec_decl = env.get(rec_name);
level_param_names lvl_params = ind_decl.get_univ_params();
levels lvls = param_names_to_levels(lvl_params);
buffer<expr> params; // datatype parameters
for (unsigned i = 0; i < nparams; i++) {
if (!is_pi(intro_type))
throw_ill_formed(n);
expr param = mk_local(ngen.next(), binding_name(intro_type), binding_domain(intro_type), binder_info());
intro_type = instantiate(binding_body(intro_type), param);
params.push_back(param);
}
expr C_A = mk_app(mk_constant(n, lvls), params);
binder_info c_bi = inst_implicit ? mk_inst_implicit_binder_info() : binder_info();
expr c = mk_local(ngen.next(), name("c"), C_A, c_bi);
buffer<expr> intro_type_args; // arguments that are not parameters
expr it = intro_type;
while (is_pi(it)) {
expr local = mk_local(ngen.next(), binding_name(it), binding_domain(it), binding_info(it));
intro_type_args.push_back(local);
it = instantiate(binding_body(it), local);
}
buffer<expr> projs; // projections generated so far
unsigned i = 0;
environment new_env = env;
for (name const & proj_name : proj_names) {
if (!is_pi(intro_type))
throw exception(sstream() << "generating projection '" << proj_name << "', '"
<< n << "' does not have sufficient data");
expr result_type = binding_domain(intro_type);
buffer<expr> proj_args;
proj_args.append(params);
proj_args.push_back(c);
expr type_former = Fun(c, result_type);
expr minor_premise = Fun(intro_type_args, mk_var(intro_type_args.size() - i - 1));
expr major_premise = c;
type_checker tc(new_env);
level l = sort_level(tc.ensure_sort(tc.infer(result_type).first).first);
levels rec_lvls = append(to_list(l), lvls);
expr rec = mk_constant(rec_name, rec_lvls);
buffer<expr> rec_args;
rec_args.append(params);
rec_args.push_back(type_former);
rec_args.push_back(minor_premise);
rec_args.push_back(major_premise);
expr rec_app = mk_app(rec, rec_args);
expr proj_type = Pi(proj_args, result_type);
proj_type = infer_implicit_params(proj_type, nparams, infer_k);
expr proj_val = Fun(proj_args, rec_app);
bool opaque = false;
bool use_conv_opt = false;
declaration new_d = mk_definition(env, proj_name, lvl_params, proj_type, proj_val,
opaque, rec_decl.get_module_idx(), use_conv_opt);
new_env = module::add(new_env, check(new_env, new_d));
new_env = set_reducible(new_env, proj_name, reducible_status::Reducible);
new_env = add_unfold_c_hint(new_env, proj_name, nparams);
new_env = save_projection_info(new_env, proj_name, inductive::intro_rule_name(intro), nparams, i, inst_implicit);
expr proj = mk_app(mk_app(mk_constant(proj_name, lvls), params), c);
intro_type = instantiate(binding_body(intro_type), proj);
i++;
}
return new_env;
}
optional<environment> mk_no_confusion_type(environment const & env, name const & n) {
optional<inductive::inductive_decls> decls = inductive::is_inductive_decl(env, n);
if (!decls)
throw exception(sstream() << "error in 'no_confusion' generation, '" << n << "' is not an inductive datatype");
if (is_inductive_predicate(env, n))
return optional<environment>(); // type is a proposition
name_generator ngen;
unsigned nparams = std::get<1>(*decls);
declaration ind_decl = env.get(n);
declaration cases_decl = env.get(name(n, "cases_on"));
level_param_names lps = cases_decl.get_univ_params();
level rlvl = mk_param_univ(head(lps));
levels ilvls = param_names_to_levels(tail(lps));
if (length(ilvls) != length(ind_decl.get_univ_params()))
return optional<environment>(); // type does not have only a restricted eliminator
expr ind_type = instantiate_type_univ_params(ind_decl, ilvls);
name eq_name("eq");
name heq_name("heq");
// All inductive datatype parameters and indices are arguments
buffer<expr> args;
ind_type = to_telescope(ngen, ind_type, args, some(mk_implicit_binder_info()));
if (!is_sort(ind_type) || args.size() < nparams)
throw_corrupted(n);
lean_assert(!(env.impredicative() && is_zero(sort_level(ind_type))));
unsigned nindices = args.size() - nparams;
// Create inductive datatype
expr I = mk_app(mk_constant(n, ilvls), args);
// Add (P : Type)
expr P = mk_local(ngen.next(), "P", mk_sort(rlvl), binder_info());
args.push_back(P);
// add v1 and v2 elements of the inductive type
expr v1 = mk_local(ngen.next(), "v1", I, binder_info());
expr v2 = mk_local(ngen.next(), "v2", I, binder_info());
args.push_back(v1);
args.push_back(v2);
expr R = mk_sort(rlvl);
name no_confusion_type_name{n, "no_confusion_type"};
expr no_confusion_type_type = Pi(args, R);
// Create type former
buffer<expr> type_former_args;
for (unsigned i = nparams; i < nparams + nindices; i++)
type_former_args.push_back(args[i]);
type_former_args.push_back(v1);
expr type_former = Fun(type_former_args, R);
// Create cases_on
levels clvls = levels(mk_succ(rlvl), ilvls);
expr cases_on = mk_app(mk_app(mk_constant(cases_decl.get_name(), clvls), nparams, args.data()), type_former);
cases_on = mk_app(cases_on, nindices, args.data() + nparams);
expr cases_on1 = mk_app(cases_on, v1);
expr cases_on2 = mk_app(cases_on, v2);
type_checker tc(env);
expr t1 = tc.infer(cases_on1).first;
expr t2 = tc.infer(cases_on2).first;
buffer<expr> outer_cases_on_args;
unsigned idx1 = 0;
while (is_pi(t1)) {
buffer<expr> minor1_args;
expr minor1 = to_telescope(tc, binding_domain(t1), minor1_args);
expr curr_t2 = t2;
buffer<expr> inner_cases_on_args;
unsigned idx2 = 0;
while (is_pi(curr_t2)) {
buffer<expr> minor2_args;
expr minor2 = to_telescope(tc, binding_domain(curr_t2), minor2_args);
if (idx1 != idx2) {
// infeasible case, constructors do not match
inner_cases_on_args.push_back(Fun(minor2_args, P));
} else {
if (minor1_args.size() != minor2_args.size())
throw_corrupted(n);
buffer<expr> rtype_hyp;
// add equalities
for (unsigned i = 0; i < minor1_args.size(); i++) {
expr lhs = minor1_args[i];
expr rhs = minor2_args[i];
expr lhs_type = mlocal_type(lhs);
expr rhs_type = mlocal_type(rhs);
level l = sort_level(tc.ensure_type(lhs_type).first);
expr h_type;
if (tc.is_def_eq(lhs_type, rhs_type).first) {
h_type = mk_app(mk_constant(eq_name, to_list(l)), lhs_type, lhs, rhs);
} else {
h_type = mk_app(mk_constant(heq_name, to_list(l)), lhs_type, lhs, rhs_type, rhs);
}
rtype_hyp.push_back(mk_local(ngen.next(), local_pp_name(lhs).append_after("_eq"), h_type, binder_info()));
}
inner_cases_on_args.push_back(Fun(minor2_args, mk_arrow(Pi(rtype_hyp, P), P)));
}
idx2++;
curr_t2 = binding_body(curr_t2);
}
outer_cases_on_args.push_back(Fun(minor1_args, mk_app(cases_on2, inner_cases_on_args)));
idx1++;
t1 = binding_body(t1);
}
expr no_confusion_type_value = Fun(args, mk_app(cases_on1, outer_cases_on_args));
bool opaque = false;
bool use_conv_opt = true;
declaration new_d = mk_definition(env, no_confusion_type_name, lps, no_confusion_type_type, no_confusion_type_value,
opaque, ind_decl.get_module_idx(), use_conv_opt);
environment new_env = module::add(env, check(env, new_d));
return some(add_protected(new_env, no_confusion_type_name));
}
SoS_primitive_result* sos_lambda5 (int i, int j, int k, int l, int m)
/* Returns significant term of Lambda5 epsilon-determinant.
Assumes indices in proper range, pairwise different, and sorted. */
{
#ifdef __DEBUG__
if (sos_proto_e_flag)
{
lia_clear ();
print ("sos_lambda5 (%d,%d,%d,%d,%d)", i, j, k, l, m);
print (" (");
print ("%s,%s,%s,%s,1;", Pi(i,1), Pi(i,2), Pi(i,3), Pi(i,4));
print ("%s,%s,%s,%s,1;", Pi(j,1), Pi(j,2), Pi(j,3), Pi(j,4));
print ("%s,%s,%s,%s,1;", Pi(k,1), Pi(k,2), Pi(k,3), Pi(k,4));
print ("%s,%s,%s,%s,1;", Pi(l,1), Pi(l,2), Pi(l,3), Pi(l,4));
print ("%s,%s,%s,%s,1;", Pi(m,1), Pi(m,2), Pi(m,3), Pi(m,4));
print (")\n");
}
#endif
/* C code generated by 'ccode' from 'gee' file "Lambda5.out" */
Initialize ();
Epsilon_Term (0);
Positive_Coefficient (Minor5 (i, j, k, l, m, 1, 2, 3, 4, 0));
Epsilon_Term (1);
Epsilon (i,4);
Negative_Coefficient (Minor4 (j, k, l, m, 1, 2, 3, 0));
Epsilon_Term (2);
Epsilon (i,3);
Positive_Coefficient (Minor4 (j, k, l, m, 1, 2, 4, 0));
Epsilon_Term (3);
Epsilon (i,2);
Negative_Coefficient (Minor4 (j, k, l, m, 1, 3, 4, 0));
Epsilon_Term (4);
Epsilon (i,1);
Positive_Coefficient (Minor4 (j, k, l, m, 2, 3, 4, 0));
Epsilon_Term (5);
Epsilon (j,4);
Positive_Coefficient (Minor4 (i, k, l, m, 1, 2, 3, 0));
Epsilon_Term (6);
Epsilon (j,4);
Epsilon (i,3);
Positive_Coefficient (Minor3 (k, l, m, 1, 2, 0));
Epsilon_Term (7);
Epsilon (j,4);
Epsilon (i,2);
Negative_Coefficient (Minor3 (k, l, m, 1, 3, 0));
Epsilon_Term (8);
Epsilon (j,4);
Epsilon (i,1);
Positive_Coefficient (Minor3 (k, l, m, 2, 3, 0));
Epsilon_Term (9);
Epsilon (j,3);
Negative_Coefficient (Minor4 (i, k, l, m, 1, 2, 4, 0));
Epsilon_Term (10);
Epsilon (j,3);
Epsilon (i,2);
Positive_Coefficient (Minor3 (k, l, m, 1, 4, 0));
Epsilon_Term (11);
Epsilon (j,3);
Epsilon (i,1);
Negative_Coefficient (Minor3 (k, l, m, 2, 4, 0));
Epsilon_Term (12);
Epsilon (j,2);
Positive_Coefficient (Minor4 (i, k, l, m, 1, 3, 4, 0));
Epsilon_Term (13);
Epsilon (j,2);
Epsilon (i,1);
Positive_Coefficient (Minor3 (k, l, m, 3, 4, 0));
Epsilon_Term (14);
Epsilon (j,1);
Negative_Coefficient (Minor4 (i, k, l, m, 2, 3, 4, 0));
Epsilon_Term (15);
Epsilon (k,4);
Negative_Coefficient (Minor4 (i, j, l, m, 1, 2, 3, 0));
Epsilon_Term (16);
Epsilon (k,4);
Epsilon (i,3);
Negative_Coefficient (Minor3 (j, l, m, 1, 2, 0));
Epsilon_Term (17);
Epsilon (k,4);
Epsilon (i,2);
Positive_Coefficient (Minor3 (j, l, m, 1, 3, 0));
Epsilon_Term (18);
Epsilon (k,4);
Epsilon (i,1);
Negative_Coefficient (Minor3 (j, l, m, 2, 3, 0));
Epsilon_Term (19);
Epsilon (k,4);
Epsilon (j,3);
Positive_Coefficient (Minor3 (i, l, m, 1, 2, 0));
Epsilon_Term (20);
Epsilon (k,4);
Epsilon (j,3);
Epsilon (i,2);
Negative_Coefficient (Minor2 (l, m, 1, 0));
Epsilon_Term (21);
Epsilon (k,4);
Epsilon (j,3);
Epsilon (i,1);
Positive_Coefficient (Minor2 (l, m, 2, 0));
Epsilon_Term (22);
Epsilon (k,4);
Epsilon (j,2);
Negative_Coefficient (Minor3 (i, l, m, 1, 3, 0));
Epsilon_Term (23);
Epsilon (k,4);
Epsilon (j,2);
Epsilon (i,1);
Negative_Coefficient (Minor2 (l, m, 3, 0));
Epsilon_Term (24);
Epsilon (k,4);
Epsilon (j,1);
Positive_Coefficient (Minor3 (i, l, m, 2, 3, 0));
Epsilon_Term (25);
Epsilon (k,3);
Positive_Coefficient (Minor4 (i, j, l, m, 1, 2, 4, 0));
Epsilon_Term (26);
Epsilon (k,3);
Epsilon (i,2);
Negative_Coefficient (Minor3 (j, l, m, 1, 4, 0));
Epsilon_Term (27);
Epsilon (k,3);
Epsilon (i,1);
Positive_Coefficient (Minor3 (j, l, m, 2, 4, 0));
Epsilon_Term (28);
Epsilon (k,3);
Epsilon (j,2);
Positive_Coefficient (Minor3 (i, l, m, 1, 4, 0));
Epsilon_Term (29);
Epsilon (k,3);
Epsilon (j,2);
Epsilon (i,1);
Positive_Coefficient (Minor2 (l, m, 4, 0));
Epsilon_Term (30);
Epsilon (k,3);
Epsilon (j,1);
Negative_Coefficient (Minor3 (i, l, m, 2, 4, 0));
Epsilon_Term (31);
Epsilon (k,2);
Negative_Coefficient (Minor4 (i, j, l, m, 1, 3, 4, 0));
Epsilon_Term (32);
Epsilon (k,2);
Epsilon (i,1);
Negative_Coefficient (Minor3 (j, l, m, 3, 4, 0));
Epsilon_Term (33);
Epsilon (k,2);
Epsilon (j,1);
Positive_Coefficient (Minor3 (i, l, m, 3, 4, 0));
Epsilon_Term (34);
Epsilon (k,1);
Positive_Coefficient (Minor4 (i, j, l, m, 2, 3, 4, 0));
Epsilon_Term (35);
Epsilon (l,4);
Positive_Coefficient (Minor4 (i, j, k, m, 1, 2, 3, 0));
Epsilon_Term (36);
Epsilon (l,4);
Epsilon (i,3);
Positive_Coefficient (Minor3 (j, k, m, 1, 2, 0));
Epsilon_Term (37);
Epsilon (l,4);
Epsilon (i,2);
Negative_Coefficient (Minor3 (j, k, m, 1, 3, 0));
Epsilon_Term (38);
Epsilon (l,4);
Epsilon (i,1);
Positive_Coefficient (Minor3 (j, k, m, 2, 3, 0));
Epsilon_Term (39);
Epsilon (l,4);
Epsilon (j,3);
Negative_Coefficient (Minor3 (i, k, m, 1, 2, 0));
Epsilon_Term (40);
Epsilon (l,4);
Epsilon (j,3);
Epsilon (i,2);
Positive_Coefficient (Minor2 (k, m, 1, 0));
Epsilon_Term (41);
Epsilon (l,4);
Epsilon (j,3);
Epsilon (i,1);
Negative_Coefficient (Minor2 (k, m, 2, 0));
Epsilon_Term (42);
Epsilon (l,4);
Epsilon (j,2);
Positive_Coefficient (Minor3 (i, k, m, 1, 3, 0));
Epsilon_Term (43);
Epsilon (l,4);
Epsilon (j,2);
Epsilon (i,1);
Positive_Coefficient (Minor2 (k, m, 3, 0));
Epsilon_Term (44);
Epsilon (l,4);
Epsilon (j,1);
Negative_Coefficient (Minor3 (i, k, m, 2, 3, 0));
Epsilon_Term (45);
Epsilon (l,4);
Epsilon (k,3);
Positive_Coefficient (Minor3 (i, j, m, 1, 2, 0));
Epsilon_Term (46);
Epsilon (l,4);
Epsilon (k,3);
Epsilon (i,2);
Negative_Coefficient (Minor2 (j, m, 1, 0));
Epsilon_Term (47);
Epsilon (l,4);
Epsilon (k,3);
Epsilon (i,1);
Positive_Coefficient (Minor2 (j, m, 2, 0));
Epsilon_Term (48);
Epsilon (l,4);
Epsilon (k,3);
Epsilon (j,2);
Positive_Coefficient (Minor2 (i, m, 1, 0));
Epsilon_Term (49);
Epsilon (l,4);
Epsilon (k,3);
Epsilon (j,2);
Epsilon (i,1);
Coefficient (Integer (1));
Finish ();
}
