Nuprl Definition : find-approx-fp

find-approx-fp(n;f;e) ==
  if n=0
  then <Ax, Ax>
  else let k = mu-ge(λm.(unit-ball-ex-decider(m;n) 
                         (λq.case isr(rless-case((r(2) * e/r(3));e;(((rlessw(((r(2) * e/r(3)) * r(3)) * rinv(r(3));(e
                                  * r(3))
                                  * rinv(r(3)))
                                  * 20)
                                  + 1)
                                  * 20)
                                  + 1;d(f 
                                        (λi.eval k = m in
                                            λn.if (k) < (0)
                                                  then -((r(q i) (2 * n)) ÷ (-2) * k)
                                                  else ((r(q i) (2 * n)) ÷ 2 * k));λi.eval k = m in
                                                                                      λn.if (k) < (0)
                                                                                            then -((r(q i) 
                                                                                                    (2 * n)) ÷ (-2) * k)
                                                                                            else ((r(q i) (2 * n)) ÷ 2
                                                                                                 * k))))
                              of inl(x) =>
                              inl x
                              | inr(x) =>
                              inr (λx.Ax) ));1) in
           case unit-ball-ex-decider(k;n) 
                (λq.case isr(rless-case((r(2) * e/r(3));e;(((rlessw(((r(2) * e/r(3)) * r(3)) * rinv(r(3));(e * r(3))
                         * rinv(r(3)))
                         * 20)
                         + 1)
                         * 20)
                         + 1;d(f 
                               (λi.eval k = k in
                                   λn.if (k) < (0)
                                         then -((r(q i) (2 * n)) ÷ (-2) * k)
                                         else ((r(q i) (2 * n)) ÷ 2 * k));λi.eval k = k in
                                                                             λn.if (k) < (0)
                                                                                   then -((r(q i) (2 * n)) ÷ (-2) * k)
                                                                                   else ((r(q i) (2 * n)) ÷ 2 * k))))
                     of inl(x) =>
                     inl x
                     | inr(x) =>
                     inr (λx.Ax) )
            of inl(x) =>
            let q,%8 = x 
            in <λi.eval k = k in
                   λn.if (k) < (0)  then -((r(q i) (2 * n)) ÷ (-2) * k)  else ((r(q i) (2 * n)) ÷ 2 * k)
               , Ax
               >
            | inr(x) =>
            let q,%8 = fix((λx.x)) 
            in <λi.eval k = k in
                   λn.if (k) < (0)  then -((r(q i) (2 * n)) ÷ (-2) * k)  else ((r(q i) (2 * n)) ÷ 2 * k)
               , Ax
               >



Definitions occuring in Statement :  unit-ball-ex-decider: unit-ball-ex-decider(k;n),  real-vec-dist: d(x;y),  rless-case: rless-case(x;y;n;z),  rdiv: (x/y),  rlessw: rlessw(x;y),  rinv: rinv(x),  rmul: a * b,  int-to-real: r(n),  mu-ge: mu-ge(f;n),  callbyvalue: callbyvalue,  isr: isr(x),  let: let,  less: if (a) < (b)  then c  else d,  int_eq: if a=b then c else d,  apply: f a,  fix: fix(F),  lambda: λx.A[x],  spread: spread def,  pair: <a, b>,  decide: case b of inl(x) => s[x] | inr(y) => t[y],  inr: inr x ,  inl: inl x,  divide: n ÷ m,  multiply: n * m,  add: n + m,  minus: -n,  natural_number: $n,  axiom: Ax
Definitions occuring in definition :  axiom: Ax,  lambda: λx.A[x],  inr: inr x ,  inl: inl x,  natural_number: $n,  multiply: n * m,  apply: f a,  int-to-real: r(n),  divide: n ÷ m,  minus: -n,  less: if (a) < (b)  then c  else d,  callbyvalue: callbyvalue,  real-vec-dist: d(x;y),  rinv: rinv(x),  rmul: a * b,  rdiv: (x/y),  rlessw: rlessw(x;y),  add: n + m,  rless-case: rless-case(x;y;n;z),  isr: isr(x),  decide: case b of inl(x) => s[x] | inr(y) => t[y],  unit-ball-ex-decider: unit-ball-ex-decider(k;n),  mu-ge: mu-ge(f;n),  let: let,  pair: <a, b>,  int_eq: if a=b then c else d,  spread: spread def,  fix: fix(F)
FDL editor aliases :  find-approx-fp

