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}}]] 

Can lists be defined in a special way so that they contain things of different type?

In https://www.seas.harvard.edu/courses/cs152/2019sp/lectures/lec18-monads.pdf it is written that

A type $ \tau$ list is the type of lists with elements of type $ \tau$

Why must a list contain elements of the same type? Why can’t it contain elements of different types?

Is there a way of defining a list polymorphically in the typed lambda calculus, so that it takes elements of any type?

Can we then use the List monad on lists, defined polymorphically?

How are prime implicates of HORN-Formulas defined?

I’m confused about the definition of prime implicates in Horn formulas.

For example in the paper of Kira 2012 on page 109 it is stated: enter image description here

Now in the paper of Boros 2010 on page 82 the following definition is used: enter image description here

My goal is to decide whether a Horn formula is prime or not in polynomial time. For that I want to assume the definition used in Kira 2012.

How can I prove that the two definitions above for prime implications of Horn formulas are equivalent?

User defined function for creating Row only listing first column of matrix or first element of a vector

I cannot figure out why my rowNameValue[] is only listing the first part of a column or vector. Below is the code.

objectName = Function[Null, SymbolName[Unevaluated[#]], {HoldFirst}]; ClearAll[m, b] m = {{1, 0, -5}, {0, 1, 1}, {0, 0, 0}}; MatrixQ[m] b = {1, 4, 0}; VectorQ[b] rowNameValue[symbol_, name_ : Null] := Block[{id, fn},    id = If[Head[name] === String, name, objectName[symbol],       objectName[symbol]];    id = If[MatrixQ[symbol] || VectorQ[symbol], Style[id, Bold], id,       id];    fn = If[MatrixQ[symbol] || VectorQ[symbol], MatrixForm,       TraditionalForm, StandardForm];    {Row[{id, " \[Rule] "}, " "], Apply[fn, symbol]}    ]; dataIn[m_, b_] = Block[{}, Grid[{     rowNameValue[m, "m"],     rowNameValue[b, "b"]     }]] dataIn[m, b] 

relocation error: symbol SSL_trace version OPENSSL_1_1_0 not defined in file libssl.so.1.1 with link time reference

I compiled libssl.so and libcrypto.so using openssl1.1.1d using command ./config -d enable-ssl-trace. when i use libssl.so and libcrypto.so and run my the apps. it show me this relocation error. i checked libssl.map and found SSL_trace is it OPENSSL_1_1_0 global feature. May I know how can I make it defined in file libssl.so.1.1?

Simplifying complex expresion (without ComplexExpand or User defined rules)

Many times, I’ve struggled with simplifying complex expressions, such as this extraordinarily simple expression, and Mathematica wont do it:

$  Assumptions = {l>0,a>0,a \[Element]Reals, l \[Element]Reals} Conjugate[(Exp[I a])^(2 l)] //FullSimplify 

Where Mathematica returns the same thing with no simplification. I told it the assumptions which make it very obvious to just change the sign of the exponent, and I don’t understand why it doesn’t work.

I looked here, but it seems like they have to define their own rules to do this kind of thing. I’m also saw here that you can do //ComplexExpand //FullSimplify for this expression, but it doesn’t seem to work in all cases. Why should it be nessecary and why doesn’t FullSimplify do it already? Also, I think ComplexExpand assumes that all variables are real, which was the case in this expression, but isn’t always the case. So how would I do it then?

Looping through all functions defined in Mathematica

Is there a way to loop through all the Functions (Elementary and Special functions) that exist in Mathematica?

I want to construct a table of some identities and maybe I can discover something surprising if I plug every function that there is into my formula.

I.e. I want to do something like:

for function in Mathematica print function[x]^2 

(Note this is not Mathematica syntax, but I hope you get the idea)

Thanks, Michał

Partially defined boolean function

Consider boolean function $ f(x_{1}, x_{2}, \dots, x_{n})$ . The value of $ f$ is defined on some set of inputs, and some inputs are undefined (let us label undefined value with $ ?$ ). It is possible to set $ f$ ‘s value on some inputs, no matter if they were initially defined.

The problem is to set some of the inputs such that:

  • all initially undefined inputs become defined (i. e. no $ ?$ in function truth table);
  • $ f$ is monotone in the common sense.

The optimization part is to use the minimum possible assignments. How can one find an optimal way in the time $ \mathcal{O} \left( p(n) \left( 2^{n} \right)^{2} \right)$ , where $ p(n)$ is polynomial?

PKCS11, softHSM, and vendor defined mechanism

I have implemented a solution where I can decrypt DUKPT taking 10 bytes of KSN, and derive a key using a vendor defined mechanism. This vendor defined mechanism uses the existing parameter of CK_KEY_DERIVATION_STRING_DATA. I tried to implement this in softHSM for testing purposes, but I am keep getting invalid mechanism.

And at this point, I am wondering if I can even implement the vendor defined mechanism testing code in softHSM since I think the algorithm of this mech could be different than the underlying mech algorithm I am trying to use. I thought the DUKPT algorithm of using symmetric derive key wouldn’t be different. I am going to double check with the vendor. But I wanted to ask experts of what they think.

The latest 3 commits of https://github.com/onesick/SoftHSMv2/commits/workingversion are me struggling trying to debug.

Thanks