## How to generate my weblogic.xml for the deployment of web logic

I would like to know where I consult to create my weblogic.xml file and thus be able to take my application in the web logic

## java – What naming convention should you use for the 2 model classes of the same business logic, a shallow one and the other deep

In one of our services, we have business objects and we sometimes want to return them in their "flat" form and sometimes in their hierarchical form.

An example:

Let's say we have an object counts. Each account has a list of projects. Each project has a list of tasks.

Account:

Project:

• first name
• created at
• Account ID

• first name
• created at
• the description
• projectId

When searching for an account (for example by username), we sometimes want to obtain "superficial" account data:

ShallowAccount {
String ID;
String name
String createdAt;
listing projectIds;
}

and sometimes the complete hierarchy:

Account {
String ID;
String name
String createdAt;
listing projects;
}

Where project:

Project {
String ID;
String name
String createdAt;
String accountId;
}

and the "shallow" project is:
ShallowProject:

Project {
String ID;
String name
String createdAt;
String accountId;
listing Chain;
}

and so on for Task.

Now for the question:

What is the naming convention for such objects (that is, shallow and complete objects)?

## reference request – Is there a three-valued logic whose game semantics correspond to potentially infinite games?

Consider the game trees with the following properties:

• Each node of the tree is one of the following:
• Auditor's Choice: Has one or more children
• Falsify Choice: Has one or more children
• No choice: has exactly one child, who is always selected (may be represented by a choice of auditor or falsifier, but is considered a separate type of node for clarity)
• Verifier Victory: is a leaf
• Falsify Victory: Is a leaf
• The branches of the tree can be infinitely long (that is, the tree is not necessarily well founded)

These game trees are perfect information for extended form games with two players. A game is said to represent a true statement if Verifier has a winning strategy, a false statement if Falsify has a winning strategy, or an indeterminate statement if neither of them has a winning strategy. It is clear that only an unsubstantiated game tree may be an indeterminate statement.

Is there a logic whose game semantics correspond to the games considered above?

If such a logic existed, it would contain Kleene's logic. Kleene's logic does not have quantifiers, however, so we would need something more complex.

An interesting example of an indeterminate statement would probably be $${x: x x xin} in {x: x x$$ in naive set theory. In classical logic, this would lead to Russell's paradox. If there is a logic discussed above, however, it would not be. Instead, the statement would consist of an infinite line of knots without choice and would therefore have an indeterminate truth value. The same applies to $${x: x in x } in {x: x in x }$$. The instruction "the set of all sets contains the set of all sets" would be true, however, consisting of a single victory node of the verifier. More interesting examples appear when you have sets defined using quantizers (which involve checker choice and falsifier choice nodes).

## Logic – Can we ignore the postcondition in Hoare's conditional rule when there is a return statement?

I prove the accuracy of the naive correspondence of the strings with the help of Hoare logic. I have the following pseudocode:

NaiveStringMatch (T, P)
0 characters
P is an array of m> 0 characters>

for (s = 0 to T.length - P.length)
<invariant: for all 0 ≤ s' < s there is no match>
j = 1
while (j ≤ P.length and P[j] == T[s + j])

j ++
if (j == P.length + 1)
results
back -1
-1 then P[i] == T[i + s], 1 ≤ i ≤ m,
and there are no s & # 39; < s for which this holds>

The thing I'm fighting with is the conditional statement

if (j == P.length + 1)
results

In particular, the Hoare logic test rule for the conditions, and the required postcondition, $$psi$$, in that case. The conditional rule looks like this:

$$frac { { phi coin B } C_1 { psi } > > > > { phi coin neg B } C_2 { psi }} { { phi } > > if > > B > > then > > C_1 > > else > > C_2 > > { psi }}$$

My precondition, $$phi$$, is it:
$$phi = text {for all teams} 0 leq s

The postcondition, $$psi$$what was given to me is this:

$$psi = text {for all teams} 0 leq s text {there is no match}$$

Looking a little closer, we notice that when the inner loop ends, then j ≤ P.length + 1. There are two cases:

1) if j <P.length + 1then P does not match T to change sThus, the outer for loop invariant is retained. After evaluating the statement though, we also satisfy $$psi$$, since there is no match when $$s = s$$.

2) if j == P.length + 1, P matches T to change sand the algorithm ends when returning s. Thus, the outer for loop invariant is retained. Now it is there that I am confused. After evaluating the if statement, how $$psi$$ satisfied here? Because after the if statement is executed, we can clearly find the offset $$s = s$$ for which there is a valid match. So in my mind $$psi$$ is not satisfied. Unless the return return means we do not need to check $$psi$$ and therefore, we simply ignore the fact that $$psi$$ is not satisfied?

## Logic – Help in rewriting a simple instruction with the help of logical quantizers.

The question was to rewrite the statement "The equation $$x ^ 2 = -1$$ There is no real solution $$Z$$"using only logical quantizers and the words" such as "

