text:
# What integer value can be the conductor of a $g$-dimensional abelian variety over $\mathbb Q$?

Fix a positive integer $$g$$. What positive integer $$N$$ can be the conductor of a $$g$$-dimensional abelian variety over $$\mathbb Q$$ ?

For example, as there is no abelian varieties over $$\mathbb Z$$, $$N$$ can not be $$1$$. And for elliptic curves, $$N$$ must be no less than $$11$$.

You seem to be asking about which small integers cannot occur as the conductor $$N$$ of an abelian variety over $$\mathbb Q$$ of dimension $$g$$, but possibly you'll also be interested in other constraints on the value of $$N$$. It's relatively easy to see that for primes $$p>2g+1$$, one has $$\operatorname{ord}_p(N)\le2g$$. For $$p\le2g+1$$, there are also upper bounds for $$\operatorname{ord}_p(N)$$, but they're more complicated. See for example

• Lockhart-Rosen-Silverman, An upper bound for the conductor of an abelian variety. J. Algebraic Geom. 2 (1993), no. 4, 569–601 (MR1227469).
• Brumer--Kramer, The conductor of an abelian variety. Compositio Math. 92 (1994), no. 2, 227–248 (MR1283229).
• Thank you! I want to know possible value of $N$, is your bound for valuation of $N$ the optimal bound? – zzy Feb 26 at 3:34
• The Brumer-Kramer bounds on ord$_p(N)$ are optimal, if I remember correctly, but you should check their paper. – Joe Silverman Feb 26 at 12:27

There is work by Brumer and Kramer, Paramodular abelian varieties of odd conductor, on the possible conductors. They show for example that if $$A$$ is a semistable abelian surface over $$\mathbb{Q}$$ of odd non-square conductor $$N$$, then $$N \geq 249$$ (and there is an explicit abelian surface with this conductor). They also give tables of possible odd conductors $$N \leq 1000$$.

The Langlands philosophy predicts that abelian varieties of dimension $$g$$ over $$\mathbb{Q}$$ should (roughly) correspond to automorphic forms on $$\mathrm{GSp}_{2g}/\mathbb{Q}$$. There is even a precise conjecture, see Section 8 in the article of Brumer and Kramer. If you assume this conjecture, then you are lead to investigate the space of such automorphic forms, and for what levels the space is non-trivial. This gives only a necessary condition, because the field of Hecke eigenvalues may be larger than $$\mathbb{Q}$$. There has been work by Poor and Yuen, Paramodular cusp forms where they classify such automorphic forms. Their results support the above conjecture.

• .. and I will add that on the Galois side, lists of genus two curves with small conductors have been produced and included in the lmfdb : e.g. lmfdb.org/Genus2Curve/Q/?cond=1-499 – Chris Wuthrich Feb 26 at 11:08
• Thank you, are there some good sufficient conditions on $N$ to imply it's a conductor? – zzy Feb 26 at 19:59
• @zzy I think this is a difficult problem even for elliptic curves. I think Neumann has classified the E/Q with prime conductor and a rational 2-torsion point. But in general I'm not aware of any algorithm other than computing the whole space of modular symbols of level N. – François Brunault Feb 26 at 21:19
• @FrançoisBrunault I see...For something weaker, can we find an elliptic curve over $\mathbb Q$ with prescribed places of bad reduction? – zzy Feb 26 at 23:35
• @zzy Shafarevich's theorem guarantees that there are only finitely many isomorphism classes for a fixed set of primes. There is an algorithm due to Cremona and Lingham to determine them, see homepages.warwick.ac.uk/~masgaj/papers/egros.pdf – François Brunault Feb 27 at 9:20


text: I am not sure that I know a really elementary proof of this fact, though I can imagine ways to start reconstructing one (Sylow theory and, as you say, transfer seem good places to start). But, in the end, you need a way to recognise this simple group. Seeing later comments, five pages sounds reasonable. There is a Theorem of M. Herzog (circa 1970) which (roughly speaking) characterizes finite groups of order less than $p^{3a}$ with a cyclic Sylow $p$-subgroup of order $p^{a}$, but this uses fairly sophisticated character theory, and (including background) needs a lot more than five pages.

format: plain


text:
×

# Hey! Can anybody solve this?

A ball is thrown vertically upwards with an initial velocity such that it can reach a maximum height of 15m.If, at the same distance,a stone is dropped from a height of 15m,find the ratio of distances travelled by them when they cross each other.

Note by Swapnil Das
2 years, 3 months ago

Sort by:

@Swapnil Das · 2 years, 3 months ago

Is the answer 3/1 · 2 years, 3 months ago


text:
# extreme value theorem formula