Latex:
find-approx-fp(n;f;e)  ==
    if  n=0
    then  <Ax,  Ax>
    else  let  k  =  mu-ge(\mlambda{}m.(unit-ball-ex-decider(m;n) 
                                                  (\mlambda{}q.case  isr(rless-case((r(2)  *  e/r(3));e;(((rlessw(((r(2)  *  e/r(3))
                                                                    *  r(3))
                                                                    *  rinv(r(3));(e  *  r(3))  *  rinv(r(3)))
                                                                    *  20)
                                                                    +  1)
                                                                    *  20)
                                                                    +  1;d(f 
                                                                                (\mlambda{}i.eval  k  =  m  in
                                                                                        \mlambda{}n.if  (k)  <  (0)
                                                                                                    then  -((r(q  i)  (2  *  n))  \mdiv{}  (-2)  *  k)
                                                                                                    else  ((r(q  i)  (2  *  n))  \mdiv{}  2
                                                                                                              *  k));\mlambda{}i.eval  k  =  m  in
                                                                                                                                \mlambda{}n.if  (k)  <  (0)
                                                                                                                                            then  -((r(q  i)  (2  *  n))  \mdiv{}  (-2)
                                                                                                                                                      *  k)
                                                                                                                                            else  ((r(q  i)  (2  *  n))  \mdiv{}  2
                                                                                                                                                      *  k))))
                                                            of  inl(x)  =>
                                                            inl  x
                                                            |  inr(x)  =>
                                                            inr  (\mlambda{}x.Ax)  ));1)  in
                      case  unit-ball-ex-decider(k;n) 
                                (\mlambda{}q.case  isr(rless-case((r(2)  *  e/r(3));e;(((rlessw(((r(2)  *  e/r(3))  *  r(3))
                                                  *  rinv(r(3));(e  *  r(3))  *  rinv(r(3)))
                                                  *  20)
                                                  +  1)
                                                  *  20)
                                                  +  1;d(f 
                                                              (\mlambda{}i.eval  k  =  k  in
                                                                      \mlambda{}n.if  (k)  <  (0)
                                                                                  then  -((r(q  i)  (2  *  n))  \mdiv{}  (-2)  *  k)
                                                                                  else  ((r(q  i)  (2  *  n))  \mdiv{}  2
                                                                                            *  k));\mlambda{}i.eval  k  =  k  in
                                                                                                              \mlambda{}n.if  (k)  <  (0)
                                                                                                                          then  -((r(q  i)  (2  *  n))  \mdiv{}  (-2)  *  k)
                                                                                                                          else  ((r(q  i)  (2  *  n))  \mdiv{}  2  *  k))))
                                          of  inl(x)  =>
                                          inl  x
                                          |  inr(x)  =>
                                          inr  (\mlambda{}x.Ax)  )
                        of  inl(x)  =>
                        let  q,\%8  =  x 
                        in  <\mlambda{}i.eval  k  =  k  in
                                      \mlambda{}n.if  (k)  <  (0)
                                                  then  -((r(q  i)  (2  *  n))  \mdiv{}  (-2)  *  k)
                                                  else  ((r(q  i)  (2  *  n))  \mdiv{}  2  *  k)
                              ,  Ax
                              >
                        |  inr(x)  =>
                        let  q,\%8  =  fix((\mlambda{}x.x)) 
                        in  <\mlambda{}i.eval  k  =  k  in
                                      \mlambda{}n.if  (k)  <  (0)
                                                  then  -((r(q  i)  (2  *  n))  \mdiv{}  (-2)  *  k)
                                                  else  ((r(q  i)  (2  *  n))  \mdiv{}  2  *  k)
                              ,  Ax
                              >



Date html generated: 2019_10_30-AM-11_29_20
Last ObjectModification: 2019_07_30-PM-00_50_42

Theory : real!vectors


Home Index