Sindbad~EG File Manager

/* M. Beeson for MathXpert
   inequality operators for the recip_ineq menus
*/
/*
Original date 6.28.96
Last modified 1.22.98
*/


#include <string.h>
#include <assert.h>
#include <search.h>
#include "globals.h"
#include "ops.h"
#include "pvalaux.h"  /* obviously_positive */
#include "errbuf.h"   /* errbuf             */
#include "prover.h"   /* interval_as_and    */
#include "eqn.h"      /* econstant          */
/*_______________________________________________________________*/
int recipineq11(term t, term arg, term *next, char *reason)
/* 1/x < a iff x<0 or 1/a < x provided a > 0 */
{ unsigned short f = FUNCTOR(t);
  term left,right,x,u;
  int err,sflag;
  if(f != '<' && f != '>' && f != LE && f != GE)
     return 1;
  if(f == '<' || f == LE)
     { left = ARG(0,t);
       right = ARG(1,t);
       sflag = 1;
     }
  else
     { left = ARG(1,t);
       right = ARG(0,t);
       sflag = 0;
     }
  if(!FRACTION(left) ||
     !econstant(ARG(0,left)) ||
     econstant(ARG(1,left)) ||
     !obviously_positive(ARG(0,left))
    )
     return 1;
  err = infer(lessthan(zero,right));
  if(err)
     { errbuf(0, english(sflag ? 1560 : 1616));
                /* Right side must be positive. */
                /* Left side must be positive.  */
       return 1;
     }
  x = reciprocal(left);
  u = sflag ? lessthan(reciprocal(right),x): greaterthan(x,reciprocal(right));
  strcpy(reason, english(1617));  /* take reciprocals */
  err = infer(le(zero,x));
  if(!err)
     { *next = u;
       HIGHLIGHT(*next);
       strcpy(reason, english(1617));  /* take reciprocals */
       return 0;
     }
  *next = or(lessthan(x,zero),u);
  HIGHLIGHT(*next);
  return 0;
}
/*_______________________________________________________________*/
int recipineq12(term t, term arg, term *next, char *reason)
/* 1/x  \le  a iff x<0 or 1/a  \le  x provided a > 0 */
{ return recipineq11(t,arg,next,reason);
}

/*_______________________________________________________________*/
int recipineq21(term t, term arg, term *next, char *reason)
/* a < 1/x iff 0 < x < 1/a provided a > 0 */
{ unsigned short f = FUNCTOR(t);
  term left,right,x,u;
  int err,sflag;
  if(f != '<' && f != '>' && f != LE && f != GE)
     return 1;
  if(f == '<' || f == LE)
     { left = ARG(0,t);
       right = ARG(1,t);
       sflag = 1;
     }
  else
     { left = ARG(1,t);
       right = ARG(0,t);
       sflag = 0;
     }
  if(!FRACTION(right) ||
     !econstant(ARG(0,right)) ||
     econstant(ARG(1,right)) ||
     !obviously_positive(ARG(0,right))
    )
     return 1;
  x = reciprocal(right);
  err = infer(lessthan(zero,left));
  if(err)
     { errbuf(0, english(sflag ? 1616: 1560));
                /* Left side must be positive.  */
                /* Right side must be positive. */
       return 1;
     }
  copy(x,&u);  /* avoid DAGs */
  *next = and(lessthan(zero,u),lessthan(x,reciprocal(left)));
  HIGHLIGHT(*next);
  strcpy(reason,english(1617));  /* take reciprocals */
  return 0;
}
/*_______________________________________________________________*/
int recipineq22(term t, term arg, term *next, char *reason)
/* a  \le  1/x iff 0 < x  \le  1/a provided a > 0 */
{ return recipineq21(t,arg,next,reason);
}

