Plot the surface defined by x^3+4y^2=10z; use (-3,3) as the range for x & y

# Tag: defined

## 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:

Now in the paper of Boros 2010 on page 82 the following definition is used:

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