How to solve this 2nd-order linear ODE analytically?

I want to analytically solve the eigenvalue problem $ $ y”(x) – 2\gamma\, y'(x) + [\lambda^2 + \gamma^2 – (\frac{x^2}{2}+\alpha)^2 + x]\, y(x)=0$ $ where $ \lambda$ is the eigenvalue and $ \alpha,\gamma$ are parameters. The boundary condition is $ y(\pm\infty)=0$ .

Or instead of the eigenvalue problem, it will as well be nice to just solve it with freely running $ \lambda$ . Then probably I can tackle the eigenproblem by imposing the boundary condition.

The following code doesn’t work well. Is there any possible way beyond?

F := (D[#, {x, 2}] -       2 \[Gamma] D[#, x] + (\[Lambda]^2 + \[Gamma]^2 + (x^2/2 + \[Alpha])^2 + x) #) &; DEigensystem[{F[y[x]] /. \[Lambda] -> 0,    DirichletCondition[y[x] == 0, True]},   y[x], {x, -\[Infinity], \[Infinity]}, 5] DSolve[F[y[x]] == 0, y[x], x] 

Logplot and linear plot in the same plot

I have the following code:

q := 1.6*10^-19; me := 9.1*10^-31; (* Free electron rest mass in kg *) h :=  6.63*10^-34;  (* Reduced Planck's constant in J.s *) kb := 1.38*10^-23;(* Boltzmann constant in J/K *) LogPlot[Abs[Jschottky[V, 77]], {V, -0.5, 0.5}, PlotRange -> All,   Frame -> True,   FrameLabel -> {"Voltage (V)",     "\!\(\*FractionBox[\(J\), SuperscriptBox[\(T\), \(3/2\)]]\)"},   BaseStyle -> {FontSize -> 15}, PlotStyle -> {Thick, Red} ,   AspectRatio -> GoldenRatio, ImageSize -> 400, FrameStyle -> Black,   FrameTicks -> {{{#, Superscript[10, Log10@#]} & /@ ({10^-21, 10^-11,         10^-1, 10^9, 10^19}), None}, {Automatic, None}}]  Plot[Abs[Jschottky[V, 77]], {V, -0.5, 0.5}, PlotRange -> All,   Frame -> True,   FrameLabel -> {"Voltage (V)",     "\!\(\*FractionBox[\(J\), SuperscriptBox[\(T\), \(3/2\)]]\)"},   BaseStyle -> {FontSize -> 15}, PlotStyle -> {Thick, Blue} ,   AspectRatio -> GoldenRatio, ImageSize -> 400, FrameStyle -> Black] 

I get the following results:

enter image description here enter image description here

Now I want to plot them on the same plot with the logplot on the left y axis and the linear plot on the right yaxis. What should I do? Also any recommendations for a good grayscale plot of the same?

In what cases is solving Binary Linear Program easy (i.e. **P** complexity)? I’m looking at scheduling problems in particular

In what cases is solving Binary Linear Program easy (i.e. P complexity)?

The reason I’m asking is to understand if I can reformulate a scheduling problem I’m currently working on in such a way to guarantee finding the global optimum within reasonable time, so any advice in that direction is most welcome.

I was under the impression that when solving a scheduling problem, where a variable value of 1 represents that a particular (timeslot x person) pair is part of the schedule, if the result contains non-integers, that means that there exist multiple valid schedules, and the result is a linear combination of such schedules; to obtain a valid integer solution, one simply needs to re-run the algorithm from the current solution, with an additional constraint for one of the real-valued variables equal to either 0 or 1.

Am I mistaken in this understanding? Is there a particular subset of (scheduling) problems where this would be a valid strategy? Any papers / textbook chapter suggestions are most welcome also.

How to prove that the dual linear program of the max-flow linear program indeed is a min-cut linear program?

So the wikipedia page gives the following linear programs for max-flow, and the dual program :

enter image description here

While it is quite straight forward to see that the max-flow linear program indeed computes a maximum flow (every feasable solution is a flow, and every flow is a feasable solution), i couldn’t find convincing proof that the dual of the max-flow linear program indeed is the LP of the min-cut problem.

An ‘intuitive’ proof is given on wikipedia, namely : $ d_{uv}$ is 1 if the edge $ (u,v)$ is counted in the cut and else $ 0$ , $ z_u$ is $ 1$ if $ u$ is in the same side than $ s$ in the cut, and $ 0$ if $ u$ is in the same side of the cut than $ t$

But that doesn’t convince me a lot, mainly why should all the variables be integers, while we don’t have integer conditions ?

And in general, do you have a convincing proof that the dual of the max-flow LP indeed is the LP formulation for min-cut ?

Problem in the CLRS Linear Programming chapter

I’m currently reading the CLRS Linear Programming chapter and there is something i don’t understand.

The goal is to prove that given a basic set of variables, the associated slack form is unique

They first prove a lemma :

enter image description here

And then they prove the result :

enter image description here

My concern is that to prove the second lemma, they apply the first lemma. However equations (29.79) -> (29.82) only holds for feasable solutions, which is not for any x, so why can they apply the first lemma ?

Does Pathfinder 2e Playtest fix the “linear fighters, quadratic wizards” problem?

It is generally accepted that a reasonably optimized DnD 3.5e wizard will wipe the floor with even a well optimized DnD 3.5e fighter by high levels, often known as “linear fighters, quadratic wizards”. Pathfinder 1e removed or nerfed a few of the easiest tricks for this (e.g. polymorph) but probably actually makes the problem worse.

Is there any evidence from the Pathfinder 2e playtest materials currently available that there is any serious attempt to fix this issue, or the more general issue of class balance?

Does RLNC (Random Linear Network Coding) still need interaction from the other side to overcome packet loss reliably?

I’m looking into implementing RLNC as a project, and while I understand the concept of encoding the original data with random linear coefficients, resulting in a number of packets, sending those packets, and thus the client will be able to reconstruct the original data from some of the received packets, even if a few of the packets are lost, if enough encoded packets have arrived to create a solvable equation system.

However, I have not seen any mention of the fact that if there is a non zero percent of packet loss, there is a possibility that the receiver of the encoded packets will not receive enough packets to reconstruct the original data. The only solution I see to this is to implement some type of sequencing so that the receiver can verify he hasn’t missed some packets that would allow him to reconstruct the original data, in other words interaction. Am I missing some part of the algorithm or not? If someone has solved this problem already, can you please show me where it has been solved so I can read about it?