/*_______________________________________________________________*/
int recipineq31(term t, term arg, term *next, char *reason)
/* 1/x < -a iff -1/a < x < 0 provided a > 0 */
{ unsigned short f = FUNCTOR(t);
  term left,right,x,u,a;
  int err,sflag;
  if(f != '<' && f != '>' && f != LE && f != GE)
     return 1;
  if(f == '<' || f == LE)
     { left = ARG(0,t);
       right = ARG(1,t);
       sflag = 1;
     }
  else
     { left = ARG(1,t);
       right = ARG(0,t);
       sflag = 0;
     }
  if(!FRACTION(left) ||
     !econstant(ARG(0,left)) ||
     econstant(ARG(1,left)) ||
     !obviously_positive(ARG(0,left))
    )
     return 1;
  x = reciprocal(left);
  a = strongnegate(right);
  err = infer(lessthan(zero,a));
  if(err)
     { errbuf(0,english(1618));  /* Right side must be negative. */
       return 1;
     }
  copy(x,&u);  /* avoid DAGs */
  if(sflag)
     *next = and(lessthan(tnegate(reciprocal(a)),u),lessthan(x,zero));
  else
     *next = and(le(tnegate(reciprocal(a)),u),lessthan(x,zero));
  HIGHLIGHT(*next);
  strcpy(reason,english(1617));  /* take reciprocals */
  return 0;
}
/*_______________________________________________________________*/
int recipineq32(term t, term arg, term *next, char *reason)
/* 1/x  \le  -a iff -1/a  \le  x < 0 provided a > 0 */
{ return recipineq31(t,arg,next,reason);
}

/*_______________________________________________________________*/
int recipineq41(term t, term arg, term *next, char *reason)
/* -a < 1/x iff x < -1/a or 0 < x provided a > 0 */
{ unsigned short f = FUNCTOR(t);
  term left,right,x,u,a;
  int err,sflag;
  if(f != '<' && f != '>' && f != LE && f != GE)
     return 1;
  if(f == '<' || f == LE)
     { left = ARG(0,t);
       right = ARG(1,t);
       sflag = 1;
     }
  else
     { left = ARG(1,t);
       right = ARG(0,t);
       sflag = 0;
     }
  if(!FRACTION(right) ||
     !econstant(ARG(0,right)) ||
     econstant(ARG(1,right)) ||
     !obviously_positive(ARG(0,right))
    )
     return 1;
  a = strongnegate(left);
  err = infer(lessthan(zero,a));
  if(err)
     { errbuf(0,english(1596));  /* Left side must be negative. */
       return 1;
     }
  x = reciprocal(right);
  copy(x,&u);  /* avoid DAGs */
  if(sflag)
     *next = or(lessthan(x,tnegate(reciprocal(a))),lessthan(zero,u));
  else
     *next = or(le(x,tnegate(reciprocal(a))),lessthan(zero,u));
  HIGHLIGHT(*next);
  strcpy(reason,english(1617));  /* take reciprocals */
  return 0;
}
/*_______________________________________________________________*/
int recipineq42(term t, term arg, term *next, char *reason)
/* -a  \le  1/x iff x  \le  -1/a or 0 < x provided a > 0 */
{ return recipineq41(t,arg,next,reason);
}

