## Problems with logical conjunction

There is a problem. I have line like this:
$$x in A backslash(Bbackslash C) leftrightarrow xin(Abackslash B)cup(Acap C)$$
and I tried to prove it from left, but stopped here:
$$xin A backslash(Bbackslash C)) leftrightarrow xin A wedge xnotin (Bbackslash C) leftrightarrow xin Abackslash(xnotin B wedge xin C) leftrightarrow ???$$
and tried from right, bout stopped here:
$$xin(Abackslash B)cup(Acap C) leftrightarrow (xin A wedge x notin B) vee (x in A wedge x in C) leftrightarrow x in A wedge (xnotin B vee xin C) leftrightarrow x in A wedge(x notin B lor x in C) leftrightarrow ???$$
So, to be honest, I’m kinda lost. I tried it two times, but still get different things from both sides. It is supposed to be "truth" and I need to show how to prove it. But I have no idea where is the mistake.

Also other question.
Is it correct to do something like this:
$$(xin A wedge x in B) wedge x notin Cleftrightarrow x in A wedge x notin C wedge x in B wedge x notin C$$
and if yes (or not) based on what? Because I tried to find something to base my prove on, but I can’t find anything specific, like theorem or definition.
If something isn’t clear, please say what, and I will try to clarify.

## No, this does not work

Precise Strike says:

Whenever you and an ally* who also has this feat are flanking the same the creature, you deal an additional 1d6 points of precision damage with each successful melee attack […]

There is no argument about whether or not you count as your own ally, but you don’t count as two people. As you can see, the Precise Strike feat specifically requires both you and an ally.

Dimensional Savant, in its entirety, says:

You flash into and out of reality so quickly it is impossible to tell exactly where you are at any given time.

Prerequisites: Dimensional Agility, Dimensional Assault, Dimensional Dervish, ability to use the abundant step class feature or cast dimension door, base attack bonus +9.

Benefit: While using the Dimensional Dervish feat, you provide flanking from all squares you attack from. Flanking starts from the moment you make an attack until the start of your next turn. You can effectively flank with yourself and with multiple allies when using this feat.

Dimensional Agility allows you to flank with yourself, but nowhere in its text does allow you to count as two people, therefore, you can’t gain the benefits of that teamwork feat by flanking with yourself.

## algorithms – How can I parse a boolean expression to group it based on the conjunction?

I have to design an algorithm to parse an array of terms and conjunctions into a grouped boolean expression. I never studied computer science and don’t usually need this for web development, but today is different and I’m stumped.

I’m getting input like so:

``````a == 1 and b == 2 or c == 3 and d == 4
``````

which I must turn into

``````(a == 1 and b == 2) or (c == 3 and d == 4)
``````

it must also work with more complex expressionswith nested `or`s and `and`s:

``````a == 1 and b == 2 and c == 3 or d == 4 or e == 5 and f == 6...
``````

which becomes

``````(a == 1 and b == 2 and c == 3) or (d == 4) or (e == 5 and f == 6)...
``````

Is there a particular algorithm I could use to do this?

I’m using JavaScript if that makes a difference, and this is for an application where the user can enter a search with these terms which I must then translate into groups of terms that are using the same conjunctions (`or` and `and` only, there is no `not or` or `not and`).

so

``````a == 1 or b == 2 and c == 3
``````

would become