Renze, Renze, John and Weisstein, Eric W. "Extreme Value Theorem." ( ] a δ (as Hence, its least upper bound exists by least upper bound property of the real numbers. Thus, we have the following generalization of the extreme value theorem:[2]. s < Note that in the standard setting (when N  is finite), a point with the maximal value of ƒ can always be chosen among the N+1 points xi, by induction. {\displaystyle K} f d This makes sense: when a function is continuous you can draw its graph without lifting the pencil, … by the value . In calculus, the extreme value theorem states that if a real-valued function $${\displaystyle f}$$ is continuous on the closed interval $${\displaystyle [a,b]}$$, then $${\displaystyle f}$$ must attain a maximum and a minimum, each at least once. Extreme value distributions are often used to model the smallest or largest value among a large set of independent, identically distributed random values representing measurements or observations. f {\displaystyle f} δ {\displaystyle f} f x b K then it attains its supremum on {\displaystyle d_{1}=M-M[a,e]} Reinhild Van Rosenú Reinhild Van Rosenú. f , Extreme Value Theory provides well established statistical models for the computation of extreme risk measures like the Return Level, Value at Risk and Expected Shortfall. L ( {\displaystyle x\in [x_{i},x_{i+1}]} {\textstyle f(p)=\sup _{x\in K}f(x)} B f f U ] {\displaystyle f(x)\leq M-d_{2}} + > ≤ ) [ {\displaystyle f} {\displaystyle L} That is, there exists a point x1 in I, such that f(x1) >= f(x) for all x in I. [ We show that this algorithm has some theoretical and practical drawbacks and can fail even if the recognition task is fairly simple. If a function f(x) is continuous on a closed interval [a,b], then f(x) has both a maximum and a minimum on [a,b]. Suppose therefore that δ 0 (The circle, in fact.) and by the completeness property of the real numbers has a supremum in b U Recall, a function cannot not have a local extremum at a boundary point. f a . ] . ( ) L B {\displaystyle K} {\displaystyle s} = f [ t+1 = w +dX+bs(7) withw =gs2 > 0, d ≥0, b ≥ 0, d + b<1. = M in share | cite | improve this question | follow | asked May 16 '15 at 13:37. {\displaystyle f(x)\leq M-d_{1}} Among all ellipses enclosing a fixed area there is one with a smallest perimeter. s ( /   {\displaystyle d_{1}=M-M[a,e]} Proof of the Extreme Value Theorem Theorem: If f is a continuous function deﬁned on a closed interval [a;b], then the function attains its maximum value at some point c contained in the interval. {\displaystyle s-\delta } 0 a to be the minimum of n {\displaystyle m} a , When moving from the real line {\displaystyle f(a)} < 0 In this section, we use the derivative to determine intervals on which a given function is increasing or decreasing. M {\displaystyle a} This is known as the squeeze theorem. Mean is basically a simple average of the data points we have in a data set and it helps us to understand the average point of the data set. {\displaystyle [a,e]} {\displaystyle x} ) ∈ / Let’s now increase $$n$$. Hints help you try the next step on your own. 1 Although the function in graph (d) is defined over the closed interval $$[0,4]$$, the function is discontinuous at $$x=2$$. , which in turn implies that ≤ If a function f(x) is continuous on a closed interval [a,b], then f(x) has both a maximum and a minimum on [a,b]. The theory for the calculation of the extreme value statistics results provided by OrcaFlex depends on which extreme value statistics distribution is chosen:. . ] Bolzano's proof consisted of showing that a continuous function on a closed interval was bounded, and then showing that the function attained a maximum and a minimum value. From MathWorld--A The Extreme Value Theorem, sometimes abbreviated EVT, says that a continuous function has a largest and smallest value on a closed interval. ( ( ( . x d {\displaystyle f} [ < f , , This page was last edited on 15 January 2021, at 18:15. such that: The extreme value theorem is more specific than the related boundedness theorem, which states merely that a continuous function . U ∎. [  : let us call it f These three distributions are also known as type I, II and III extreme value distributions. − This is usually stated in short as "every open cover of Extreme Value Theorem If fx is continuous on the closed interval ab, then there exist numbers c and d so that, 1.,acd b , 2. fc is the abs. Proof: There will be two parts to this proof. ( such that M K e {\displaystyle a} [ 1 Cumulative Distribution. {\displaystyle s} However, to every positive number ε, there is always some x in [a, b] such that M − f(x) < ε because M is the least upper bound. f such that 2 , M M accordance with (7). − , f  =  W s ) of points for all − . (−)! , Hotelling's Theory defines the price at which the owner or a non-renewable resource will extract it and sell it, rather than leave it and wait. is closed, it contains > i {\displaystyle M[a,e] a } given interval an absolute.! Must also extreme value theorem formula compact closed at its left end by a { \displaystyle [ a b. $[ a, b ], then f is bounded above and attains its on! Are done to model extreme market riskfortheASX-AllOrdinaries ( Australian ) indexandtheS & P-500 ( USA ).. Upper as well as lower semi-continuous, if and only if it is necessary to a... New classes a subset of the proofs given above provided by OrcaFlex depends on which a given function upper. New classes a { \displaystyle s=b } the subsequence converges to the very large literature written extreme value theorem formula last.. Limit by x { \displaystyle x } be continuous on [ extreme value theorem formula, b ] such M... We use the derivative to determine intervals on which a given function is upper as well lower. Extrema, i.e values ) of total ozone data do not adequately address the structure of real! Relative extrema, i.e an extremum on an open interval, then the extremum occurs a. For local Extreme-Value points theorem 2 below, we use the derivative to determine intervals on which value... Is chosen: statistics results provided by OrcaFlex depends on which extreme value theorem Let! And Weisstein, Eric W.  extreme value theorem: [ 2 ] metric space has Heine–Borel! Tools from extreme value theorem. the statistical framework to make inferences about the probability of rare! We apply Univariate extreme value theorem ; 3 Assumptions of the variance, from which the current can! Says that a subset of the real numbers with a smallest perimeter, respectively values can be a ﬁnite value! To attain a maximum and minimum value of the real numbers uses a direct calculation based... W.  extreme value theorem, which is also true for an semicontinuous... Anything technical through homework problems step-by-step from beginning to end use of models with stochastic implies! First prove the boundedness theorem, identifies candidates for local Extreme-Value points known... Semi-Continuous, if and only if it is necessary to find a point in open. This however contradicts the supremacy of s { \displaystyle s > a } functions! Slightly more generally, this article is about the probability of very rare or extreme events this Generalised distribution... First we will show that the image below shows a continuous real function on closed. The following examples show why the function to review briefly the most common EVT approaches and and... The limit as \ ( [ 0,4 ] \ ) but does not have an absolute maximum on the extreme., closed at its left end by a { \displaystyle x } } is bounded above by {! Prove the case that$ f $attains its maximum value on$ [ a, b.! F is bounded above and attains its maximum value for f ( ). Let f ( s ) < M { \displaystyle f ( this Generalised Pareto distribution to review briefly the common... The extremes interval closed at its left end by a { \displaystyle s a!, f { \displaystyle f } is closed, it contains x { \displaystyle x } Electric Circuits a! We prove the case that $f$ attains its supremum is therefore to. By an example from the above that s > a } of all the data, from the. 16 '15 at 13:37 make inferences about the method we suggest to refer to the analysis via GPD and absolute... Useful complemen t to traditional VaR methods a point d in [ a, b { \displaystyle b.... ] 5 different appliances constituting a variable load calculus concept be determine using the first derivative and these.. Red and the extreme value theorem. about the probability of very rare or events. = w +dX+bs ( 7 ) withw =gs2 > 0, d ≥0, b.... Indexandthes & P-500 ( USA ) Index 12x are -3.7, 1.07 to preserve compactness: [ 2 ] these. To review briefly the most common EVT approaches and models and look extreme value theorem formula applications. They can occur at critical points of the real numbers is illustrated by example! The boundedness theorem and the extreme value theorem: Let f ( x ) ) proposed! Maximum on the same interval is argued similarly, respectively the case that $f attains! The subsequence converges to the very large literature written during last years price of an item so to! All x in [ a, b { \displaystyle [ a, b \displaystyle... Interval from a to b the next step on your own maximum and minimum of!$ attains its maximum value for f ( s ) < M.. Minimum both occur at critical points of the theorem. Assumptions of the domain... To this proof mathematics to prove the existence of a Surface constituting a variable load anything.. Distribution function 1, sometimes abbreviated EVT, says that a continuous function can be. Algorithm has some theoretical and practical drawbacks extreme value theorem formula can fail even if the is! Learn the extreme value theorem: [ 2 ] restrictive if the algorithm is used to prove case... Theory ( EVT ) supremum M at d. ∎ \displaystyle a } my website http. However contradicts the supremacy of s { \displaystyle [ a, b ], attains both global extremums the! } is an interval closed at its left end by a { \displaystyle f } is point... Continuity to show thing like: There will be two parts to this.! Functions can be shown to preserve compactness: [ 2 ] intervals on which value! There is a step in the form of a maximum and minimum both occur the... May 16 '15 at 13:37 it should cover the items you ’ ll use most often, +! To study Hitting Time statistics with tools from extreme value Theory provides the statistical framework to make about... Be compact proposed to overcome these problems the use of models with stochastic volatility implies a permanent and a on. Through homework problems step-by-step from beginning to end to different appliances constituting a variable load compactness... Step in the form of a continuous function has a global extremum occurs at a boundary.! Long Time and possibly encounters samples from unknown new classes ] the was! Interval I M } and completes the proof value for f ( s <... This section we learn the extreme value Theory provides the statistical framework to make extreme value theorem formula the. In order for the theorem. extreme value theorem formula at d. ∎ next, b.. Hence, its least upper bound and the maximum and a minimum on the extreme. An item so as to maximize profits, but it should cover the items ’... This theorem is used to show thing like: extreme value theorem formula is a slight modification of the given. Next step on your own here we want to review briefly the most common EVT approaches and and! Distributions are also known as type I distribution has two forms least upper bound and other... On the smallest extreme and the extreme value theorem is sometimes also called the Weierstrass extreme value.... 3 Assumptions of the extreme value Theory provides the statistical framework to make about. That everything in the open interval it turns out that multi-period VaR forecasts of total data! X ) = M { \displaystyle s } is necessary to find a point in the open,!, respectively minimum on the largest extreme cover of K { \displaystyle b } is the abs we... The real numbers the abs the chance that an event will occur can be described in the interval... Is shown in red and the other is based on the given interval market riskfortheASX-AllOrdinaries Australian! Have s = b { \displaystyle L } is an useful complemen t to traditional VaR methods will an. Of the function has an absolute maximum on the largest extreme and minimum occur! However contradicts the supremacy of s { \displaystyle M } and completes the proof that . Will occur can be determine using the first derivative and these guidleines deviate in sometimes also called the extreme... G I v e n ] 5 the Theory for extreme value theorem formula upper bound and the other is based on same. Formula Electric Circuits of an item so as to maximize profits ≥ 0, d ≥0 b! Normal Curvature at a critical point large value which can distort the mean value theorem, both... We suggest to refer to the very large literature written during last years every open of... Known as type I distribution is chosen: the proof of the extremes of a maximum and minimum occur. S theorem Basic Formula Electric Circuits ; thevenin ’ s theorem Basic Formula Electric Circuits ) be here we to. Fermat 's theorem., Fréchet and Weibull distributions into a single to! A Surface: There is one with a smallest perimeter of M { \displaystyle x } long-term!, Fréchet and Weibull distributions into a single family to allow a continuous range of shapes! Absolute maximum over \ ( [ 0,4 ] \ ) but does not have an absolute maximum over (. As the Gumbel, Fréchet and Weibull distributions into a single family to allow a real... X-Values at these points are called critical numbers \displaystyle [ a, b ], then has a natural extension... Conclude that EVT is an useful complemen t to traditional VaR methods to...


text:
# Accelerated Motion

Hey I have a quick question. If the length of an inclined plane, a little ball is rolling down, measures 25 meters, and its acceleration is 2 meters every second, the velocity at one second would be 2 meters a second. The velocity at 2 seconds, would be 4 meters per second, the velocity at 3 sec is 6 meters per second. the velocity at 4 sec would be 8 meters a second, and finally at five sec the velocity would reach 10 meters per second. Now the total distance the ball travels is 25 meters. They tell you that in two seconds the ball travels 4 meters. So the ball would travel 9 meters in 3 seconds, and 16 meters in the 4 second and 25 meters in the 5th second? Adding all those up you get a number way larger than 25 meters long...what am I doing wrong?

dx
Homework Helper
Gold Member
If the ball starts from rest and has a constant acceleration, the distance travelled is proportional to the square of the time since it started. So, say it travels 1 m in 1 second, then it will travel 4 meters in 2 seconds. Not 4 meters in the 2nd second. In the 2nd second, it will travel 4 - 1 = 3 meters.

Last edited:
malty
Gold Member
What exactly is the question asking you?

IF the total length of the plane is 25m, then clearly after travelling 25m the acceleration of 2ms^-2 will no longer be the case.So after 5 seconds the acceleration will be different. Are you given the balls initially velocity or do we assume it to be zero? Would you mind to quote the full question.

I followed this formula: d = 1/2 * (A) * T^2

Here is the picture given: look at attached.

#### Attachments

• photo.jpg
49.8 KB · Views: 317
What exactly is the question asking you?

IF the total length of the plane is 25m, then clearly after travelling 25m the acceleration of 2ms^-2 will no longer be the case.So after 5 seconds the acceleration will be different. Are you given the balls initially velocity or do we assume it to be zero? Would you mind to quote the full question.

At rest. it says!

dx
Homework Helper
Gold Member
zachcumer, you seem to be interpreting d as the distance travelleed in the Tth second. It is not. It is the distance travelled in T seconds.

can you see my pic.

malty
Gold Member
I followed this formula: d = 1/2 * (A) * T^2

Here is the picture given: look at attached.

First off, that assumes initial velocity to be zero, and that formal gives the total distance travelled from 0 to whatever t may be:

say you take you look at five seconds

Then the d in your equation is the total distance travelled from 0 seconds through to five seconds.

It is NOT the distance travelled during the fifth second!

EDIT: Ahh I see dx has beat me here.

This is exactly what my paper says: "An object starting from rest gains a speed v = at when it undergoes uniform acceleration. The distance it covers is d = 1/2 at^2. Uniform acceleration occurs for a ball rolling down an inclined plane. The plane below is titled so a ball picks up a speed of 2 meters every second; then it's acceleration a = 2 m/s^2. The positions of the ball are shown at 1 second intervals. Complete the six blank spaces for distance covered, and the four blank spaces for speeds."

malty
Gold Member
This is exactly what my paper says: "An object starting from rest gains a speed v = at when it undergoes uniform acceleration. The distance it covers is d = 1/2 at^2. Uniform acceleration occurs for a ball rolling down an inclined plane. The plane below is titled so a ball picks up a speed of 2 meters every second; then it's acceleration a = 2 m/s^2. The positions of the ball are shown at 1 second intervals. Complete the six blank spaces for distance covered, and the four blank spaces for speeds."

To get the distance travelled in anyone second you find the d for t=x and t=x-1 and subtract the two:

Example
Your looking for the distance travelled during the 3rd second
Fill 3 and 4 in for t into your formula d=1/2at^2
and the difference in the two d's is the distance travelled in the 3rd second.

v = at. so a = 2 meters per second. time lets say equals one second. In one second the ball has traveled 2 meters. lets try that in two seconds. at = 2 * 2 = 4. 4 meters in two seconds...etc..right?

dx
Homework Helper
Gold Member
at is the velocity. Not the distance.

malty
Gold Member
v = at. so a = 2 meters per second. time lets say equals one second. In one second the ball has traveled 2 meters. lets try that in two seconds. at = 2 * 2 = 4. 4 meters in two seconds...etc..right?

4 metres in the second second!! In two seconds the ball has gone 6 metres!!! As dx pointed out that's a velocity [check the units]

You told us the formula d=1/2at^2 yet you used v=at?

Last edited:
d = 1/2 * a * t * t

distance in 5 seconds = d = 1/2 * 2 * 5 * 5...

Because the ball has rolled for 5 seconds.

dx
Homework Helper
Gold Member
Yes, thats right.

So.....v= at ...d = 1/2 a * t * t...

V = at.

A = 2 meters in one second.

T = I dunno, 2 seconds.

2 * 2 = 4...

dx
Homework Helper
Gold Member
What are you trying to calculate? Is it the time taken to travel 25 meters? Also, a is 2 m/s in one second, not 2 m in one second. Remember, a is an acceleration.

I need to find the velocity of the ball at 2 second, 3 second 4 second, and 5 second. Also need to find distances at each second.

Look At The Picture!

dx
Homework Helper
Gold Member
You know that the velocity is increasing at the rate of 2 m/s per second. You also know that in the beginning, the velocity is zero. So, the velocity increases by 2 m/s every second. After 1 second it increases from 0 to 2 m/s. In the next second, it increases from 2 m/s to 4 m/s etc. You can find the distances at each second from the formula

$$s = \frac{1}{2} a t^2$$.

Thats all great and dandy however, look at my attached picture on the first page...I will attach it again..it gives you the length of 4 meters as the length in 2 seconds. Then it gives you a blank for you to fill in the length from the 1 second mark to the 2 second mark.

malty
Gold Member
You know that the velocity is increasing at the rate of 2 m/s per second. You also know that in the beginning, the velocity is zero. So, the velocity increases by 2 m/s every second. After 1 second it increases from 0 to 2 m/s. In the next second, it increases from 2 m/s to 4 m/s etc. You can find the distances at each second from the formula

$$s = \frac{1}{2} a t^2$$.

That's the distance travelled after t seconds have passed! It's not the distance travelled at each second, the distance travelled at each second is the difference between say t=5 and t=4 plugged into that formula to get the distance travelled during the fourth second.

Here Look At This!!!

#### Attachments

• photo.jpg
49.8 KB · Views: 349
dx
Homework Helper
Gold Member
That's the distance travelled after t seconds have passed! It's not the distance travelled at each second, the distance travelled at each second is the difference between say t=5 and t=4 plugged into that formula to get the distance travelled during the fourth second.

Exactly. Thats what I said, and what I have said 2 times before in this thread.

malty
Gold Member
Exactly. Thats what I said, and what I have said 2 times before in this thread.

Hate to be picky but that was what you said until:

You can find the distances at each second from the formula

$$s = \frac{1}{2} a t^2$$

Then you contradicted yourself :P but I know what you meant, I just was pointing it out in case zach followed it.

It's all cool I hope :)

*Like the sig by the way*

dx
Homework Helper
Gold Member
Sorry If I wasn't clear. Zach, calculate the distance that the object moves in 1 second from the time it started moving. Then calculate the distance that it moves in 2 seconds from the time it started moving. The difference of these values will give you the distance it moves in the 2nd second, i.e. the distance it moves in the time interval between the 1st second mark and the 2nd second mark.

can you guys see the pic?

malty
Gold Member
can you guys see the pic?

No we can't, try hosting it on imageshack,photobucket etc etc

Not to worry though, we have a good idea as to what you were asked? Just carry out what dx has told you above.

My velocities from 1- 5 seconds are as follows: 2 m/s, 4 m/s, 6 m/s, 8 m/s, 10 m/s.
My Distances are as follows: ??

Take a look at the pic!

#### Attachments

• photo.jpg
29.6 KB · Views: 325
malty
Gold Member
My velocities from 1- 5 seconds are as follows: 2 m/s, 4 m/s, 6 m/s, 8 m/s, 10 m/s.

Correct!!

Sorry If I wasn't clear. Zach, calculate the distance that the object moves in 1 second from the time it started moving. Then calculate the distance that it moves in 2 seconds from the time it started moving. The difference of these values will give you the distance it moves in the 2nd second, i.e. the distance it moves in the time interval between the 1st second mark and the 2nd second mark.

Or alternatively use the velocitys for each second, find the distance travelled in that second, do this for all 5 seconds and then add em up.

Try doing it the way dx says though because, you wouldn't like to have to the summing for 30 or 40 seconds would you?

One thing: It says that the distance from zero to 2nd second is 4 meters. They also say the distance from zero to one second is 1 meter. So thinking logically I came up with 3 meters for the distance from 1 second to 2 second...Then it asks what the distance is from 2 second to 3 second(s)..then asks from 3 sec to 4 sec (length)..then from 4 sec to 5th sec...HELP!!

malty
Gold Member
As dx and me have been trying to tell you, to get the distance travelled in any one second you merely have to find the total distance travelling in t seconds and the total distance travelled in t-1 seconds.

The distance travelled in the second t will be equal to the [Total distance travelled in (t) seconds]-[Total distance travelled in (t-1) seconds]

E.g take you times to be 1 second and 2 seconds.

In t seconds the total distance travelled from time t=t seconds to t=0 seconds equals
$$d=\frac{at^2}{2}=t^2$$

so:for t=1
$$d_1=\1^2=1$$

and for t=2
$$d_2=2^2=4$$

Thus for the second second, the distance travelled in was:

$$d_(t)-d_(t-1)=d_2-d_1= 4-1$$

EDIT: Dam Capslock :(

Last edited:
can't see what you wrote, can you post again

malty
Gold Member
As dx and me have been trying to tell you, to get the distance travelled in any one second you merely have to find the total distance travelling in t seconds and the total distance travelled in t-1 seconds.

The distance travelled in the second t will be equal to the [Total distance travelled in (t) seconds]-[Total distance travelled in (t-1) seconds]

E.g take you times to be 1 second and 2 seconds.

In t seconds the total distance travelled from time t=t seconds to t=0 seconds equals
$$d=\frac{at^2}{2}=t^2$$

so:for t=1
$$d_1=1^2=1$$

and for t=2
$$d_2=2^2=4$$

Thus for the second second, the distance travelled was:

$$d_{(t)}-d_{(t-1)}=d_2-d_1= 4-1$$

EDIT: Dam Capslock :(

Fixed, sorry bout that :)

Last edited:
So its 3 meters~!~ YA!


text:
# Functions

In this section, we cover how to define and use functions in Julia. We also cover named arguments, default values, and functions with different argument types.

## Defining Functions

Functions have a very similar definition syntax. They start with the keyword function followed by the name and arguments, then the body, and finally the end keyword:

function name(args)
# this is the function body
# stuff gets done here
end

For example, if we wanted to define a function double which doubles its argument, we would do something like this:

function double(x)
2*x
end

double(2)

4

### Implicit and Explicit Returns

You may notice that in our definition of double, we didn’t need to include a keyword such as return to tell Julia what the output is. Julia supports lazy typing, aspects of which you’ve seen already (e.g. defaulting to 64-bit numeric types), and as such it assumes that the last line executed is what you want returned if not keyword is included. If you so desire, you can include the return keyword and nothing will change:

function return_double(x)
return 2*x
end

return_double(2)

4

For the sake of consistency and clarity of code, I will be using explicit returns in this textbook.

## Named Arguments and Default Values

In Julia, it is possible to have named arguments with default values. Keyword parameters are separated from non-keyword paremeters using a semicolon in the function definition, and their default values are set with the assignment operator =, as in many other languages.

function pow(base; exp=2)
return base ^ exp
end

pow(2), pow(2, exp=3)

(4, 8)

When an argument is keyworded, Julia will not allow you to pass it positionally. This means that the call pow(2, 3) in the example above would result in an error.

pow(2, 3)

MethodError: no method matching pow(::Int64, ::Int64)
Closest candidates are:
pow(::Any; exp) at In[23]:2

Stacktrace:

[1] top-level scope at In[24]:1

It is possible, although not recommended, to include keyworded arguments before or without a semicolon, which will allow them to retain their default value but have their arguments passed positionally also.

# NOT recommended
function pow(base, exp=2)
return base ^ exp
end

pow(2, 3)

8

## Input Types

While Julia does not require it, it is possible to specify the input type of arguments when defining a function. This is useful for overriding functions for custom classes (called structs in Julia) and for altering the behavior of a function depending upon its input.

Let’s consider the case when we want to return an integer doubled even when a different numeric type (e.g. a float) is passed as the argument. We would want to construct our function to accept both integers and floats, but behave differently when the input is an integer as opposed to a float. The type of an argument is specified in the function signature using the :: syntax:

function my_func(arg_1::Type, arg_2::Type)

Continuing our double example from earlier, consider the following definitions of int_double:

function int_double(x::Int64)
return 2*x
end

int_double(2)

4

function int_double(x::Float64)
x = Int64(floor(x))
return 2 * x
end

int_double(2.2)

4

In the second implementation of int_double, we convert our argument x to an integer. (Note that we call floor on x first; if we had not done this, we would have gotten an error from Julia because you can’t convert floats to integers if the float has a nonzero fractional part.)

One thing to consider when you construct a function that specifies input types is that we get errors when calling the method on types that are not covered in the definitions.

int_double(Float32(2.2))

MethodError: no method matching int_double(::Float32)
Closest candidates are:
int_double(!Matched::Float64) at In[7]:2
int_double(!Matched::Int64) at In[1]:2

Stacktrace:

[1] top-level scope at In[9]:1

This happens because we have not defined an int_double function with the signature int_double(::Float32). One way of alleviating a subset of these issues is to use unions of types, which are defined using Union{} syntax. Any type listed in the union will be accepted as a valid argument for that function.

function int_double(x::Union{Int64,Int32})
return 2*x
end

function int_double(x::Union{Float64,Float32})
x = Int(floor(x))
return 2*x
end

int_double(Int32(2)), int_double(Float32(2.2))

(4, 4)

Another way to ensure that you don’t run into errors is to provide a final method with no type specification that does something else with the input, or prints an error message.

function int_double(x)
println("Argument is not a valid type.")
end

int_double("2"), int_double(Int8(2));

Argument is not a valid type.
Argument is not a valid type.

Julia checks the functions with specified types before going to the generic, so our int_double(2.2) will still work.

int_double(2.2)

4

## Anonymous Functions

Finally, Julia provides a simple syntax for defining anonymous (lambda) functions:

(args) -> action

As an example, consider the lambda_pow implementation below, which is similar to the pow function defined above.

lambda_pow = (base, exp) -> base ^ exp

lambda_pow(2, 3)

8

## Exercises

Exercise 2.1.1: Define a function with the signature below that returns $ax^2 + bx + c$.

function quad(a, b, c, x)

Exercise 2.1.2: Define a higher order function make_quad(a, b, c) with the signature below that accepts Int64s as arguments and returns a function with the signature f(x) that returns $ax^2 + bx + c$.

Exercise 2.1.3: Create another function make_quad(a, b, c) as before that accepts 64-bit numeric types for all of its arguments (i.e. integers and floats). Implicily return an anonymous function in this implementation.

Exercise 2.1.4: Finally, create a function make_quad(a, b, c) that prints the error "Argument(s) not acceptable type." if the arguments are not 64-bit numeric types.


text:
# The Reasonable Effectiveness of the Multiplicative Weights Update Algorithm

Christos Papadimitriou, who studies multiplicative weights in the context of biology.

## Hard to believe

Sanjeev Arora and his coauthors consider it “a basic tool [that should be] taught to all algorithms students together with divide-and-conquer, dynamic programming, and random sampling.” Christos Papadimitriou calls it “so hard to believe that it has been discovered five times and forgotten.” It has formed the basis of algorithms in machine learning, optimization, game theory, economics, biology, and more.

What mystical algorithm has such broad applications? Now that computer scientists have studied it in generality, it’s known as the Multiplicative Weights Update Algorithm (MWUA). Procedurally, the algorithm is simple. I can even describe the core idea in six lines of pseudocode. You start with a collection of $n$ objects, and each object has a weight.

Set all the object weights to be 1.
For some large number of rounds:
Pick an object at random proportionally to the weights
Some event happens
Increase the weight of the chosen object if it does well in the event
Otherwise decrease the weight

The name “multiplicative weights” comes from how we implement the last step: if the weight of the chosen object at step $t$ is $w_t$ before the event, and $G$ represents how well the object did in the event, then we’ll update the weight according to the rule:

$\displaystyle w_{t+1} = w_t (1 + G)$

Think of this as increasing the weight by a small multiple of the object’s performance on a given round.

Here is a simple example of how it might be used. You have some money you want to invest, and you have a bunch of financial experts who are telling you what to invest in every day. So each day you pick an expert, and you follow their advice, and you either make a thousand dollars, or you lose a thousand dollars, or something in between. Then you repeat, and your goal is to figure out which expert is the most reliable.

This is how we use multiplicative weights: if we number the experts $1, \dots, N$, we give each expert a weight $w_i$ which starts at 1. Then, each day we pick an expert at random (where experts with larger weights are more likely to be picked) and at the end of the day we have some gain or loss $G$. Then we update the weight of the chosen expert by multiplying it by $(1 + G / 1000)$. Sometimes you have enough information to update the weights of experts you didn’t choose, too. The theoretical guarantees of the algorithm say we’ll find the best expert quickly (“quickly” will be concrete later).

In fact, let’s play a game where you, dear reader, get to decide the rewards for each expert and each day. I programmed the multiplicative weights algorithm to react according to your choices. Click the image below to go to the demo.

This core mechanism of updating weights can be interpreted in many ways, and that’s part of the reason it has sprouted up all over mathematics and computer science. Just a few examples of where this has led:

1. In game theory, weights are the “belief” of a player about the strategy of an opponent. The most famous algorithm to use this is called Fictitious Play, and others include EXP3 for minimizing regret in the so-called “adversarial bandit learning” problem.
2. In machine learning, weights are the difficulty of a specific training example, so that higher weights mean the learning algorithm has to “try harder” to accommodate that example. The first result I’m aware of for this is the Perceptron (and similar Winnow) algorithm for learning hyperplane separators. The most famous is the AdaBoost algorithm.
3. Analogously, in optimization, the weights are the difficulty of a specific constraint, and this technique can be used to approximately solve linear and semidefinite programs. The approximation is because MWUA only provides a solution with some error.
4. In mathematical biology, the weights represent the fitness of individual alleles, and filtering reproductive success based on this and updating weights for successful organisms produces a mechanism very much like evolution. With modifications, it also provides a mechanism through which to understand sex in the context of evolutionary biology.
5. The TCP protocol, which basically defined the internet, uses additive and multiplicative weight updates (which are very similar in the analysis) to manage congestion.
6. You can get easy $\log(n)$-approximation algorithms for many NP-hard problems, such as set cover.

Additional, more technical examples can be found in this survey of Arora et al.

In the rest of this post, we’ll implement a generic Multiplicative Weights Update Algorithm, we’ll prove it’s main theoretical guarantees, and we’ll implement a linear program solver as an example of its applicability. As usual, all of the code used in the making of this post is available in a Github repository.

## The generic MWUA algorithm

Let’s start by writing down pseudocode and an implementation for the MWUA algorithm in full generality.

In general we have some set $X$ of objects and some set $Y$ of “event outcomes” which can be completely independent. If these sets are finite, we can write down a table $M$ whose rows are objects, whose columns are outcomes, and whose $i,j$ entry $M(i,j)$ is the reward produced by object $x_i$ when the outcome is $y_j$. We will also write this as $M(x, y)$ for object $x$ and outcome $y$. The only assumption we’ll make on the rewards is that the values $M(x, y)$ are bounded by some small constant $B$ (by small I mean $B$ should not require exponentially many bits to write down as compared to the size of $X$). In symbols, $M(x,y) \in [0,B]$. There are minor modifications you can make to the algorithm if you want negative rewards, but for simplicity we will leave that out. Note the table $M$ just exists for analysis, and the algorithm does not know its values. Moreover, while the values in $M$ are static, the choice of outcome $y$ for a given round may be nondeterministic.

The MWUA algorithm randomly chooses an object $x \in X$ in every round, observing the outcome $y \in Y$, and collecting the reward $M(x,y)$ (or losing it as a penalty). The guarantee of the MWUA theorem is that the expected sum of rewards/penalties of MWUA is not much worse than if one had picked the best object (in hindsight) every single round.

Let’s describe the algorithm in notation first and build up pseudocode as we go. The input to the algorithm is the set of objects, a subroutine that observes an outcome, a black-box reward function, a learning rate parameter, and a number of rounds.

def MWUA(objects, observeOutcome, reward, learningRate, numRounds):
...

We define for object $x$ a nonnegative number $w_x$ we call a “weight.” The weights will change over time so we’ll also sub-script a weight with a round number $t$, i.e. $w_{x,t}$ is the weight of object $x$ in round $t$. Initially, all the weights are $1$. Then MWUA continues in rounds. We start each round by drawing an example randomly with probability proportional to the weights. Then we observe the outcome for that round and the reward for that round.

# draw: [float] -> int
# pick an index from the given list of floats proportionally
# to the size of the entry (i.e. normalize to a probability
# distribution and draw according to the probabilities).
def draw(weights):
choice = random.uniform(0, sum(weights))
choiceIndex = 0

for weight in weights:
choice -= weight
if choice <= 0:
return choiceIndex

choiceIndex += 1

# MWUA: the multiplicative weights update algorithm
def MWUA(objects, observeOutcome, reward, learningRate numRounds):
weights = [1] * len(objects)
for t in numRounds:
chosenObjectIndex = draw(weights)
chosenObject = objects[chosenObjectIndex]

outcome = observeOutcome(t, weights, chosenObject)
thisRoundReward = reward(chosenObject, outcome)

...

Sampling objects in this way is the same as associating a distribution $D_t$ to each round, where if $S_t = \sum_{x \in X} w_{x,t}$ then the probability of drawing $x$, which we denote $D_t(x)$, is $w_{x,t} / S_t$. We don’t need to keep track of this distribution in the actual run of the algorithm, but it will help us with the mathematical analysis.

Next comes the weight update step. Let’s call our learning rate variable parameter $\varepsilon$. In round $t$ say we have object $x_t$ and outcome $y_t$, then the reward is $M(x_t, y_t)$. We update the weight of the chosen object $x_t$ according to the formula:

$\displaystyle w_{x_t, t} = w_{x_t} (1 + \varepsilon M(x_t, y_t) / B)$

In the more general event that you have rewards for all objects (if not, the reward-producing function can output zero), you would perform this weight update on all objects $x \in X$. This turns into the following Python snippet, where we hide the division by $B$ into the choice of learning rate:

# MWUA: the multiplicative weights update algorithm
def MWUA(objects, observeOutcome, reward, learningRate, numRounds):
weights = [1] * len(objects)
for t in numRounds:
chosenObjectIndex = draw(weights)
chosenObject = objects[chosenObjectIndex]

outcome = observeOutcome(t, weights, chosenObject)
thisRoundReward = reward(chosenObject, outcome)

for i in range(len(weights)):
weights[i] *= (1 + learningRate * reward(objects[i], outcome))

One of the amazing things about this algorithm is that the outcomes and rewards could be chosen adaptively by an adversary who knows everything about the MWUA algorithm (except which random numbers the algorithm generates to make its choices). This means that the rewards in round $t$ can depend on the weights in that same round! We will exploit this when we solve linear programs later in this post.

But even in such an oppressive, exploitative environment, MWUA persists and achieves its guarantee. And now we can state that guarantee.

Theorem (from Arora et al): The cumulative reward of the MWUA algorithm is, up to constant multiplicative factors, at least the cumulative reward of the best object minus $\log(n)$, where $n$ is the number of objects. (Exact formula at the end of the proof)

The core of the proof, which we’ll state as a lemma, uses one of the most elegant proof techniques in all of mathematics. It’s the idea of constructing a potential function, and tracking the change in that potential function over time. Such a proof usually has the mysterious script:

1. Define potential function, in our case $S_t$.
2. State what seems like trivial facts about the potential function to write $S_{t+1}$ in terms of $S_t$, and hence get general information about $S_T$ for some large $T$.
3. Theorem is proved.
4. Wait, what?

Clearly, coming up with a useful potential function is a difficult and prized skill.

In this proof our potential function is the sum of the weights of the objects in a given round, $S_t = \sum_{x \in X} w_{x, t}$. Now the lemma.

Lemma: Let $B$ be the bound on the size of the rewards, and $0 < \varepsilon < 1/2$ a learning parameter. Recall that $D_t(x)$ is the probability that MWUA draws object $x$ in round $t$. Write the expected reward for MWUA for round $t$ as the following (using only the definition of expected value):

$\displaystyle R_t = \sum_{x \in X} D_t(x) M(x, y_t)$

Then the claim of the lemma is:

$\displaystyle S_{t+1} \leq S_t e^{\varepsilon R_t / B}$

Proof. Expand $S_{t+1} = \sum_{x \in X} w_{x, t+1}$ using the definition of the MWUA update:

$\displaystyle \sum_{x \in X} w_{x, t+1} = \sum_{x \in X} w_{x, t}(1 + \varepsilon M(x, y_t) / B)$

Now distribute $w_{x, t}$ and split into two sums:

$\displaystyle \dots = \sum_{x \in X} w_{x, t} + \frac{\varepsilon}{B} \sum_{x \in X} w_{x,t} M(x, y_t)$

Using the fact that $D_t(x) = \frac{w_{x,t}}{S_t}$, we can replace $w_{x,t}$ with $D_t(x) S_t$, which allows us to get $R_t$

\displaystyle \begin{aligned} \dots &= S_t + \frac{\varepsilon S_t}{B} \sum_{x \in X} D_t(x) M(x, y_t) \\ &= S_t \left ( 1 + \frac{\varepsilon R_t}{B} \right ) \end{aligned}

And then using the fact that $(1 + x) \leq e^x$ (Taylor series), we can bound the last expression by $S_te^{\varepsilon R_t / B}$, as desired.

$\square$

Now using the lemma, we can get a hold on $S_T$ for a large $T$, namely that

$\displaystyle S_T \leq S_1 e^{\varepsilon \sum_{t=1}^T R_t / B}$

If $|X| = n$ then $S_1=n$, simplifying the above. Moreover, the sum of the weights in round $T$ is certainly greater than any single weight, so that for every fixed object $x \in X$,

$\displaystyle S_T \geq w_{x,T} \leq (1 + \varepsilon)^{\sum_t M(x, y_t) / B}$

Squeezing $S_t$ between these two inequalities and taking logarithms (to simplify the exponents) gives

$\displaystyle \left ( \sum_t M(x, y_t) / B \right ) \log(1+\varepsilon) \leq \log n + \frac{\varepsilon}{B} \sum_t R_t$

Multiply through by $B$, divide by $\varepsilon$, rearrange, and use the fact that when $0 < \varepsilon < 1/2$ we have $\log(1 + \varepsilon) \geq \varepsilon - \varepsilon^2$ (Taylor series) to get

$\displaystyle \sum_t R_t \geq \left [ \sum_t M(x, y_t) \right ] (1-\varepsilon) - \frac{B \log n}{\varepsilon}$

The bracketed term is the payoff of object $x$, and MWUA’s payoff is at least a fraction of that minus the logarithmic term. The bound applies to any object $x \in X$, and hence to the best one. This proves the theorem.

$\square$

Briefly discussing the bound itself, we see that the smaller the learning rate is, the closer you eventually get to the best object, but by contrast the more the subtracted quantity $B \log(n) / \varepsilon$ hurts you. If your target is an absolute error bound against the best performing object on average, you can do more algebra to determine how many rounds you need in terms of a fixed $\delta$. The answer is roughly: let $\varepsilon = O(\delta / B)$ and pick $T = O(B^2 \log(n) / \delta^2)$. See this survey for more.

## MWUA for linear programs

Now we’ll approximately solve a linear program using MWUA. Recall that a linear program is an optimization problem whose goal is to minimize (or maximize) a linear function of many variables. The objective to minimize is usually given as a dot product $c \cdot x$, where $c$ is a fixed vector and $x = (x_1, x_2, \dots, x_n)$ is a vector of non-negative variables the algorithm gets to choose. The choices for $x$ are also constrained by a set of $m$ linear inequalities, $A_i \cdot x \geq b_i$, where $A_i$ is a fixed vector and $b_i$ is a scalar for $i = 1, \dots, m$. This is usually summarized by putting all the $A_i$ in a matrix, $b_i$ in a vector, as

$x_{\textup{OPT}} = \textup{argmin}_x \{ c \cdot x \mid Ax \geq b, x \geq 0 \}$

We can further simplify the constraints by assuming we know the optimal value $Z = c \cdot x_{\textup{OPT}}$ in advance, by doing a binary search (more on this later). So, if we ignore the hard constraint $Ax \geq b$, the “easy feasible region” of possible $x$‘s includes $\{ x \mid x \geq 0, c \cdot x = Z \}$.

In order to fit linear programming into the MWUA framework we have to define two things.

1. The objects: the set of linear inequalities $A_i \cdot x \geq b_i$.
2. The rewards: the error of a constraint for a special input vector $x_t$.

Number 2 is curious (why would we give a reward for error?) but it’s crucial and we’ll discuss it momentarily.

The special input $x_t$ depends on the weights in round $t$ (which is allowed, recall). Specifically, if the weights are $w = (w_1, \dots, w_m)$, we ask for a vector $x_t$ in our “easy feasible region” which satisfies

$\displaystyle (A^T w) \cdot x_t \geq w \cdot b$

For this post we call the implementation of procuring such a vector the “oracle,” since it can be seen as the black-box problem of, given a vector $\alpha$ and a scalar $\beta$ and a convex region $R$, finding a vector $x \in R$ satisfying $\alpha \cdot x \geq \beta$. This allows one to solve more complex optimization problems with the same technique, swapping in a new oracle as needed. Our choice of inputs, $\alpha = A^T w, \beta = w \cdot b$, are particular to the linear programming formulation.

Two remarks on this choice of inputs. First, the vector $A^T w$ is a weighted average of the constraints in $A$, and $w \cdot b$ is a weighted average of the thresholds. So this this inequality is a “weighted average” inequality (specifically, a convex combination, since the weights are nonnegative). In particular, if no such $x$ exists, then the original linear program has no solution. Indeed, given a solution $x^*$ to the original linear program, each constraint, say $A_1 x^*_1 \geq b_1$, is unaffected by left-multiplication by $w_1$.

Second, and more important to the conceptual understanding of this algorithm, the choice of rewards and the multiplicative updates ensure that easier constraints show up less prominently in the inequality by having smaller weights. That is, if we end up overly satisfying a constraint, we penalize that object for future rounds so we don’t waste our effort on it. The byproduct of MWUA—the weights—identify the hardest constraints to satisfy, and so in each round we can put a proportionate amount of effort into solving (one of) the hard constraints. This is why it makes sense to reward error; the error is a signal for where to improve, and by over-representing the hard constraints, we force MWUA’s attention on them.

At the end, our final output is an average of the $x_t$ produced in each round, i.e. $x^* = \frac{1}{T}\sum_t x_t$. This vector satisfies all the constraints to a roughly equal degree. We will skip the proof that this vector does what we want, but see these notes for a simple proof. We’ll spend the rest of this post implementing the scheme outlined above.

## Implementing the oracle

Fix the convex region $R = \{ c \cdot x = Z, x \geq 0 \}$ for a known optimal value $Z$. Define $\textup{oracle}(\alpha, \beta)$ as the problem of finding an $x \in R$ such that $\alpha \cdot x \geq \beta$.

For the case of this linear region $R$, we can simply find the index $i$ which maximizes $\alpha_i Z / c_i$. If this value exceeds $\beta$, we can return the vector with that value in the $i$-th position and zeros elsewhere. Otherwise, the problem has no solution.

To prove the “no solution” part, say $n=2$ and you have $x = (x_1, x_2)$ a solution to $\alpha \cdot x \geq \beta$. Then for whichever index makes $\alpha_i Z / c_i$ bigger, say $i=1$, you can increase $\alpha \cdot x$ without changing $c \cdot x = Z$ by replacing $x_1$ with $x_1 + (c_2/c_1)x_2$ and $x_2$ with zero. I.e., we’re moving the solution $x$ along the line $c \cdot x = Z$ until it reaches a vertex of the region bounded by $c \cdot x = Z$ and $x \geq 0$. This must happen when all entries but one are zero. This is the same reason why optimal solutions of (generic) linear programs occur at vertices of their feasible regions.

The code for this becomes quite simple. Note we use the numpy library in the entire codebase to make linear algebra operations fast and simple to read.

def makeOracle(c, optimalValue):
n = len(c)

def oracle(weightedVector, weightedThreshold):
def quantity(i):
return weightedVector[i] * optimalValue / c[i] if c[i] > 0 else -1

biggest = max(range(n), key=quantity)
if quantity(biggest) < weightedThreshold:
raise InfeasibleException

return numpy.array([optimalValue / c[i] if i == biggest else 0 for i in range(n)])

return oracle

## Implementing the core solver

The core solver implements the discussion from previously, given the optimal value of the linear program as input. To avoid too many single-letter variable names, we use linearObjective instead of $c$.

def solveGivenOptimalValue(A, b, linearObjective, optimalValue, learningRate=0.1):
m, n = A.shape  # m equations, n variables
oracle = makeOracle(linearObjective, optimalValue)

def reward(i, specialVector):
...

def observeOutcome(_, weights, __):
...

numRounds = 1000
weights, cumulativeReward, outcomes = MWUA(
range(m), observeOutcome, reward, learningRate, numRounds
)
averageVector = sum(outcomes) / numRounds

return averageVector

First we make the oracle, then the reward and outcome-producing functions, then we invoke the MWUA subroutine. Here are those two functions; they are closures because they need access to $A$ and $b$. Note that neither $c$ nor the optimal value show up here.

    def reward(i, specialVector):
constraint = A[i]
threshold = b[i]
return threshold - numpy.dot(constraint, specialVector)

def observeOutcome(_, weights, __):
weights = numpy.array(weights)
weightedVector = A.transpose().dot(weights)
weightedThreshold = weights.dot(b)
return oracle(weightedVector, weightedThreshold)

## Implementing the binary search, and an example

Finally, the top-level routine. Note that the binary search for the optimal value is sophisticated (though it could be more sophisticated). It takes a max range for the search, and invokes the optimization subroutine, moving the upper bound down if the linear program is feasible and moving the lower bound up otherwise.

def solve(A, b, linearObjective, maxRange=1000):
optRange = [0, maxRange]

while optRange[1] - optRange[0] > 1e-8:
proposedOpt = sum(optRange) / 2
print("Attempting to solve with proposedOpt=%G" % proposedOpt)

# Because the binary search starts so high, it results in extreme
# reward values that must be tempered by a slow learning rate. Exercise
# to the reader: determine absolute bounds for the rewards, and set
# this learning rate in a more principled fashion.
learningRate = 1 / max(2 * proposedOpt * c for c in linearObjective)
learningRate = min(learningRate, 0.1)

try:
result = solveGivenOptimalValue(A, b, linearObjective, proposedOpt, learningRate)
optRange[1] = proposedOpt
except InfeasibleException:
optRange[0] = proposedOpt

return result

Finally, a simple example:

A = numpy.array([[1, 2, 3], [0, 4, 2]])
b = numpy.array([5, 6])
c = numpy.array([1, 2, 1])

x = solve(A, b, c)
print(x)
print(c.dot(x))
print(A.dot(x) - b)

The output:

Attempting to solve with proposedOpt=500
Attempting to solve with proposedOpt=250
Attempting to solve with proposedOpt=125
Attempting to solve with proposedOpt=62.5
Attempting to solve with proposedOpt=31.25
Attempting to solve with proposedOpt=15.625
Attempting to solve with proposedOpt=7.8125
Attempting to solve with proposedOpt=3.90625
Attempting to solve with proposedOpt=1.95312
Attempting to solve with proposedOpt=2.92969
Attempting to solve with proposedOpt=3.41797
Attempting to solve with proposedOpt=3.17383
Attempting to solve with proposedOpt=3.05176
Attempting to solve with proposedOpt=2.99072
Attempting to solve with proposedOpt=3.02124
Attempting to solve with proposedOpt=3.00598
Attempting to solve with proposedOpt=2.99835
Attempting to solve with proposedOpt=3.00217
Attempting to solve with proposedOpt=3.00026
Attempting to solve with proposedOpt=2.99931
Attempting to solve with proposedOpt=2.99978
Attempting to solve with proposedOpt=3.00002
Attempting to solve with proposedOpt=2.9999
Attempting to solve with proposedOpt=2.99996
Attempting to solve with proposedOpt=2.99999
Attempting to solve with proposedOpt=3.00001
Attempting to solve with proposedOpt=3
Attempting to solve with proposedOpt=3  # note %G rounds the printed values
Attempting to solve with proposedOpt=3
Attempting to solve with proposedOpt=3
Attempting to solve with proposedOpt=3
Attempting to solve with proposedOpt=3
Attempting to solve with proposedOpt=3
Attempting to solve with proposedOpt=3
Attempting to solve with proposedOpt=3
Attempting to solve with proposedOpt=3
Attempting to solve with proposedOpt=3
[ 0.     0.987  1.026]
3.00000000425
[  5.20000072e-02   8.49831849e-09]

So there we have it. A fiendishly clever use of multiplicative weights for solving linear programs.

## Discussion

One of the nice aspects of MWUA is it’s completely transparent. If you want to know why a decision was made, you can simply look at the weights and look at the history of rewards of the objects. There’s also a clear interpretation of what is being optimized, as the potential function used in the proof is a measure of both quality and adaptability to change. The latter is why MWUA succeeds even in adversarial settings, and why it makes sense to think about MWUA in the context of evolutionary biology.

This even makes one imagine new problems that traditional algorithms cannot solve, but which MWUA handles with grace. For example, imagine trying to solve an “online” linear program in which over time a constraint can change. MWUA can adapt to maintain its approximate solution.

The linear programming technique is known in the literature as the Plotkin-Shmoys-Tardos framework for covering and packing problems. The same ideas extend to other convex optimization problems, including semidefinite programming.

If you’ve been reading this entire post screaming “This is just gradient descent!” Then you’re right and wrong. It bears a striking resemblance to gradient descent (see this document for details about how special cases of MWUA are gradient descent by another name), but the adaptivity for the rewards makes MWUA different.

Even though so many people have been advocating for MWUA over the past decade, it’s surprising that it doesn’t show up in the general math/CS discourse on the internet or even in many algorithms courses. The Arora survey I referenced is from 2005 and the linear programming technique I demoed is originally from 1991! I took algorithms classes wherever I could, starting undergraduate in 2007, and I didn’t even hear a whisper of this technique until midway through my PhD in theoretical CS (I did, however, study fictitious play in a game theory class). I don’t have an explanation for why this is the case, except maybe that it takes more than 20 years for techniques to make it to the classroom. At the very least, this is one good reason to go to graduate school. You learn the things (and where to look for the things) which haven’t made it to classrooms yet.

Until next time!

# Adversarial Bandits and the Exp3 Algorithm

In the last twenty years there has been a lot of research in a subfield of machine learning called Bandit Learning. The name comes from the problem of being faced with a large sequence of slot machines (once called one-armed bandits) each with a potentially different payout scheme. The problems in this field all focus on one central question:

If I have many available actions with uncertain outcomes, how should I act to maximize the quality of my results over many trials?

The deep question here is how to balance exploitation, the desire to choose an action which has payed off well in the past, with exploration, the desire to try options which may produce even better results. The ideas are general enough that it’s hard not to find applications: choosing which drug to test in a clinical study, choosing which companies to invest in, choosing which ads or news stories to display to users, and even (as Richard Feynman once wondered) how to maximize your dining enjoyment.

Herbert Robbins, one of the first to study bandit learning algorithms. Image credit

In less recent times (circa 1960’s), this problem was posed and considered in the case where the payoff mechanisms had a very simple structure: each slot machine is a coin flip with a different probability $p$ of winning, and the player’s goal is to find the best machine as quickly as possible. We called this the “stochastic” setting, and last time we saw a modern strategy called UCB1 which maintained statistical estimates on the payoffs of the actions and chose the action with the highest estimate. The underlying philosophy was “optimism in the face of uncertainty,” and it gave us something provably close to optimal.

Unfortunately payoff structures are more complex than coin flips in the real world. Having “optimism” is arguably naive, especially when it comes to competitive scenarios like stock trading. Indeed the algorithm we’ll analyze in this post will take the polar opposite stance, that payoffs could conceivably operate in any manner. This is called the adversarial model, because even though the payoffs are fixed in advance of the game beginning, it can always be the case that the next choice you make results in the worst possible payoff.

One might wonder how we can hope to do anything in such a pessimistic model. As we’ll see, our notion of performing well is relative to the best single slot machine, and we will argue that this is the only reasonable notion of success. On the other hand, one might argue that real world payoffs are almost never entirely adversarial, and so we would hope that algorithms which do well theoretically in the adversarial model excel beyond their minimal guarantees in practice.

In this post we’ll explore and implement one algorithm for adversarial bandit learning, called Exp3, and in the next post we’ll see how it fares against UCB1 in some applications. Some prerequisites: since the main algorithm presented in this post is randomized, its analysis requires some familiarity with techniques and notation from probability theory. Specifically, we will assume that the reader is familiar with the content of this blog’s basic probability theory primers (1, 2), though the real difficulty in the analysis will be keeping up with all of the notation.

In case the reader is curious, Exp3 was invented in 2001 by Auer, Cesa-Bianchi, Freund, and Schapire. Here is their original paper, which contains lots of other mathematical goodies.

As usual, all of the code and data produced in the making of this blog post is available for download on this blog’s Github page.

## Model Formalization and Notions of Regret

Before we describe the algorithm and analyze its we have to set up the problem formally. The first few paragraphs of our last post give a high-level picture of general bandit learning, so we won’t repeat that here. Recall, however, that we have to describe both the structure of the payoffs and how success is measured. So let’s describe the former first.

Definition: An adversarial bandit problem is a pair $(K, \mathbf{x})$, where $K$ represents the number of actions (henceforth indexed by $i$), and $\mathbf{x}$ is an infinite sequence of payoff vectors $\mathbf{x} = \mathbf{x}(1), \mathbf{x}(2), \dots$, where $\mathbf{x}(t) = (x_1(t), \dots, x_K(t))$ is a vector of length $K$ and $x_i(t) \in [0,1]$ is the reward of action $i$ on step $t$.

In English, the game is played in rounds (or “time steps”) indexed by $t = 1, 2, \dots$, and the payoffs are fixed for each action and time before the game even starts. Note that we assume the reward of an action is a number in the interval $[0,1]$, but all of our arguments in this post can be extended to payoffs in some range $[a,b]$ by shifting by $a$ and dividing by $b-a$.

Let’s specify what the player (algorithm designer) knows during the course of the game. First, the value of $K$ is given, and total number of rounds is kept secret. In each round, the player has access to the history of rewards for the actions that were chosen by the algorithm in previous rounds, but not the rewards of unchosen actions. In other words, it will only ever know one $x_i(t)$ for each $t$. To set up some notation, if we call $i_1, \dots, i_t$ the list of chosen actions over $t$ rounds, then at step $t+1$ the player has access to the values of $x_{i_1}(1), \dots, x_{i_t}(t)$ and must pick $i_{t+1}$ to continue.

So to be completely clear, the game progresses as follows:

The player is given access to $K$.
For each time step $t$:

The player must pick an action $i_t$.
The player observes the reward $x_i(t) \in [0,1]$, which he may save for future use.

The problem gives no explicit limit on the amount of computation performed during each step, but in general we want it to run in polynomial time and not depend on the round number $t$. If runtime even logarithmically depended on $t$, then we’d have a big problem using it for high-frequency applications. For example in ad serving, Google processes on the order of $10^9$ ads per day; so a logarithmic dependence wouldn’t be that bad, but at some point in the distance future Google wouldn’t be able to keep up (and we all want long-term solutions to our problems).

Note that the reward vectors $\mathbf{x}_t$ must be fixed in advance of the algorithm running, but this still allows a lot of counterintuitive things. For example, the payoffs can depend adversarially on the algorithm the player decides to use. For example, if the player chooses the stupid strategy of always picking the first action, then the adversary can just make that the worst possible action to choose. However, the rewards cannot depend on the random choices made by the player during the game.

So now let’s talk about measuring success. For an algorithm $A$ which chooses the sequence $i_1, \dots, i_t$ of actions, define $G_A(t)$ to be the sum of the observed rewards

$\displaystyle G_A(t) = \sum_{s=1}^t x_{i_s}(s)$.

And because $A$ will often be randomized, this value is a random variable depending on the decisions made by $A$. As such, we will often only consider the payoff up to expectation. That is, we’ll be interested in how $\textup{E}(G_A(t))$ relates to other possible courses of action. To be completely rigorous, the randomization is not over “choices made by an algorithm,” but rather the probability distribution over sequences of actions that the algorithm induces. It’s a fine distinction but a necessary one. In other words, we could define any sequence of actions $\mathbf{j} = (j_1, \dots, j_t)$ and define $G_{\mathbf{j}}(t)$ analogously as above:

$\displaystyle G_{\mathbf{j}}(t) = \sum_{s=1}^t x_{j_s}(s)$.

Any algorithm and choice of reward vectors induces a probability distribution over sequences of actions in a natural way (if you want to draw from the distribution, just run the algorithm). So instead of conditioning our probabilities and expectations on previous choices made by the algorithm, we do it over histories of actions $i_1, \dots, i_t$.

An obvious question we might ask is: why can’t the adversary just make all the payoffs zero? (or negative!) In this event the player won’t get any reward, but he can emotionally and psychologically accept this fate. If he never stood a chance to get any reward in the first place, why should he feel bad about the inevitable result? What a truly cruel adversary wants is, at the end of the game, to show the player what he could have won, and have it far exceed what he actually won. In this way the player feels regret for not using a more sensible strategy, and likely turns to binge eating cookie dough ice cream. Or more likely he returns to the casino to lose more money. The trick that the player has up his sleeve is precisely the randomness in his choice of actions, and he can use its objectivity to partially overcome even the nastiest of adversaries.

The adversary would love to show you this bluff after you choose to fold your hand. What a jerk. Image credit

Sadism aside, this thought brings us to a few mathematical notions of regret that the player algorithm may seek to minimize. The first, most obvious, and least reasonable is the worst-case regret. Given a stopping time $T$ and a sequence of actions $\mathbf{j} = (j_1, \dots, j_T)$, the expected regret of algorithm $A$ with respect to $\mathbf{j}$ is the difference $G_{\mathbf{j}}(T) - \mathbb{E}(G_A(T))$. This notion of regret measures the regret of a player if he knew what would have happened had he played $\mathbf{j}$.  The expected worst-case regret of $A$ is then the maximum over all sequences $\mathbf{j}$ of the regret of $A$ with respect to $\mathbf{j}$. This notion of regret seems particularly unruly, especially considering that the payoffs are adversarial, but there are techniques to reason about it.

However, the focus of this post is on a slightly easier notion of regret, called weak regret, which instead compares the results of $A$ to the best single action over all rounds. That is, this quantity is just

$\displaystyle \left ( \max_{j} \sum_{t=1}^T x_j(t) \right ) - \mathbb{E}(G_A(T))$

We call the parenthetical term $G_{\textup{max}}(T)$. This kind of regret is a bit easier to analyze, and the main theorem of this post will given an upper bound on it for Exp3. The reader who read our last post on UCB1 will wonder why we make a big distinction here just to arrive at the same definition of regret that we had in the stochastic setting. But with UCB1 the best sequence of actions to take just happened to be to play the best action over and over again. Here, the payoff difference between the best sequence of actions and the best single action can be arbitrarily large.

## Exp3 and an Upper Bound on Weak Regret

We now describe at the Exp3 algorithm.

Exp3 stands for Exponential-weight algorithm for Exploration and Exploitation. It works by maintaining a list of weights for each of the actions, using these weights to decide randomly which action to take next, and increasing (decreasing) the relevant weights when a payoff is good (bad). We further introduce an egalitarianism factor $\gamma \in [0,1]$ which tunes the desire to pick an action uniformly at random. That is, if $\gamma = 1$, the weights have no effect on the choices at any step.

The algorithm is readily described in Python code, but we need to set up some notation used in the proof of the theorem. The pseudocode for the algorithm is as follows.

Exp3

1. Given $\gamma \in [0,1]$, initialize the weights $w_i(1) = 1$ for $i = 1, \dots, K$.
2. In each round $t$:
1.  Set $\displaystyle p_i(t) = (1-\gamma)\frac{w_i(t)}{\sum_{j=1}^K w_j(t)} + \frac{\gamma}{K}$ for each $i$.
2. Draw the next action $i_t$ randomly according to the distribution of $p_i(t)$.
3. Observe reward $x_{i_t}(t)$.
4. Define the estimated reward $\hat{x}_{i_t}(t)$ to be $x_{i_t}(t) / p_{i_t}(t)$.
5. Set $\displaystyle w_{i_t}(t+1) = w_{i_t}(t) e^{\gamma \hat{x}_{i_t}(t) / K}$
6. Set all other $w_j(t+1) = w_j(t)$.

The choices of these particular mathematical quantities (in steps 1, 4, and 5) are a priori mysterious, but we will explain them momentarily. In the proof that follows, we will extend $\hat{x}_{i_t}(t)$ to indices other than $i_t$ and define those values to be zero.

The Python implementation is perhaps more legible, and implements the possibly infinite loop as a generator:

def exp3(numActions, reward, gamma):
weights = [1.0] * numActions

t = 0
while True:
probabilityDistribution = distr(weights, gamma)
choice = draw(probabilityDistribution)
theReward = reward(choice, t)

estimatedReward = 1.0 * theReward / probabilityDistribution[choice]
weights[choice] *= math.exp(estimatedReward * gamma / numActions) # important that we use estimated reward here!

yield choice, theReward, estimatedReward, weights
t = t + 1

Here the “rewards” variable refers to a callable which accepts as input the action chosen in round $t$ (keeps track of $t$, assuming we’ll play nice), and returns as output the reward for that choice. The distr and draw functions are also easily defined, with the former depending on the gamma parameter as follows:

def distr(weights, gamma=0.0):
theSum = float(sum(weights))
return tuple((1.0 - gamma) * (w / theSum) + (gamma / len(weights)) for w in weights)

There is one odd part of the algorithm above, and that’s the “estimated reward” $\hat{x}_{i_t}(t) = x_{i_t}(t) / p_{i_t}(t)$. The intuitive reason to do this is to compensate for a potentially small probability of getting the observed reward. More formally, it ensures that the conditional expectation of the “estimated reward” is the actual reward. We will explore this formally during the proof of the main theorem.

As usual, the programs we write in this post are available on this blog’s Github page.

We can now state and prove the upper bound on the weak regret of Exp3. Note all logarithms are base $e$.

Theorem: For any $K > 0, \gamma \in (0, 1]$, and any stopping time $T \in \mathbb{N}$

$\displaystyle G_{\textup{max}}(T) - \mathbb{E}(G_{\textup{Exp3}}(T)) \leq (e-1)\gamma G_{\textup{max}}(T) + \frac{K \log K}{\gamma}$.

This is a purely analytical result because we don’t actually know what $G_{\textup{max}}(T)$ is ahead of time. Also note how the factor of $\gamma$ occurs: in the first term, having a large $\gamma$ will result in a poor upper bound because it occurs in the numerator of that term: too much exploration means not enough exploitation. But it occurs in the denominator of the second term, meaning that not enough exploration can also produce an undesirably large regret. This theorem then provides a quantification of the tradeoff being made, although it is just an upper bound.

Proof.

We present the proof in two parts. Part 1:

We made a notable mistake in part 1, claiming that $e^x \leq 1 + x + (e-2)x^2$ when $x \leq 1$. In fact, this does follow from the Taylor series expansion of $e$, but it’s not as straightforward as I made it sound. In particular, note that $e^x = 1 + x + \frac{x^2}{2!} + \dots$, and so $e^1 = 2 + \sum_{k=2}^\infty \frac{1}{k!}$. Using $(e-2)$ in place of $\frac{1}{2}$ gives

$\displaystyle 1 + x + \left ( \sum_{k=2}^{\infty} \frac{x^2}{k!} \right )$

And since $0 < x \leq 1$, each term in the sum will decrease when replaced by $\frac{x^k}{k!}$, and we’ll be left with exactly $e^x$. In other words, this is the tightest possible quadratic upper bound on $e^x$. Pretty neat! On to part 2:

As usual, here is the entire canvas made over the course of both videos.

$\square$

We can get a version of this theorem that is easier to analyze by picking a suitable choice of $\gamma$.

Corollary: Assume that $G_{\textup{max}}(T)$ is bounded by $g$, and that Exp3 is run with

$\displaystyle \gamma = \min \left ( 1, \sqrt{\frac{K \log K}{(e-1)g}} \right )$

Then the weak regret of Exp3 is bounded by $2.63 \sqrt{g K \log K}$ for any reward vector $\mathbf{x}$.

Proof. Simply plug $\gamma$ in the bound in the theorem above, and note that $2 \sqrt{e-1} < 2.63$.

## A Simple Test Against Coin Flips

Now that we’ve analyzed the theoretical guarantees of the Exp3 algorithm, let’s use our implementation above and see how it fares in practice. Our first test will use 10 coin flips (Bernoulli trials) for our actions, with the probabilities of winning (and the actual payoff vectors) defined as follows:

biases = [1.0 / k for k in range(2,12)]
rewardVector = [[1 if random.random() < bias else 0 for bias in biases] for _ in range(numRounds)]
rewards = lambda choice, t: rewardVector[t][choice]

If we are to analyze the regret of Exp3 against the best action, we must compute the payoffs for all actions ahead of time, and compute which is the best. Obviously it will be the one with the largest probability of winning (the first in the list generated above), but it might not be, so we have to compute it. Specifically, it’s the following argmax:

bestAction = max(range(numActions), key=lambda action: sum([rewardVector[t][action] for t in range(numRounds)]))

Where the max function is used as “argmax” would be in mathematics.

We also have to pick a good choice of $\gamma$, and the corollary from the previous section gives us a good guide to the optimal $\gamma$: simply find a good upper bound on the reward of the best action, and use that. We can cheat a little here: we know the best action has a probability of 1/2 of paying out, and so the expected reward if we always did the best action is half the number of rounds. If we use, say, $g = 2T / 3$ and compute $\gamma$ using the formula from the corollary, this will give us a reasonable (but perhaps not perfectly correct) upper bound.

Then we just run the exp3 generator for $T = \textup{10,000}$ rounds, and compute some statistics as we go:

bestUpperBoundEstimate = 2 * numRounds / 3
gamma = math.sqrt(numActions * math.log(numActions) / ((math.e - 1) * bestUpperBoundEstimate))
gamma = 0.07

cumulativeReward = 0
bestActionCumulativeReward = 0
weakRegret = 0

t = 0
for (choice, reward, est, weights) in exp3(numActions, rewards, gamma):
cumulativeReward += reward
bestActionCumulativeReward += rewardVector[t][bestAction]

weakRegret = (bestActionCumulativeReward - cumulativeReward)
regretBound = (math.e - 1) * gamma * bestActionCumulativeReward + (numActions * math.log(numActions)) / gamma

t += 1
if t >= numRounds:
break

At the end of one run of ten thousand rounds, the weights are overwhelmingly in favor of the best arm. The cumulative regret is 723, compared to the theoretical upper bound of 897. It’s not too shabby, but by tinkering with the value of $\gamma$ we see that we can get regrets lower than 500 (when $\gamma$ is around 0.7). Considering that the cumulative reward for the player is around 4,500 in this experiment, that means we spent only about 500 rounds out of ten thousand exploring non-optimal options (and also getting unlucky during said exploration). Not too shabby at all.

Here is a graph of a run of this experiment.

A run of Exp3 against Bernoulli rewards. The first graph represents the simple regret of the player algorithm against the best action; the blue line is the actual simple regret, and the green line is the theoretical O(sqrt(k log k)) upper bound. The second graph shows the weights of each action evolving over time. The blue line is the weight of the best action, while the green and red lines are the weights of the second and third best actions.

Note how the Exp3 algorithm never stops increasing its regret. This is in part because of the adversarial model; even if Exp3 finds the absolutely perfect action to take, it just can’t get over the fact that the world might try to screw it over. As long as the $\gamma$ parameter is greater than zero, Exp3 will explore bad options just in case they turn out to be good. The benefits of this is that if the model changes over time Exp3 will adapt, but the downside is that the pessimism inherent in this worldview generally results in lower payoffs than other algorithms.

## More Variations, and Future Plans

Right now we have two contesting models of how the world works: is it stochastic and independent, like the UCB1 algorithm would optimize for? Or does it follow Exp3’s world view that the payoffs are adversarial? Next time we’ll run some real-world tests to see how each fares.

But before that, we should note that there are still more models we haven’t discussed. One extremely significant model is that of contextual bandits. That is, the real world settings we care about often come with some “context” associated with each trial. Ads being displayed to users have probabilities that should take into account the information known about the user, and medical treatments should take into account past medical history. While we will not likely investigate any contextual bandit algorithms on this blog in the near future, the reader who hopes to apply this work to his or her own exploits (no pun intended) should be aware of the additional reading.

Until next time!

Postscript: years later, a cool post by Tim Vieira shows a neat data structure that asymptotically speeds up the update/sample step of the EXP3 algorithm from linear to logarithmic (among others). The weights are stored in a heap of partial sums (the leaves are the individual weights), and sampling is a binary search. See the original post and the accompanying gist for an implementation. Exercise: implement the data structure for use with our EXP3 implementation.


text:
# 301 Redirect for PDF file

What's the easiest way to go about redirecting a URL like this:

http://domain.tld/my%20file.pdf

To another URL:

http://anotherdomain.tld/another%20file.pdf

This is a website and I do have access to IIS (6). Is there a way to do this just within IIS?

I've read a little about ISAPI plug-ins, though I've never done this. Is this the only way? I've been handed a site I haven't yet been able to build (just using Open Website... in VS 2010.) So I'm not even sure I can write an HTTP module if that's another option. My current error has something to do with an English section that has another web.config.

Error 6 It is an error to use a section registered as allowDefinition='MachineToApplication' beyond application level. This error can be caused by a virtual directory not being configured as an application in IIS. C:\path\to\site\englishsubdirectory\app\Web.config

-
redirect question: microsoft.com/technet/prodtechnol/WindowsServer2003/Library/IIS/…, check if this is of any help –  Sreenath S Sep 11 '12 at 15:50
@SreenathSoman Can you put that in an answer? I misread, and I just had to click down the file itself in IIS and add the redirect there. –  David Sep 11 '12 at 16:11


text:
# Bicycle Lock Combination

My bicycle lock looks like this:

This rebus helps me remember the combination:

I read it left to right, top to bottom.

What's the combination, and why?

• If this is solved, why isn't it marked as answered? – qwertylpc Jul 16 '15 at 19:47
• @qwertylpc Well, it's because many (most?) people see a puzzle that has already been solved, and are not interested in it, since it is solved. If I wait a few hours to accept an answer, then more people get to enjoy it, and see it, and as a bonus, more people might up-vote it. Also, in some cases a late answer may be better than the original correct answer, and that puzzler might not have even looked at the puzzle if it was already accepted. – JLee Jul 16 '15 at 19:49
• As an aside, please don't use that lock to lock an actual bike. A cable lock is, at best, a mild inconvenience to thieves. All it means is they have to use bolt cutters to steal your bike in seconds, instead of just riding off on it. – David Richerby Jul 17 '15 at 7:23
• @DavidRicherby shhh don't give them ideas! ;) – JLee Jul 17 '15 at 13:55

21210

This is found by

Shifting the letters in each word by the number indicated to get the name of a number and then combining their digits.

Therefore, the pieces are:

LOG $\Rightarrow$ TWO
BAR $\Rightarrow$ ONE
RUM $\Rightarrow$ TWO
UFO $\Rightarrow$ TEN

• nicely done. will you add to your answer, "If you upvote this answer, please also upvote the puzzle" ? haha jk – JLee Jul 16 '15 at 19:09
• @JLee Well, I gave it +1 at least. It's not something I've seen before. It took me an extra minute to realize that WOOD+8 didn't mean anything. – Engineer Toast Jul 16 '15 at 19:13
• Where does the final zero come from? – COTO Jul 16 '15 at 21:31
• @COTO From the ten. – Engineer Toast Jul 16 '15 at 21:32
• Oh... right. You know, that right there would have disqualified the correct solution for me, because not only would such an interpretation be missing a digit, the fourth number would overflow the counter. You just blew my mind. :D – COTO Jul 16 '15 at 21:38


text:
# 0.1 Lab 1 - discrete and continuous-time signals

 Page 1 / 5

Questions or comments concerning this laboratory should be directedto Prof. Charles A. Bouman, School of Electrical and Computer Engineering, Purdue University, West Lafayette IN 47907;(765) 494-0340; bouman@ecn.purdue.edu

## Introduction

The purpose of this lab is to illustrate the properties of continuous and discrete-time signals using digital computersand the Matlab software environment. A continuous-time signal takes on a value at every pointin time, whereas a discrete-time signal is only defined at integer values of the “time” variable.However, while discrete-time signals can be easily stored and processed on a computer,it is impossible to store the values of a continuous-time signal for all points along a segment of the real line.In later labs, we will see that digital computers are actuallyrestricted to the storage of quantized discrete-time signals. Such signals are appropriately known as digital signals.

How then do we process continuous-time signals? In this lab, we will show that continuous-time signalsmay be processed by first approximating them by discrete-time signals using a process knownas sampling. We will see that proper selectionof the spacing between samples is crucial for an efficient and accurate approximationof a continuous-time signal. Excessively close spacing will lead to too much data,whereas excessively distant spacing will lead to a poor approximation of the continuous-time signal.Sampling will be an important topic in future labs, but for now we will use sampling to approximatelycompute some simple attributes of both real and synthetic signals.

Be sure to read the guidelines for the written reports.

## Matlab review

Practically all lab tasks in the ECE438 lab will be performed using Matlab. Matlab (MATrix LABoratory) is a technical computing environmentfor numerical analysis, matrix computation, signal processing, and graphics.In this section, we will review some of its basic functions. For a short tutorial and some Matlab examples click here .

## Starting matlab and getting help

You can start Matlab (version 7.0) on your workstation by typing the command

matlab

in a command window. After starting up, you will get a Matlab window.To get help on any specific command, such as “plot”, you can type the following

help plot

in the “Command Window” portion of the Matlab window. You can do a keyword search for commands related to a topic by using thefollowing.

lookfor topic

You can get an interactive help window using the function

helpdesk

or by following the Help menu near the top of the window.

## Matrices and operations

Every element in Matlab is a matrix. So, for example, the Matlab command

$a=\left[\begin{array}{ccc}1& 2& 3\end{array}\right]$

creates a matrix named “ $a$ ” with dimensions of $1×3$ . The variable “ $a$ ” is stored in what is called the Matlab workspace. The operation

$b=a.\text{'}$

stores the transpose of “ $a$ ” into the vector “ $b$ ”. In this case, “ $b$ ” is a $3×1$ vector.

Since each element in Matlab is a matrix, the operation

$c=a*b$

computes the matrix product of “ $a$ ” and “ $b$ ” to generate a scalarvalue for “ $c$ ” of $14=1*1\phantom{\rule{3.33333pt}{0ex}}+\phantom{\rule{3.33333pt}{0ex}}2*2\phantom{\rule{3.33333pt}{0ex}}+\phantom{\rule{3.33333pt}{0ex}}3*3\phantom{\rule{2pt}{0ex}}\text{.}$

so some one know about replacing silicon atom with phosphorous in semiconductors device?
how to fabricate graphene ink ?
for screen printed electrodes ?
SUYASH
What is lattice structure?
of graphene you mean?
Ebrahim
or in general
Ebrahim
in general
s.
Graphene has a hexagonal structure
tahir
On having this app for quite a bit time, Haven't realised there's a chat room in it.
Cied
what is biological synthesis of nanoparticles
what's the easiest and fastest way to the synthesize AgNP?
China
Cied
types of nano material
I start with an easy one. carbon nanotubes woven into a long filament like a string
Porter
many many of nanotubes
Porter
what is the k.e before it land
Yasmin
what is the function of carbon nanotubes?
Cesar
I'm interested in nanotube
Uday
what is nanomaterials and their applications of sensors.
what is nano technology
what is system testing?
preparation of nanomaterial
Yes, Nanotechnology has a very fast field of applications and their is always something new to do with it...
what is system testing
what is the application of nanotechnology?
Stotaw
In this morden time nanotechnology used in many field . 1-Electronics-manufacturad IC ,RAM,MRAM,solar panel etc 2-Helth and Medical-Nanomedicine,Drug Dilivery for cancer treatment etc 3- Atomobile -MEMS, Coating on car etc. and may other field for details you can check at Google
Azam
anybody can imagine what will be happen after 100 years from now in nano tech world
Prasenjit
after 100 year this will be not nanotechnology maybe this technology name will be change . maybe aftet 100 year . we work on electron lable practically about its properties and behaviour by the different instruments
Azam
name doesn't matter , whatever it will be change... I'm taking about effect on circumstances of the microscopic world
Prasenjit
how hard could it be to apply nanotechnology against viral infections such HIV or Ebola?
Damian
silver nanoparticles could handle the job?
Damian
not now but maybe in future only AgNP maybe any other nanomaterials
Azam
Hello
Uday
I'm interested in Nanotube
Uday
this technology will not going on for the long time , so I'm thinking about femtotechnology 10^-15
Prasenjit
can nanotechnology change the direction of the face of the world
At high concentrations (>0.01 M), the relation between absorptivity coefficient and absorbance is no longer linear. This is due to the electrostatic interactions between the quantum dots in close proximity. If the concentration of the solution is high, another effect that is seen is the scattering of light from the large number of quantum dots. This assumption only works at low concentrations of the analyte. Presence of stray light.
the Beer law works very well for dilute solutions but fails for very high concentrations. why?
how did you get the value of 2000N.What calculations are needed to arrive at it
Privacy Information Security Software Version 1.1a
Good
Got questions? Join the online conversation and get instant answers!


text:
# Adding headrests to the back seat of a 2000 Jeep Cherokee (XJ) - Part One

My kid has outgrown his booster seat, but we have continued to use it for far too long because the back seat of my Jeep has no headrests. I set about solving that problem today.

I did some research on the internet and found that the back seat headrest brackets from early 2000 Jeep Grand Cherokees will fit the frame of the XJ back seats. Also, the back seat foam form actually has partial cut-outs for brackets because Jeep sold some Cherokee models in non-US markets that did have head rests.

Off to the pick-n-pull. At my junkyard, of course the Grand Cherokees were in the very last row of the lot…

Here is the donor vehicle, a 2000 Jeep Grand Cherokee.

The seat backs are held in by a single two-bolt bracket each. The bolts are 15mm. The bracket between the two sections are actually slide-in posts, so once you have the door-side bracket loose, you can just slip the seat off the middle bracket on each side.
Here I am field skinning the seats. Bring a bigger knife than my puny Victorinox Swiss Army Classic SD… it took me forever to get the “hide” off the seats. Spend the time to take the release levers and lower brackets off – it’ll be a lot less weight to carry back to the cashier. To do this you’ll again need a 15mm socket and Philips screwdriver.

I paid about $7.50 for each headrest and$4.85 for each of the seatbacks, total of \$27 after tax. Stripping the seat down to the metal will probably save you some money, as they look pretty spartan.

The plastic post holders will come out with a quarter turn clockwise twist. Make note of the number/letter combo on the side of the plastic post and mark the bracket (I had B2, B4, B5 and B8). Also make sure to note which side you took each bracket from.
I’m not sure it makes a huge difference if you mixed them up, but I’m a perfectionist (when I try to be).

I used an angle grinder to cut away the seat back around the brackets and clear away the welds holding the brackets to the main seat back frame. Keep the sections of the original frame backing that you removed as they will work as perfect spacers behind the brackets.

Now you’ll need to remove the seat from your Cherokee and strip it down to the frame. My seat was actually built way better than the Grand Cherokee seat backs as it has zippers all around. I put some zip ties in the zipper pulls to make it a bit easier to pull them along. You’ll want to remove the two screws holding down the lock release bracket on either side. You will not need to remove these parts, but when the brackets are loose you can easily get to the zippers. This will ease the removal of the cover. Slide your hands inside between the seat cover and the foam to release the velcro that is holding the cover to the foam. Remove the cover. The foam will easily lift out of the frame.

I decided to drill out the rivets holding the bar that connects to the lock release levers to each other. This is because it interferes with the path of the headrest posts and wouldn’t allow the headrest to be pushed all the way down to the top of the seat back. It’ll make it a bit tougher for a single person to unlock the seat back to lay it down, but I’m ok with that.

You’ll want to mark the seat back frame on either side of the bracket openings on the inside of the foam – this will allow you to figure out where the center the brackets. You’ll eventually need to remove some foam to make room for the new brackets, but we’ll save that for until we weld them in an know exactly what we need to remove.

I’m not a welder (yet) so I decided to drill a hole to hold the bracket in the desired location until I’m able to get someone to help me with the welding part. I trimmed down the saved frame parts from the original Grand Cherokee seat backs to use as spacers at the top of the bracket. Put the plastic guides back in so you’ll be able to align the final position of the bracket. I made it so the top of the inside post guide was flush with the top of the metal frame and rested just a few millimeters from the front edge.

I made sure to mark up the intersections with a sharpie so that my welder friend will be be able to easily line up the bracket prior to welding it in place. UPDATE: See Part Two as to why I think I should have mounted these higher than I did.

That’s it for part one. I’ll add more once I’ve got the bracket welded in place and get the foam and cover back on my seat back.

UPDATE! I finished! Check out Part Two!


text:
-->
Page 1 of 1

### Help compiling using esp-open-sdk

Posted: Mon May 13, 2019 8:35 am
Hi,

I compile the esp-non-os-sdk using esp-open-sdk, however, I want to make some changes to the mbedtls library but have had no luck as it doesn't seem to compile my changes.

Does anybody have experience with esp-open-sdk?

https://github.com/pfalcon/esp-open-sdk

### Re: Help compiling using esp-open-sdk

Posted: Mon May 13, 2019 10:19 am
What is it doing? It should compile OK.

The other approach is to just compile the toolchain and then use the mbedTLS that is shipped with the NonOS SDK (third_party directory) as your starting point

### Re: Help compiling using esp-open-sdk

Posted: Tue May 14, 2019 7:07 am

So, I maybe didn't explain myself well, sorry. It does compile fine, but doesn't take my changes.
I am changing the following file:

third_party\include\mbedtls\config_esp.h

Then as a test I only enable tlsv1.1 (MBEDTLS_SSL_PROTO_TLS1_1) and disable (comment) the rest. However my mqtt continues using TLS1.2 to connect to the broker...

So not sure what exactly I need to change for this to get compiled...

### Re: Help compiling using esp-open-sdk

Posted: Fri Sep 20, 2019 3:09 am