Can you show that the function f must have an absolute minimum value on the interval (a,b), if f is continuous on (a,b) and the right hand limit as x->a along with the left hand limit as x-> b are both equal to positive infinity?

# Tag: bounds

## windows 10 – what is an example of out of bounds read in order to leak sensitive information?

I Am trying to understand a little bit better behind the scenes on bypassing aslr by reading the bytes in the memory of a process, but how can I make an example of an info leak in WIN32? my code does the leaks of bytes , but how can I check the image base based on those bytes?

```
#include <stdio.h>
#include <string.h>
int main(int argc, char **argv) {
char a(16);
strncpy(a, "0123456789abcdef", sizeof(a));
//... lots of code passes, functions are called...
//... we finally come back to array a ...
printf("%sn", a);
}
```

## oa.operator algebras – Lower bounds in the space of compact operators

Let $H$ be a separable Hilbert space, and $K(H)$ the corresponding space of compact operators. Consider the “unit sphere” $S:={Tin K(H)|Tgeq 0text{ and }||T||=1}$. Is it true that, given any pair of operators $T_1,T_2in S$, there exists another operator $Tin S$ such that $Tleq T_1,T_2$?.

## What are the lower and upper bounds for the sum of the first $n$ primes?

I am looking for the lower and upper bounds for the sum of the first $n$ primes, $S(n)$ for all $n geq 2$

I found that $S(n) = frac{n^2}{2 log n} + O(frac{n^2}{log^2n})$. This is only an upper bound, and also not explicit.

Wondering what are some explicit (i.e without asymptotic notation) lower and upper bounds for $S(n)$ that fit all $n geq 2$?

## satisfaction of constraints – Algebra for min / max bounds

I am trying to model certain set operations which are only well defined if one is a subset of the other. The way the sets are constructed, I'm going to have a series of constraints of the form $ x subseteq y $, including the two sets in question and a few others as well. I don't know anything about belonging to an individual item, so I have to operate at the defined level and I would like to be able to determine if $ a subseteq b $ is involved by the given constraints.

It sounds like the kind of thing that has been studied before (for example, for SMT solvers or linear programming), but I can't seem to find the right keywords to search for. Are there any effective representations / algorithms known for this type of problem?

Here's what I pretty much thought of doing:

```
type Set = Symbol;
type Bound = {kind: 'upper' | 'lower', arg: Set};
type Constraint = {kind: 'lt' | 'gt', arg: Bound};
const max = (b1: Bound, b2: Bound): Bound => ...;
const min = (b1: Bound, b2: Bound): Bound => ...;
const checker = (a: Constraint, b: Constraint): bool => ...;
```

My idea would be to build two `Constraint`

s, one for $ a $ and one for $ b $. $ a $ would have a `lt`

constraint and $ b $ would have a `gt`

constraint. I suspect `Bound`

form an algebra with `max`

and `min`

, which would allow me to put two `Bound`

s in an almost canonical form and break it down that way.

I'm not sure it will work, so before spending several hours fleshing it out, I wondered if this had been resolved before!

## calculation and analysis – Numerical solution of triple integration of a region with variable bounds?

I am asked to calculate the mass of the region bounded by the plane `(2x + 3y - z = 2)`

and below by the triangle on the xy plane with vertices `(0,2),(1,0),(4,0)`

. The density is proportional to the distance from the plane to the xy plane, so the function is `d(x,y,z) = kz`

.

My limits are:

`0 ≤ z ≤ (2x + 3y - 2)`

`(1 - 0.5y) ≤ x ≤ (4 - 2y)`

and `0 ≤ y ≤ 2`

.

My code is:

```
Integrate(d(x,y,z),{z,0,2x+3y-2},{x,1-0.5y,4-2y},{y,0,2})
```

but Mathematica does not return a number (if I'm not mistaken, it should be 19k).

Instead, I get: `k(3-1.5y)(-2+2x+3y)^2`

.

However if I integrate the function step by step:

```
Integrate(Integrate(Integrate(d(x,y,z),{z,0,2x+3y-2}),{x,1-0.5y,4-2y}),{y,0,2}),
```

I get a numeric value.

Is there some syntax that Mathematica requires that I am not aware of?

## real analysis – Bounds for a continuous function given that f(0)=e and f(R)=(-2,-1)U[1,5)

Let $f:R→R$ be a function such that $f(R)$ is a subset of $(-2,-1) cup (1,5)$ and $f(0)=e$. Can you give realistic bounds for $f$?

This is a question I got from a book and I didn’t understand the question nicely. A solution to this will be appreciated.

Thanks in advance!

## partial order – Efficient calculation of lower bounds on partially ordered sets

I have a list of sets that I would like to sort in a partial order based on the subset relation.

In fact, I don't require the full order, only the lower bounds.

If I'm not mistaken, each lower bound should define a separate component of the respective graph – and that component should be a meet-semilattice.

What would be the most convenient way in terms of space and time to solve this problem? Maybe there is a way that does not require building the entire graph? Perhaps there is an algorithm known in better terminology than what I naively described above?

I am aware that the time and space requirements are under-specified above, but I would be happy with any suggestions, whether or not they are found to be optimal …

**Context**: I'm trying to build an entire graphical database that contains all the edges between the sets, then I'm looking for nodes that don't have generalizations, but this is quite complicated, slow and requires a lot of ;disk space). The list mentioned above contains *around 100 million sets*.

## security – In Baggy Bounds Checking, why is an error generated when accessing more than half the size of the slot the end limit of an allocated memory?

The second note of the MIT Computer Systems Security Class (6.858) contains this excerpt (slightly modified).

```
char *p = malloc(44);
char *q = p + 60;
char *r = q + 16;
// r is now at an offset of 60+16=76 from
// p. This means that r is (76-64)=12 bytes
// beyond the end of p. This is more than
// half a slot away, so baggy bounds will
// raise an error.
```

I understand that Baggy Bounds Checking makes it possible to check at a lower cost if a pointer to an allocated memory is or is not within the limits of this memory. This prevents many forms of attacks involving the replacement of arbitrary parts of memory. What I do not understand, it is this part of the extract above.

This is more than half a time slot, too big limits will create an error.

Why should an error be generated when accessing memory more than half the size of the slot from the final limit of an allocated memory?

## Prove that the following sequence has upper and lower bounds

I have to prove that $ x_n = sqrt {n ^ 2 + 1} -n $ the sequence is bounded. Here is what I tried:

$ x_n = ( sqrt {n ^ 2 + 1} -n) $$ frac { sqrt {n ^ 2 + 1} + n} { sqrt {n ^ 2 + 1} + n} $=$ frac {1} { sqrt {n ^ 2 + 1} + n} $But can not continue.