``````// a == 1 or (b == 2 and c == 3)
(
{
group: {
entries: (
{
term: 'a',
operator: 'equal'
value: '1'
},
{
group: {
entries: (
{
term: 'b',
operator: 'equal'
value: '2'
},
{
term: 'c',
operator: 'equal'
value: '3'
},
)
}
)
}
)
``````

Something that confuses me very much is that `and` groups must be evaluated first, and then `or`ed together.

Any pointers as to how to approach this problem?

## Media image linking when used in conjunction with the Anchor link module

I've raised questions here about drupal responses to have a faster action item and to get answers, please don't close this question and be disappointed.

## error – How can I use ReplicateLayer?[] in conjunction with the variable length input?

I am trying to build a `NetGraph[]` that takes the form entry `{{0.6},{0.6},...,{0.8},{0.8}}` and multiply the last sequence value `{0.8}` with all the elements in the sequence.

I have defined the following network:

``````net = NetGraph[
<|
"last" ->
SequenceLastLayer["Input" -> {"Varying", 1}, "Output" -> 1],
"replicate" -> ReplicateLayer[Automatic],
"sub" -> ThreadingLayer[#1 - #2 &]
|>
,
{NetPort["input"] -> {"last", "sub"},
"last" -> "replicate" -> "sub"}]
``````

but when I apply the network, as in the following two examples:

``````net[{1, 2, 3}]
``````

Y

``````net[{{1}, {2}, {3}}]
``````

I continually receive the following error:

``````NetGraph::interr2: An unknown internal error occurred. Consult Internal`\$LastInternalFailure for potential information.
``````

And, using \$ LastInternalFailure, I get:

``````InvalidSowNode
At position NeuralNetworks`NetPath[Nodes,replicate] in net, in layer of type Replicate: cannot serialize {NeuralNetworks`LengthVar[1016995628]} in SowNode[broadcast_axis, {{5,0,0}}, {axis->{1},size->{NeuralNetworks`LengthVar[1016995628]}}] for MXNetFunction of layer "replicate".
<<43 raw stack frames>>
``````

I have devoted some time to this and, although it seems that it should be quite simple, I have not been able to make it work.

I guess this may have something to do with the use `Automatic` in `ReplicateLayer[]`, but this seems to be the only option, since the input sequence is of variable length.

What can I do to make this work? Thank you!

## Programming languages: can the value model for variables only be used in conjunction with static writing, not dynamic writing?

There are two models of variables: the value model (for example, variables in C) and the reference model (for example, variables in Python).

There is also a distinction between static writing and dynamic writing.

Can the value model only be used in conjunction with static writing, not dynamic writing?
Or how can the value model and dynamic writing work together, and perhaps some sample languages?

Can the reference model for variables work with static typing or dynamic typing?

## 8 – Bigpipe works in conjunction with ajax?

I will have the audio player placed at the bottom of the window that persists through the loads on the page, which means that I think I will have to reload the content of the page through js / ajax. I'm not really sure how this affects / is affected by caching, so I'm curious to know if using Bigpipe is possible / beneficial in this case or if it's essentially useless.

## Concepts: How to understand and design functions with enumeration arguments that work in conjunction with bitwise operators in C ++ and Qt?

In C ++, there are 6 bitwise operators:

``````Symbol Operator
& bitwise Y
| bitwise inclusive O
^ XOR in bit mode (eXclusive)
<<      left shift
>> change to the right
~ NOT along the bits (one's complement) (unary)
``````

In Qt, I've seen `|`, `~`Y `Y` used quite often in functions:

``````file-> open (QIODevice :: WriteOnly | QIODevice :: Truncate);
``````

The source for that function looks like this:

``````bool QFile :: open (OpenMode mode)
{
Q_D (QFile);
if (isOpen ()) {
qWarning ("QFile :: open: File (% s) is now open", qPrintable (fileName ()));
false return;
}
yes (mode and append)
mode | = WriteOnly;

unsetError ();
if ((mode & (ReadOnly | WriteOnly)) == 0) {
qWarning ("QIODevice :: open: unspecified file access");
false return;
}
if (fileEngine () -> open (mode)) {
QIODevice :: open (mode);
yes (mode and append)
search (size ());
true returns
}
QFile :: FileError err = fileEngine () -> error ();
if (err == QFile :: UnspecifiedError)
err = QFile :: OpenError;
d-> setError (err, fileEngine () -> errorString ());
false return;
}
``````

The source code for the enumeration looks like this:

``````enumeration OpenModeFlag {
NotOpen = 0x0000,
WriteOnly = 0x0002,
Append = 0x0004,
Truncate = 0x0008,
Text = 0x0010,
Unbuffered = 0x0020,
NewOnly = 0x0040,
ExistingOnly = 0x0080
};
Q_DECLARE_FLAGS (OpenMode, OpenModeFlag)
``````

In the book from which I learned Qt and C ++, it does not adequately touch these design patterns, so I am not even quite sure how to read this code, or to what extent I should use the Bitwise Operators in conjunction with my enumerations.

## Questions

1. How is it exactly `file-> open (QIODevice :: WriteOnly | QIODevice :: Truncate));` Evaluated first? Do you evaluate the two enumerations in this way?

``````QIODevice :: WriteOnly> 0x0002> 0000 0000 0000 0000 0000 0010
QIODevice :: Truncate> 0x0008> 0000 0000 0000 0000 0000 1000
| 0000 0000 0000 0000 0000 1010
``````

and execute the function like this?

``````file-> open (0000 0000 0000 0000 0000 1010); // 10 is not set in enumeration
``````
2. If this is the case, what is the relevance of the number 10 in binary?

3. Why are the numbers set all the powers of 2?
4. Why use hexadecimals for numbers and not for simple integers?
5. Could all the bitwise operators be applied to the function and how would it read it? This would be my rudamentary conjecture:

``````file-> open (QIODevice :: WriteOnly & QIODevice :: Truncate); // Do they both have to be true?
file-> open (QIODevice :: WriteOnly | QIODevice :: Truncate); // At least one has to be true?
file-> open (QIODevice :: WriteOnly ^ QIODevice :: Truncate); // Does only one have to be true?
file-> open (QIODevice :: WriteOnly ~ QIODevice :: Truncate); // WriteOnly has to be true and Truncate has to be false
file-> open (QIODevice :: WriteOnly << QIODevice::Truncate);// ???
file->open (QIODevice :: WriteOnly >> QIODevice :: Truncate); // ???
``````
6. In the source of the function, I also see things like `| =`

7. How would you read this line of code: `if ((mode & (ReadOnly | WriteOnly)) == 0)` ?
8. In more practical terms, what are the circumstances in which each bitwise operator would use to be used in conjunction with the enumerations?

Thank you.