## convex optimization – proof of the min max theorem, equivalence of duality problems, how to do it?

I'm trying to prove the min-max theorem. In this one, I have to prove the following equivalence of the linear program (one is the duplicate of the other):

$$max {x_0 mid textbf {1} x_0 – A ^ T x leq 0, sum x_i = 1, x > geq 0 }.$$ $$fs$$

$$min {y_0 mid textbf {1} y_0 – A y geq 0, sum y_i = 1, y geq > 0 }.$$

How to do ?

## postgresql – SELECT Optimization in Postgres 10

My crystal ball says that both queries end up using different query plans. You can check by running `EXPLAIN` on each. More useful details with `EXPLAIN (ANALYSIS, BUFFER)`.

The subquery gets the biggest `login` with `time_track` more than 5 minutes before the biggest one `login` together in the table `eco.tracks`. Assuming a strong positive correlation between `login` and `time_track`, humans have a rough idea of ​​the work to be done here: this only concerns the (probably very few) last rows of the last 5 minutes of the painting. But Postgres has no idea when planning the query.

(Except: he can to be a persistent logical bug assuming that serial IDs are synchronized with column timestamps `time_track`. Not enough information to say more.)

For the first request (slow), Postgres must prepare a plan that fits best with all value that could come out of the subquery. This can very well be a sequential analysis, which turns out to be a bad choice for the last few lines only.