/*_______________________________________________________________*/
int recipinterval11(term t, term arg, term *next, char *reason)
/* a < 1/x < b iff 1/b < x < 1/a provided a,b > 0 */
{ unsigned short f,g;
  term left,right,mid,x,u,a,b;
  int err;
  if(!interval_as_and(t))
     return 1;
  a = ARG(0,ARG(0,t));
  b = ARG(1,ARG(1,t));
  mid = ARG(1,ARG(0,t));
  if(!FRACTION(mid) || !econstant(ARG(0,mid)) || econstant(ARG(1,mid)))
     return 1;
  x = reciprocal(ARG(1,ARG(0,t)));
  err = infer(lessthan(zero,a));
  if(err)
     { errbuf(0,english(1616)); /* Left side must be positive */
       return 1;
     }
  copy(x,&u);
  f = FUNCTOR(ARG(0,t));
  g = FUNCTOR(ARG(1,t));
  left = g == '<' ? lessthan(reciprocal(b),x) : le(reciprocal(b),x);
  right = f == '<' ? lessthan(u,reciprocal(a)) : le(u,reciprocal(a));
  *next = and(left,right);
  HIGHLIGHT(*next);
  strcpy(reason,english(1617));  /* take reciprocals */
  return 0;
}
/*_______________________________________________________________*/
int recipinterval21(term t, term arg, term *next, char *reason)
/* a < 1/x  \le  b iff 1/b  \le  x < 1/a provided a,b > 0 */
{ return recipinterval11(t,arg,next,reason);
}
/*_______________________________________________________________*/
int recipinterval12(term t, term arg, term *next, char *reason)
/* a  \le  1/x < b iff 1/b < x  \le  1/a provided a,b > 0 */
{ return recipinterval11(t,arg,next,reason);
}
/*_______________________________________________________________*/
int recipinterval22(term t, term arg, term *next, char *reason)
/* a  \le  1/x  \le  b iff 1/b  \le  x < 1/a provided a,b > 0 */
{ return recipinterval11(t,arg,next,reason);
}
/*_______________________________________________________________*/
int recipinterval31(term t, term arg, term *next, char *reason)
/* -a < 1/x < -b iff -1/b < x < -1/a provided a,b > 0 */
{ unsigned short f,g;
  term left,right,mid,x,u,a,b;
  int err;
  if(!interval_as_and(t))
     return 1;
  b = tnegate(ARG(1,ARG(1,t)));
  a = tnegate(ARG(0,ARG(0,t)));
  mid = ARG(1,ARG(0,t));
  if(!FRACTION(mid) || !econstant(ARG(0,mid)) || econstant(ARG(1,mid)))
     return 1;
  x = reciprocal(ARG(1,ARG(0,t)));
  err = infer(lessthan(zero,b));
  if(err)
     { errbuf(0,english(1618));
       /* Right side must be negative */
       return 1;
     }
  copy(x,&u);
  f = FUNCTOR(ARG(0,t));
  g = FUNCTOR(ARG(1,t));
  left = g == '<' ? lessthan(tnegate(reciprocal(b)),x) : le(tnegate(reciprocal(b)),x);
  right = f == '<' ? lessthan(u,tnegate(reciprocal(a))): le(u,tnegate(reciprocal(a)));
  *next = and(left,right);
  HIGHLIGHT(*next);
  strcpy(reason, english(1617));  /* take reciprocals */
  return 0;
}
/*_______________________________________________________________*/
int recipinterval41(term t, term arg, term *next, char *reason)
/* -a < 1/x  \le  -b iff -1/b  \le  x < -1/a provided a,b > 0 */
{ return recipinterval31(t,arg,next,reason);
}
/*_______________________________________________________________*/
int recipinterval32(term t, term arg, term *next, char *reason)
/* -a  \le  1/x < -b iff -1/b < x  \le  -1/a provided a,b > 0 */
{ return recipinterval31(t,arg,next,reason);
}
/*_______________________________________________________________*/
int recipinterval42(term t, term arg, term *next, char *reason)
/* -a  \le  1/x  \le  -b iff -1/b  \le  x  \le  -1/a provided a,b > 0 */
{ return recipinterval31(t,arg,next,reason);
}
/*_______________________________________________________________*/
int recipinterval51(term t, term arg, term *next, char *reason)
/* -a < 1/x < b iff x < - 1/a or 1/b < x (a,b > 0) */
{ unsigned short f,g;
  term left,right,mid,x,u,a,b;
  int err;
  if(!interval_as_and(t))
     return 1;
  a = strongnegate(ARG(0,ARG(0,t)));
  b = ARG(1,ARG(1,t));
  mid = ARG(1,ARG(0,t));
  if(!FRACTION(mid) || !econstant(ARG(0,mid)) || econstant(ARG(1,mid)))
     return 1;
  x = reciprocal(mid);
  err = infer(lessthan(zero,a));
  if(err)
     { errbuf(0,english(1596)); /* Left side must be negative */
       return 1;
     }
  err = infer(lessthan(zero,b));
  if(err)
     { errbuf(0,english(1560)); /* Right side must be positive */
       return 1;
     }
  copy(x,&u);
  f = FUNCTOR(ARG(0,t));
  g = FUNCTOR(ARG(1,t));
  left = f == '<' ? lessthan(x,tnegate(reciprocal(a))) : le(x,tnegate(reciprocal(a)));
  right = g == '<' ? lessthan(reciprocal(b),u) : le(reciprocal(b),u);
  *next = or(left,right);
  HIGHLIGHT(*next);
  strcpy(reason,english(1617));  /* take reciprocals */
  return 0;
}
/*_______________________________________________________________*/
int recipinterval61(term t, term arg, term *next, char *reason)
/* -a < 1/x  \le  b iff x < -1/a or 1/b  \le  x (a,b > 0) */
{ return recipinterval51(t,arg,next,reason);
}
/*_______________________________________________________________*/
int recipinterval52(term t, term arg, term *next, char *reason)
/* -a  \le  1/x < b iff x  \le  - 1/a or 1/b < x (a,b > 0) */
{ return recipinterval51(t,arg,next,reason);
}
/*_______________________________________________________________*/
int recipinterval62(term t, term arg, term *next, char *reason)
/* -a  \le  1/x  \le  b iff x  \le  -1/a or 1/b  \le  x (a,b > 0) */
{ return recipinterval51(t,arg,next,reason);
}