How to only show page if private secure key in body of request?

I want to make it secure by sending a pre-decided private secret key in body of request. If that key exists in incoming request, then only show page, otherwise give 404 error or redirect to some other page.

In which paper is written that you can transform one problem to another to show NP-completeness?

For example in this post they discuss how to construct a reduction between problems to show that one probleme is NP-Hard: Post

I am searching for a scientific paper to cite where it is written, that this is a valid method.

Does anybody knows one?

How to show your work to potential clients as a pentester?

I’m sorry if you feel this doesn’t belong here but I genuinely couldn’t find any place to ask this and feel maybe people here can suggest something. While freelance software developers can show their work to potential clients by building personal projects or by showing their previous client’s project how can a pentester do the same?

A pentester can’t provide audit reports of previous client’s as they are confidential and if he is new he may work for free for few clients and show his work but again same thing how would he show his work to potential clients without showing the actual reports? I’m scratching my head from days and can’t sleep properly because am constantly thinking of a way to solve this. Any help would be highly appreciated.

Permissions required for row counts to show up on Object Explorer Details

I’m having a weird security issue. I have a user that’s using SSMS 18.2 on a SQL 2016 server. They are a member of db_datareader but when they pull up the the Row Count column in Object Explorer Details it’s blank. As best I can tell it is requiring DBO in order to get the row counts to show up.

User with dbo access:

Is this a bug or intentional? Does anyone know if there is a lower level of permissions that will give this row count? I know there are plenty of other ways to get the row count, sys.partitions for example, however the user insists they want to use the OED window.

Proof strategy to show that an algorithm cannot be implemented using just hereditarily terminating procedures

I am taking my question here from there. Consider the following scenario:

You are given a fixed programming language with no nonlocal control flow constructs. In particular, the language does not have

• Exceptions, first-class continuations, etc.
• Assertions, in the sense of “runtime tests that crash the program if they fail”.

Remark: An example of such a language could be Standard ML, minus the ability to raise exceptions. Inexhaustive pattern matching implicitly raises the Match exception, so it is also ruled out.

Moreover, you are forced to program using only hereditarily terminating values. Inductively, we define hereditarily terminating values as follows:

• Data constructors (including numeric and string literals) are hereditarily terminating.
• Applications of data constructors to hereditarily terminating arguments are hereditarily terminating.
• A procedure f : foo -> bar is hereditarily terminating if, for every hereditarily terminating x : foo, evaluating the expression f x always terminates and the final result is a hereditarily terminating value of type bar.

Remarks:

• Hereditarily terminating procedures need not be pure. In particular, they may read from or write to a mutable store.

• A procedure is more than just the function it computes. In particular, functions do not have an intrinsic asymptotic time or space complexity, but procedures do.

Hereditarily terminating procedures formalize my intuitive idea of “program that is amenable to local reasoning”. Thus, I am interested in what useful programs one can write using only hereditarily terminating procedures. At the most basic level, programs are built out of algorithms, so I want to investigate what algorithms are expressible using only hereditarily terminating procedures.

Unfortunately, I have hit an expressiveness ceiling much earlier than I expected. No matter how hard I tried, I could not implement Tarjan’s algorithm for finding the strongly connected components of a directed graph.

Recall that Tarjan’s algorithm performs a depth-first search of the graph. In addition to the usual depth-first search stack, the algorithm uses an auxiliary stack to store the nodes whose strongly connected components have not been completely explored yet. Eventually, every node in the current strongly connected component will be explored, and we will have to pop them from the auxiliary stack. This is the step I am having trouble with: The loop that pops the nodes from the stack terminates when a given reference node has been found. But, as far as the type checker can tell, the reference node could not be in the stack at all! This results in an extra control flow path in which the stack is empty after popping everything from it and still not finding the reference node. At this point, the only thing the algorithm can do is fail.

Conjecture: Tarjan’s algorithm cannot be implemented in Standard ML using only hereditarily terminating procedures.

My questions are:

1. What kind of proof techniques would be necessary to prove the above conjecture?

