## Azure Logic application with SharePoint connection

I am creating my first logical application that connects to SharePoint and adds entries in some sharepoint list.

Every time I create a SharePoint connection, add the following resource to my logical application.

``````{
"type": "MICROSOFT.WEB/CONNECTIONS",
"apiVersion": "2018-07-01-preview",
"name": "(parameters('sharepointonline_1_Connection_Name'))",
"location": "(parameters('logicAppLocation'))",
"properties": {
"api": {
"id": "(concat(subscription().id, '/providers/Microsoft.Web/locations/', parameters('logicAppLocation'), '/managedApis/', 'sharepointonline'))"
},
"displayName": "(parameters('sharepointonline_1_Connection_DisplayName'))",
"nonSecretParameterValues": {
"token:TenantId": "(parameters('sharepointonline_1_token:TenantId'))"
}
}
``````

Could anyone give an explanation of "token: TenantId". How / where to obtain this value in my development tenant. How can this be moved to the UAT / PROD environment?

Every time I recreate my logical application with the SharePoint connection, it loses the connection and shows me below the screen with a warning icon.

Is there a way to authenticate this connection through PowerShell or through Azure DevOps implementation?

## Logic: what algorithms for unification in terms of matrix (multidimensional)?

I am looking for references on the implementation of unification in terms of multidimensional matrix.

Are there specialized unification algorithms for these cases? I could not find satisfactory literature on the subject, and I am trying to write a logical programming library for the J language.

## Can you express \$ EG \$ with only US \$ in CTL (Computation Tree Logic)?

According to the logic article of the computation tree in Wikipedia, the following set of operators can be considered minimum (all CTL formulas can be transformed to use only those operators): $$top$$, $$lor$$, $$EG$$, $$US$$Y $$EX$$.

However, I'm not sure if that is really a minimum example. Couldn't we express $$EG$$ with $$US$$ As follows?

$$EG phi equiv E ( phi U phi)$$

Is the equivalence given by me not true or the definition of a minimum operator set Doesn't it necessarily mean that the number of operators in that set cannot be reduced?

## Find the law that transforms sentence into propositional logic

I need to find what law, combined with substitutions, completes the following sentence equation:

``````Calculation:
(q ≡ p) ∧ (q ≡ r) ≡ q ≡ p
=    ⟨ ? ⟩
(q ≡ p) ∧ (p ≡ q ≡ q ≡ r) ≡ (q ≡ p) ∧ (p ≡ q)
``````

I was thinking about the semi-distributive law of ∧ in ≡: $$p ∧ (q ≡ r) ≡ p ∧ q ≡ p ∧ r ≡ p$$ but the CalcCheck verification tells me that I am wrong. So, I don't know where to go from there.

## java – Alternative to massive blocks Try Catch for my logic

I am currently working on creating something with the following general structure. I want to call 4 different APIs in sequential order (the results of one are necessary for the next). If an exception is thrown, undo the efforts of the previous APIs with their sister removal APIs.

Currently my structure / control flow looks like this:

``````boolean A = false;
boolean B = false;
boolean C = false;
boolean D = false;
string response = StringUtils.EMPTY

try {
API_A;
A = true;
}
catch (A's Exceptions {
response = "fail!"
}

if (boolean_A == false){
undo_if_stuff_to_undo;
return response;
}
``````

Basically, this was repeated 3 times and if all 4 were successful, my response would be successful. I was wondering if there was a cleaner way to address this. I thought about making a function for each API call that returned a Boolean value, but the problem was that I needed the results of each API to call the next one. Perhaps create a special class for each API result that would store its success / failure and relevant attributes?

## Formalization of temporal logic "dual-time" – Computer Science Stack Exchange

I am interested in modeling a discrete temporal logic based on music, where there are two metrics of time, time and seconds (call them B and S). The restrictions on what constitutes a syntactically valid formula is that the following conditions are satisfactory

• If B (t) = a and B (t + 1) = b, there must be some t2 and t3 such that S (t2) = a and S (t2 + t3) = b, and the value of S between t2 and t3 is a .
• Similarly, if S (t) = a and S (t + 1) = b, there must be some t2 and t3 so that B (t2) = a and B (t2 + t3) = b, and the value of B between t2 and t3 is a.
• If B (t_i – 1) = a and B (t_i..t_i + k) = by B (t_i + k + 1) = c, there must be an interval S (t_j..t_j + m) = at which S (t_j – 1) = a, S (t_j..t_j + m) = b, S (m + 1) = c, and (m / k) is in some range in the real ones.

Intuitively, I am trying to define a system in which time does not always pass proportionally between "beat time" and "second time" (because beats per second fluctuate), but where there is a restriction on how much this fluctuation can occur .

Is there such a logic today, or is there any idea how to adjust the existing temporal logic to this paradigm?

## Logic: Does the only existential quantifier commute with the existential quantifier?

Given some function that involves two variables, $$mathit p (x, y)$$, is the function $$mathit exist! x exist yp (x, y)$$ equivalent to $$mathit exist y y exist! xp (x, y)$$
I have tried to write the formal definition of the single existential quantifier, but I get stuck simplifying the statement when the single quantifier is the first. I have also tried to give $$mathit p (x, y)$$ some meaning and talk about it, but I can't decide if they mean the same. Any help is appreciated!

## propositional calculation – Rule of substitution in logic

I am reading a logic book by Tarski and he says:

"Substitution rule: If a universal sentence, which has already been accepted as true, contains sentence variables, and if these variables are replaced by other oral variables, by oral functions or by sentences — always replacing the same expression with a given variable—, then the prayer obtained in this way can also be recognized as true. "

"When we want to apply the substitution rule, we omit the quantifier and substitute the variables that were previously linked by this quantifier, other related variables or compound expressions, any other united variable that may occur in the sentence function must remain unchanged, and in the expressions we cannot accept any variable that has the same form as the joined ones; finally, if necessary, a universal quantifier is established in front of the expression obtained in this way, to turn it into a sentence ".

Then proceed with an example:

"applying the substitution rule to the sentence:
for any number x there is a number and such that x + y = 5
The following sentence can be obtained:
for any number z there is a number and such that z² + y = 5 "

How is this possible? Isn't it wrong "z²" since it says "always substituting the same expression for a given variable at all times"?

## Need help with filter logic

I have noticed two possible different behaviors for checkbox filters and I was wondering if someone could shed some light on how these cases should be treated as a designer.

Case 1:
SHOES> COLOR> [x] red, [x] blue, [] yellow.
This should show you all blue and all yellow shoes.

Case 2:
Rooms> Services> [x] wifi, [x] balcony, [] breakfast
Now, in this case, we want to see all the rooms that have wifi and balcony.

In case 1, you will see more results with each check box selected, while in case 2 it is the other way around. However, the interface looks exactly the same. How can I deal with this? Do we assume what are the expectations of the users for the given context and design the logic as such?

## Proof techniques – Prove a first-order logic theorem in equitable logic with a rewrite system of terms

I am trying to translate and prove a theorem, originally written in first order logic (FOL), in a combination of equitable logic (EL) and Boolean logic (BL) (more precisely a model of Boolean algebra). The target language also allows Skolemization (Sk). Then the translation task is from FOL to EL + BL + Sk. My motivation is that if my translation and the subsequent test in EL + BL + Sk are correct, then I should be able to perform such tests using a Rewrite System of Terms (TRS). TRS can be used to test equitable theories. Because EL + BL is a sublogic of FOL and Skolemization results in an equisatisfactable system, a valid proof in EL + BL + Sk is expected to be a valid proof of the original FOL theorem. Below is an example of FOL and my attempt at a natural deduction test. This is followed by my translation attempt and test in EL + BL + Sk. See translation / test notes below.

My questions are:

Is the tentative translation of FOL to EL + BL + Sk correct?

Is the tentative test correct in EL + BL + Sk?

Does the proof in EL + BL + Sk count as proof of the original FOL theorem? I'm not sure how it proves the theoretical implication ($$vdash$$) in FOL refers to semantic linking ($$models$$) in EL + BL + Sk. Does ($$Gamma models_ {EL + BL + Sk} varphi iff Gamma vdash_ {FOL} varphi$$) to hold?

Examples of FOL formulas

At least one person likes each person: $$exists y for all x: I like (x, y)$$

Each person likes at least one person: $$( forall x exist y: Like (x, y))$$

I want to try: $$( exist y forall x: Like (x, y)) vdash ( forall x exist y: Like (x, y))$$

Natural deduction test (ND)

The ND test uses syntactic consequence where $$Gamma vdash varphi$$ means that prayer $$varphi$$ is demonstrable from the set of assumptions $$Gamma$$.
begin {align *} & textbf {FOL theorem} ~~ ( exist y forall x: Likes (x, y)) vdash ( forall x exist y: Likes (x, y)) \ & \ & textbf {Notation for EL + BL + Sk} \ & x ~~~~~~~~~~~~~~~~~~~~~~~~~ forall x ~~ text {Universally quantified variable} \ & c ~~~~~~~~~~~~~~~~~~~~~~~~~~ text {Skolem Constant} \ & d ~~~~~~~~~~~~~~~~~~~~~~~~ text {Arbitrary Person , for universal removal} \ & mathtt {skFun} ~~~~~~~~~~~~~~~~ text {Skolem function} \ & mathtt {Like} ~~~~~~~~~~~~~~~~ text {Boolean Value Function} \ & mathtt {true} ~~~~~~~~~~~~~~~~~~ text {Boolean constant} \ & \ & textbf {Translation of the theorem into EL + BL + Sk:} \ & ( forall x: ( mathtt {skFun} (x) = c, mathtt {Like} (x, c))) models ( forall x: mathtt {Like} (x, mathtt { skFun} (X))) \ & \ & textbf {Test in EL + BL + Sk} \ & textbf {1} ~~ forall x: mathtt {Like} (x, c) = true ~~~~~~ text {Assumption, with constant Skolem c } \ & textbf {2} ~~ forall x: mathtt {skFun} (x) = c ~~~~~~~~~~~~~~~ text {Interpretation of Sk. work with Sk. constant c } \ & textbf {3} ~~ mathtt {Like} (d, mathtt {skFun} (d)) ~~~~~~~~~~~~ text {Universal deletion and Skolemization of the term to be tested } \ & textbf {4} = ~~~~~ mathtt {Like (d, c)} ~~~~~~~~~~~~~~~~ text {Apply 2 to the second argument of 3} & textbf {5} = ~~~~~~ true ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ text {Apply 1 to 4 } \ end {align *}
Notes on translation / proof.

• The EL + BL + Sk test is based on an interpretation, so the translation needs semantic involvement $$models$$. In general, this can be written as $$Gamma models_ {EL + BL + Sk} varphi$$, which means that under $$EL + BL + Sk$$ logic prayer $$varphi$$ is true in all models of $$Gamma$$.

• In EL, all variables are considered universally quantified.

• Existential variables in FOL that are not within the scope of universals are translated into Skolem constants.

• Existential variables in FOL that are in the field of universals are translated into functions of Skolem, p. $$mathtt {skFun} (x)$$ with unique universal argument of $$x$$. The original existential was in scope $$x$$.

• Each predicate in FOL translates to an operation of Boolean value in EL + BL + Sk, p. predicate $$Like$$ becomes a boolean operation $$mathtt {Like}$$.

• In EL terms, they are different, unless they are made identical or equal by equations.

Below is the list in CafeOBJ using TRS. The command `red` reduce a given term by considering the declared equations as rewrite rules from left to right

``````mod LIKES {
(Person)
pred Likes : Person Person
}

op c : -> Person .
ops d : -> Person .
op skFun : Person -> Person .
-- Hypothesis
eq (assumption) : Likes(x:Person,c) = true .
eq (skolem) :  skFun(x:Person) =  c .
red Likes(d,skFun(d)) .
--> Gives true
``````