For the second request (fast), Postgres know the value given to what to expect. It can start by identifying the few relevant lines with an index or bitmap index on an index on `(Id)` which probably exists (again supposing it's the PK). The rest is peanuts.

## Possible solutions

### 1. Run two separate queries.

Simple death. Build the second query with the actual value returned by the first. the disadvantage: two round trips to the database server collecting twice the latency of the network and a variable overload.

### 2. Dynamic SQL

``````CREATE OR REPLACE FUNCTION f_latest_tracks (_intv interval = 300 seconds & # 39;)
SETOF RETURNS eco.tracks AS
\$ func \$
TO START

BACK QUERY EXECUTE
& # 39; SELECT DISTINCT ON (track) *
DE eco.tracks O ID> 1 \$
ORDER BY, time_track DESC & # 39;
USING (
SELECT ID
DE eco.tracks
WHERE time_track <(SELECT time_track - _intv FROM eco.tracks ORDER BY id DESC LIMIT 1)
ORDER BY id DESC
LIMIT 1
)

END
\$ func \$ LANGUAGE plpgsql;
``````

Call:

``````SELECT * FROM f_latest_tracks ();
SELECT * FROM f_latest_tracks (& # 39; 10 minutes & # 39;);
``````

Why? The manual on Run dynamic commands:

The important difference is that `RUN` will re-schedule the order on
each run, generating a specific plan aware
parameter values; whereas PL / pgSQL can otherwise create a generic plan
and the cache for reuse. In situations where the best plan depends
strongly on the values ​​of the parameters, it may be useful to use `RUN` at
ensure positively that no generic plan is selected.

Disadvantage: You must create a server-side function that introduces a dependency on the table `eco.tracks`. And you must of course be comfortable with PL / pgSQL.

There are other ways. Anything that can get Postgres to choose the appropriate query plan …

## optimization – how to optimize the next energy in ADMM?

$$E ( mathbf {p} # i, mathbf {w}) = sum_i sum_ {j in N (i)} c_ {ij} | ( mathbf {p}

could this function be solved without the third term?

if rewrite the function as a normal equation, $$mathbf {x} =[mathbf{p’},mathbf{w}]$$, in admm, $$mathbf {x}$$ is optimized by
$$mathbf {x} _ {k + 1} = (A ^ TA + rho I) ^ {- 1} (A ^ T + rho ( mathbf {z} _k- mathbf {u} _k))$$
but $$mathbf {w}$$ is sub-vector of $$mathbf {x}$$, how to treat this case?

and how to add the third term in optimization?

## Optimization – What is the first moment where a blind character could be passed as well as Zatoichi?

enemies of the same insight who have a higher equivalent rank of the school.

It's very ambiguous. Insight and rank of school are not necessarily a good indication of combat prowess, this is not even a good indication of the amount of experience spent by the samurai. A courtier who has spent all his XP in rings and combat skills will crush a bushi who has taken Way of the Daimyo and who has focused on effectively managing their Gentry.

By definition, a character with Blind will be at a disadvantage compared to anyone with the same skills. As Ben Barden said, Zatoichi is able to win because it's just better than the people he's fighting.

My only knowledge of Zatoishi is the linked page of TVTropes and some youtube clips. Therefore, I will answer the question "what can a ronin do to mitigate the effects of blind disadvantage".

Kenku is known to train people worthy of their Kenku Swordsman school (Enemies p.180). This embodies the trope master sword better than the Ronin generic school and many ronin Paths and Advanced schools. It also rewards the obvious expectation that your enemies are coming to you and mitigates some of the penalties for blindness.

Moonlight Rider (Enemies p.201) has a combat technique in the dark that, according to the interpretation of your GM, could eliminate your penalties for blindness while you fight in the dark.

Little Truths, a supplement for a well done fan, contains a somewhat less debilitating version of Blind Disadvantage (p.20) and Blind Swordsman Path (p.29) for Ronin that you might want to introduce to your GM.

Individual workarounds
1. penalty for attack rolls: There are countless ways to add bonuses to attack rolls. advantages, accents, skills, attributes, you choose.
2 ATN penalty: Zatoishi seems to solve this problem mainly by killing his opponents at once, preventing them from attacking him in the first place, to obtain the highest possible strength and to bet on the control abilities of the opponent. Kenjutsu to increase the damage to the sword. Otherwise, since most defensive kata are out of your reach, try Friend of the Brotherhood and go for Kiho.
3 Penalties of movementAthletics / agility of 7k3 will be enough to pass the TN20 test 90% of the time. The kata Hitting like water will give you back some of the mobility you lose.
4 penalties of perception: Audience-based investigations would be a good start. Beyond that, the Kiho Awareness Sense Eight is all I can think of.

## Convex Optimization – Proven Subspace \$ V = C-x_ {0} = left {x-x_ {0} | x in C subseteq R ^ n right } \$ associated with the affine set \$ C \$ does not depend on the choice of \$ x_0 \$

Subspace $$V = C-x_ {0} = left {x-x_ {0} | x in C subseteq R ^ n right$$ associated with the whole affine $$C$$ does not depend on the choice of $$x_0 in C$$, that is to say. $$V$$ are the same regardless of $$x_0$$

My essay:
For $$V_0 = C-x_ {0} = left {x-x_ {0} | x in C right$$ and $$V_1 = C-x_ {1} = left {x-x_ {1} | x in C right$$
assume $$v_0 in V_0$$, I'm trying to show that $$v_0 + x_1 in C$$but I do not know how to show it

A clue?

## Why on a Sony SLT-A65V with dynamic range optimization, I get three almost duplicate photos. Now what?

I turned on DRO and this gives me 3 slightly different pictures of the same thing.

Now what?

1. Decide manually which is the best?
2. Recombine them in one single best photo? How?
3. Something else

Final goal

To have 1 copy of each image that benefits from DRO.

## optimization – Optimize a system of equations to minimize purchase costs

I am new to this field (posting on stack exchange and higher level mathematics in general), so correct me if I am wrong. I try to minimize the costs for my company for the purchase of a certain product. We can get this product at different prices depending on what we buy at once (in "bundle"). We need to cover the total demand (TD) of the product and have enough packages so that each customer has 1 package (TL is essentially the number of customers that will also match the number of packages purchased) and even maximize the TD if possible. Each bundle contributes to the overall supply available, so that the individual needs of each customer are irrelevant because the product can be reallocated to different customers as needed, but the supply is important at the time of delivery. Purchase for us, the company.

So, I try to minimize the TC (total cost) in this case. TD and TL will be constantly updated every month, but these can easily be entered (here TD = 950 and TL = 195).

TD = 0.1 * x1 + 1 * x2 + 3 * x3 + 5 * x4 + 7 * x5 + 10 * x6

TL = x1 + x2 + x3 + x4 + x5 + x6

TC = 12 * x1 + 17 * x2 + 25 * x3 + 33 * x4 + 42 * x5 + 52 * x6

So, would the configuration look like this?

A =

| .1 1 3 5 7 10 |

| 1 1 1 1 1 1 |

| 12 17 25 33 42 53 |

b =

[TD TL TC]

x =

[x1 x2 x3 x4 x5 x6]

What could be an appropriate approximation method to solve this problem? I try to avoid being mean, but I'm not sure where to start. Would the downhill slope suit something like that? Thank you

## Mathematical Optimization – Modify / Optimize a Double Sum with a If Condition

I would like to better understand the double summations of which one of the sums depends on the upper limit of the previous sum. This frequently appears in the theory of representation (to the extent of my knowledge) and in some systems of physics. With representations of the form $$[a,b,c]$$ or even of a simpler form, it is tricky – at least for me – as I explain below.

Ideally, I would like to understand how I can effectively implement something like the following example of representations.

Consider the formula:

$$[0,p_1,0] otimes [0,p_2,0] = sum_ {k_1 = 0} ^ {p_1} sum_ {k_2 = 0} ^ {p_1-k_1} [k_1,p_2-p_1+2k_2,k_1]$$
with $$p_1 leq p_2$$.

It is essentially a decomposition of representations; each term $$[a,b,c]$$ is a representation to be more concrete.

Here is a minimal and non-trivial example of what he should give:

$$[0,2,0] otimes [0,2,0] = [0,0,0] oplus [0,2,0] otimes [0,4,0] otimes [2,0,2] otimes [1,0,1] otimes [1,2,1]$$

What I have implemented is the following:

``````break down[p1_, p2_] : =
Module[{x1 = p1, x2 = p2},
If[x1 <= x2,
Sum[Print[k1, x2 - x1 + 2 k2, k1], {k1, 0, x1}, {k2, 0, x1 - k1}

,
Impression["Wrong values for the p1 and the p2"]]]
``````

And to achieve the above example, one must perform the simple

``````break down[2, 2]
``````

If you try to execute this command, the absolute timing is $$0,000328$$- you get the correct decompositions and none are missing. Once the representations are printed, I receive the following message:

``````6 Null
``````

Six is ​​the number of terms; which is great and very useful because I wanted to implement a command m indicating the number of terms that I would get after the decomposition. I understand why I receive the Null. This comes from the way I wrote the sum. However, I have not been able to solve the problem. Namely, if I polish the implementation of the sum, the code does not work.

Punchline: I wish I could run the order and get something like -for the example above-

``````There are 6 channels

000

020

040

101

121

202
``````

P.S: A little more generally, I think, is the equivalent of asking how I can ask Mma to do a summation or product in a symbolic form and not by actually calculating the traditional algebraic problem.

## optimization – Optimal implementation of an animation in UE4

We have already created the runway spline animation of a tank, but this one uses a lot of memory because it is implemented in a tick function. So he has to check every second, but as you may know, it takes a lot of resources if there are more than 10 tanks.

I would like to ask if you have an optimal solution to this problem or if you have faced such problems.

P.S. would be great if the solution in the plans.

Thank you!

## Variable in the exhibitor in an optimization problem

I've plugged the following problem

Minimize[{X^zz>=1z[{X^zz>=1z[{x^zz>=1z[{x^zz>=1z<= 10, x >= 1}, {x, z}

Can any one please explain why the software does not provide the solution? Clearly the solution is $$x = 1$$ and $$1 leq z leq10$$.