Plotting a well defined function displays nothing for two-thirds of the range required

The plot in question concerns the second derivative of an inverse Laplace transform (ILT) of a function with five parameters. Here is the ILT

ClearAll["Global`*"] prod = (s - cr1) (s - cr2) (s - cr3) (s - cr4); LW = (1 + s)^2/(si prod); Print["symbolic W'=", Wp = D[InverseLaplaceTransform[LW, s, x], x]] 

Four parameters are functions of the fifth parameter "si", defined as the roots of a fourth order equation

cr = {cr1, cr2, cr3, cr4} =     s /. Solve[si s^2 + 107 s/5 + 10 ((1 + s)^(-2) - 1) - 1/10 == 0,       s]; 

Plotting the first derivative of the ILT takes .64

lx = 13; Timing[  pd = Plot[Evaluate[Wp /. si -> 1], {x, 0, lx},     PlotRange -> {{0, lx}, {0.0225, .0275}}]] 

Plotting of the second derivative of the ILT takes 14.84 and displays nothing for two-thirds of the range lx

    Wd = D[Wp, x]; Timing[Plot[(Wd /. si -> 1), {x, 0, lx},   PlotRange -> {{0, lx}, {-0.002, .002}}]] 

Speeding up the Rummikub algorithm – explanation required

Regarding this question: Rummikub algorithm.

I was reading the first part of the solution in the posted answer (specifically, when there are no jokers involved, all tiles are distinct and only four colours are involved). Then, I reached the part in which the says that the algorithm runs in $ O(ABCD(A+B+C+D))$ time, which is easy to determine why.

However, he the goes on to saying that we can speed up the algorithm so as to run in $ O(ABCD)$ time by changing "the recurrence to ensure this occurs only once while maintaining correctness, which leads to $ O(1)$ time for every ‘cell’ in the DP-table".

My problem is: I do not see how this can be done. I have tried playing around a bit with the recurrence, but I do not see how it can be modified, or what else we should keep track of so that we can speed up the time.

Why is the ‘Integrity’ property required in consensus protocols?

Formally a consensus protocol must satisfy the following three properties:

Termination

  • Eventually, every correct process decides some value.

Integrity

  • If all the correct processes proposed the same value "v", then any correct process must decide "v".

Agreement

  • Every correct process must agree on the same value.

"Termination" certifies the protocol is resilient to halting failures. "Agreement" deters any two correct processes from deciding on different values which would break consensus. But what about "Integrity", why is it required? If all correct processes propose "x" but then they all decide "y" (e.g. f(x) = y), is that a violation of consensus?

What are the details surrounding the brass brazier required for the Find Familiar spell?

In our campaign, I play a warlock and brass braziers are hard to come by. I want to carry a brass brazier in case my familiar dies and I need to again cast find familiar.

  1. How bulky is a small brass brazier? Can it be carried for several weeks without hindering long distance foot travel? That is, because of its shape or weight, does the typical brass brazier reduce my speed?
  2. What’s the price of a small, simple brass brazier?
  3. How long would it take a brass worker to make a small, simple brazier? How long would it take the brass worker to make one specifically designed to be eminently portable? In both cases, assume the brass worker works nonstop exclusively on the brazier.

What I’m looking for are references, similar cases, and information that can help handle these issues properly and accurately. First and foremost in D&D 5e (especially RAW) and then other RPGs and even real world, if they could be used to make estimates about the answers to these questions when we compare how similar cases translate to D&D 5e mechanics.

Is it recommended to drop all traffic by default in iptables and then accept only what is required?

I was told using iptables -P OUTPUT DROP and then rules such as iptables -A OUTPUT -p tcp --dport 80 -m state --state NEW -j ACCEPT to accept what is required didn’t do much from a security standpoint. Is that true?

This is what I am been using for some time (planning on implementing some SSH brute force rules shortly):

apt update apt install -y iptables-persistent iptables -A INPUT -i lo -j ACCEPT iptables -A INPUT -p tcp -m tcp --dport 22 -j ACCEPT iptables -A INPUT -m state --state RELATED,ESTABLISHED -j ACCEPT iptables -A OUTPUT -o lo -j ACCEPT iptables -A OUTPUT -p tcp --dport 53 -m state --state NEW -j ACCEPT iptables -A OUTPUT -p udp --dport 53 -m state --state NEW -j ACCEPT iptables -A OUTPUT -p tcp --dport 80 -m state --state NEW -j ACCEPT iptables -A OUTPUT -p tcp --dport 443 -m state --state NEW -j ACCEPT iptables -A OUTPUT -m state --state RELATED,ESTABLISHED -j ACCEPT iptables -P FORWARD DROP iptables -P INPUT DROP iptables -P OUTPUT DROP iptables-save > /etc/iptables/rules.v4 

Is a concentration check required for each of my following spells if I buff myself with Mage Armor

Player’s Handbook 1, p. 170, "Concentration" – "Spell" says:

"If you are affected by a spell while attempting to cast a spell of your own, you must make a Concentration check or lose the spell you are casting."

Now I have the feeling I played DnD wrong for years – this means if I buff myself with e.g. "Mage Armor" and try to cast "Magic Missiles" the next round, I have to do a concentration check, correct? And someone I buff with another spell, too?

There is no mentioning of the spell affecting me being from someone else or hostile.

How many clauses are required for SAT to be NP-hard in CNF formulas?

It is not hard to see that SAT for a CNF formula with $ n$ variables and a constant number of clauses can be solved in polynomial time. On the other hand, it is not hard to see that a CNF formula with $ n$ variables and $ O(n)$ clauses is enough for NP-hardness (consider for example the instances of SAT associated with the natural formula for 3-colorability, applied to planar graphs).

We could define this formally as $ \text{CNFSAT}-f-\text{Clauses}$ , a family of problems parameterized by a function $ f$ , in which instances are formulas in CNF such that if they have $ n$ variables, then they have at most $ f(n)$ clauses. Based on this, what I’d like to know is what is the smallest function $ g$ such that we know there exists $ f \in O(g)$ such that $ \text{CNFSAT}-f-\text{Clauses}$ is already NP-hard. We know that g = 1 (constant # of clauses) does not work, and $ g = n$ (linear number of clauses) works.

What about $ g = \log n$ ? Is there a simple algorithm for CNFSAT over formulas that have $ O(\lg \lg n)$ clauses?