2. What is the bare minimum type system in which Tarjan’s algorithm can be expressed as a hereditarily terminating program? That is, what is the bare minimum type system that can “understand” that the auxiliary stack is guaranteed to contain the reference node, and thus will not add a control flow path in which the auxiliary stack is empty before the reference node has been found?

Final remark: It is possible to rewrite this program inside a partiality monad. Then every procedure would be a Kleisli arrow. Instead of

val tarjan : graph -> scc list 

we would have something like

val tarjan : graph -> scc list option 

But, obviously, this defeats the point of the exercise, which is precisely to take out the procedure out of the implicit partiality monad present in most programming languages. So this does not count as a solution.

Confluence to show equivalent terms have one common reduct

In lemma 30.3.9, Pierce states a confluence property for $$F_{\omega}$$:

$$S \to_* T \land S \to_* U \implies \exists V. T \to_* V \land U \to_* V$$

He then states the following proposition:

$$S \leftrightarrow_* T \implies \exists U. S \to_* U \land T \to_* U$$

However, he doesn´t use the above property to prove it. I remember this was the case for other books on term rewriting systems that I read. However, to me it looks very simple to prove using the confluence lemma.

From $$S \leftrightarrow_* T$$ one has $$S \to_* T$$ and $$S \to_* T \to_* S$$ thus by confluence $$\exists U. S \to_* U \land T \to_* U$$.

Why is this approach not correct?

Show, if possible, small isolated “islands” in the unit cube using RegionPlot3D

I have a certain three-dimensional constraint

-(1/3) < t3 < 1/3 && -(1/3) < t2 < 1/3 && 9 t1^2 < (1 - 3 t3)^2 && 9 t1^2 < (1 + 3 t3)^2 && t1^2 t2^2 t3^2 > 1/23328  . 

If I perform an integration over the unit cube $$[-1,1]^3$$, I obtain (using the GenericCylindricalDecomposition and FullSimplify command) the result

(1/(54 Sqrt[2]))(8 Sqrt[2 - Sqrt[2]] - ArcTanh[Sqrt[1 - 1/Sqrt[2]]] (8 + Log[128]) + Log[2 - Sqrt[4 - 2 Sqrt[2]]]^2 - Log[2 + Sqrt[4 - 2 Sqrt[2]]]^2 - 4 PolyLog[2, 1/4 (2 - Sqrt[4 - 2 Sqrt[2]])] + 4 PolyLog[2, 1/4 (2 + Sqrt[4 - 2 Sqrt[2]])] 

which evaluates to approximately 0.00221357, while, of course, the unit cube has a much larger volume, that is, $$2^3=8$$.

I believe–on the basis of prior (“bound-entanglement” probability) considerations, that the regions in which the constraint is satisfied are disjointed and form an “archipelago” of islands.

However, my limited attempts (using various ranges of coordinates for the variables $$t1, t2, t3$$) to show these presumed regions using RegionPlot3D just return vacuous plots.

**Show:** For $n\ge0$, $K^{(n)}\le_mA \Rightarrow K^{(n)}\le_1 A$

Show: For $$n\ge0$$, $$K^{(n)}\le_mA \Rightarrow K^{(n)}\le_1 A$$

$$K:=\{x:x\in W_x\}$$
$$A\le_mB :\Leftrightarrow (\exists$$recursive function $$f)[x\in A \Leftrightarrow f(x)\in B]$$
$$A\le_1B :\Leftrightarrow (\exists$$recursive injection $$f)[x\in A \Leftrightarrow f(x)\in B]$$
$$A^{‘}:=\{x:x\in W^{A}_x\}$$ $$\begin{cases} A^{(0)}:=A\ A^{(n+1)}:=(A^{(n)})^{‘} \end{cases}$$

Show that a problem is NP-Complete

The problem is, K_longestPath:

Given a graph with some “cities”, we define a “city” such that in the graph there are no cities with an edge between them, thus every city must be at distance at least $$2$$ from each ofther city. We have to find a path that goes through each such city without forming a cycle.

We are given the Graph with a valid configuration of cities and we have to find if there exists such a path.

At first I was thinking solving this with Hamiltonian path, but to show that the problem is NP-complete I have to find an algorithm that will change it’s inputs to be inputs for this problem that we got, and I don’t know how to do this..