My poorly marked answer was $$forall x in Z$$, $$nexists x in Z$$ such as $$x ^ 2 = -1$$.

I've been watching it for a while and I do not see what I've done wrong. Can any one help me?

## What is the logic of finding all the possible numbers that add to the number requested?

But note that the number on the left is always greater than the number on the right. I've already tried it in several ways, but I think I did not understand the logic to create an algorithm that does it, so I always fail in numbers greater than 8.

Example: 8
8

7 + 1

6 + 2

6 + 1 + 1

5 + 3

5 + 2 + 1

5 + 1 + 1 + 1

4 + 4

4 + 3 + 1

4 + 2 + 2

4 + 2 + 1 + 1

4 + 1 + 1 + 1 + 1

3 + 3 + 2

3 + 2 + 2 + 1

3 + 2 + 1 + 1 + 1

3 + 1 + 1 + 1 + 1 + 1

2 + 2 + 1 + 1 + 1 + 1

2 + 1 + 1 + 1 + 1 + 1 + 1

1 + 1 + 1 + 1 + 1 + 1 + 1 + 1

## logic – Negation of operator semantics Until in LTL

I hope so that it belongs here and not in mathematics or StackExchange.

I looked at the operator until the shipping and the publication operator. When presenting the publication operator, it was suggested that this is equivalent to

$$phi ps equiv neg ( neg phi U neg psi)$$

But in trying to move from the semantic definition of the Until operator to the semantic definition of the negation operator Release, I remain partially blocked. Specifically, I'm stuck trying to deny a $$forall j expression as I will show below.

So, the semantic definition of up to:

$$pi templates phi U psi iff exists i geq0, pi[i] models psi land forall j leq i-1, pi[j] models phi$$

Put the negations in:

$$pi templates neg ( neg phi U neg psi) iff neg ( exists i geq0, pi[i] models neg psi land forall j leq i-1, pi[j] models neg phi)$$

$$iff forall i geq 0, neg ( pi[i] models neg psi) lor neg ( forall j leq i-1, pi[j] models neg phi)$$

$$iff forall i geq 0, ( pi[i] models psi) lor ( exists j leq i-1, pi[j] models phi)$$

In words, I finish with overall $$psi$$ or globally, there is always a predecessor who satisfies $$phi$$. What can not be correct $$pi[j]$$ is not defined when $$i = 0$$.

The semantic definition of the publication operator that I was aiming for is as follows:

$$pi templates phi R psi iff ( exists i geq 0, pi[i] models psi land forall j leq i, pi[j] models psi) lor ( forall k geq 0, pi[k] models psi)$$

I therefore have some of the correct expression ($$forall k geq 0, pi[k] models psi equiv forall i geq 0, ( pi[i] models psi)$$), but I am really puzzled over how to get the second part or about the mistakes I made.

Any enlightening help is greatly appreciated!

Thank you!

## logic – NAND gate only (De Morgan's law)

I have a function that I need to convert to NAND only.

I've tried using De Morgan's law, but my results are wrong.

Here is my function:
$$z = overline {d} overline {f} ( overline {a} this + ac overline {e} + overline {b} a overline {c} + overline {a} b overline {c } overline {e} + overline {a} b overline {c} overline {e} + df (ace + overline {a} bc overline {e} + a overline {b} overline { c} overline {e}) + (overline {c} overline + overline {b} overline {f}) + abc overline {d} f$$

I used De Morgan's law:

$$overline {a + b} = overline {a} * overline {b}$$

To obtain the following function:

$$overline { overline { overline {df} ( overline {a overline {ce}} * overline { overline {ac} e} * overline { overline {a} bc} * overline {a overline {b} this} * overline {a overline {b} this})} * overline { overline { overline {d} overline {f}} { overline { overline {a} overline {c} overline {e}} * overline {a overline {b} overline { c} e} * overline { overline {a} bce})} * overline { overline { overline {d} overline {e}} ( overline {cf} * overline { overline {a} b overline {c} f})} * abc overline {d} f }$$

which produces erroneous results. This function seems too difficult, I must do something wrong. It has been two days since I tried to make this work, but it seems that I will need the help of professionals.

## education – Why is logic not taught in school?

I am looking for a non-pessimistic answer. Once I finally learned enough formal logic to get a degree in mathematics and then a Ph.D., I realized how much time I had lost to understanding things because I was not initiated to formal logic when I was much younger.

I understand that it is difficult to teach logic to illiterates or even to functional literacy, which is enough to obtain many degrees, but it is that we do not teach logic in our schools.

## usability – Why does the Revolution slider have an inverted layer appearance logic compared to the common model?

This is the screen capture of the WP revolution slider of the layers section, where the lower layer named "Button" is displayed at the top, which means that the layers display logic goes from low to high. above.
Most layer-based editing programs (Sketch, Photoshop) have an opposite logic, from top to bottom, which is a motive that most people learn.
Someone has an idea why Revslider has the opposite?