What are some general lines of attack when proving that some system of axioms is not equivalent to some other system?

I created two axioms, we can call them $ A_1$ and $ A_2$ , inside a theory $ T$ axiomatized by axioms $ \{B_1,…,B_k\}$ .

There is one axiom from a theory $ T$ , for example $ B_k$ , that I can prove with $ A_1$ and $ A_2$ inside a theory $ T \setminus \{B_k\}$ , that is, I can prove that $ (T \setminus \{B_k\}) \cup \{A_1,A_2\}$ implies $ T$ .

But, I am not sure does $ T$ implies $ T \cup \{A_1,A_2\}$ .

What are some general lines of attack on such a problems?

What do you suggest me to read to understand better the issues in problems like these ones?

My training in mathematical logic is at some basic undergraduate level, and I think that in advanced mathematics all of this has been investigated and well-understood, I just need some guidelines and to know where to start from.

If this question is not appropriate for MO notify me and I will delete it.

Java TreeMap.floorKey() equivalent in CPP STL map class

Java Program:

TreeMap<Integer,Integer> map = new TreeMap<Integer,Integer>();     map.put(10, 100);     map.put(20, 200);     map.put(30, 300);     map.put(40, 400);     map.put(50, 500);     map.put(60, 600);     map.put(70, 700);     map.put(80, 800);      System.out.println(map.floorKey(5));     System.out.println(map.floorKey(9));     System.out.println(map.floorKey(10));     System.out.println(map.floorKey(11));     System.out.println(map.floorKey(90)); 

output: null null 10 10 80

As there is no direct API to achieve the same in C++, to replicate the same floorKey method in C++, here is the code I have written.

C++ Code:

template <typename key,typename value> int floorKey(map<key, value> input, int key) {     auto begin = input.begin();     if (begin->first > key)//if key is less than the first key. It must retrun -1;         return -1;      auto end = input.end();     end--;     if (end->first < key)//if key is greater than last key, it must return last key         return end->first;      //if key is equal to any existing key, it should return the key     auto find = input.find(key);      if (find != input.end())         return key;      //Return the floor key for the given key     auto lower = input.lower_bound(key);      lower--;     return lower->first; }  int main() {     map<int, int> map;     map.insert({ 10, 100 });     map.insert({ 20, 200 });     map.insert({ 30, 300 });     map.insert({ 40, 400 });     map.insert({ 50, 500 });     map.insert({ 60, 600 });     map.insert({ 70, 700 });     map.insert({ 80, 800 });       cout << floorKey(map, 5) << endl;     cout << floorKey(map, 9) << endl;     cout << floorKey(map, 10) << endl;     cout << floorKey(map, 11) << endl;     cout << floorKey(map, 90) << endl;     return 0; } 

output: -1 -1 10 10 80

Is it correct way to perform this or is there any better way to get the same? Thanks in advance!!

Is there a celestial/good equivalent of the Fiendish Codexes and Fiend Folio?

I have recently been studying D&D Cosmology and was impressed by the level of detail in the descriptions of Baator and The Abyss found in Fiendish Codex I & II.

Are there any source books that explore the good aligned outer planes to the same detail? Specifically I want to learn more about Celestia, Elysium or Arborea.

Is there an Android equivalent to iOS’s “CallKit”?

This actually seems like a very Android-like feature. When I heard about it, I thought there might be an Android equivalent.

It lets VoIP apps use the standard phone app to call/receive calls, integrating with the phone’s contacts and recent calls list. Basically, it turns VoIP calls into regular phone calls (at least for apps that support it).

If there is nothing like this on Android, is there any indication that Google will add something like this to a future version?

Is the C# async/Task construct equivalent to Java’s Executor/Future?

I’m a long time Java developer, but with so little traffic on SE, I don’t limit my viewing to any single tags. I’ve noticed that C# questions with async/await come up a lot, and as far as I’ve read it’s the standard (but somewhat recent) asynchronous programming mechanism in C#, which would make it equivalent to Java’s Executor, Future or perhaps more accurately CompatibleFuture constructs (or even wait()/notify() for very old code).

Now async / await seems like a handy tool, quick to write and easy to understand, but the questions give me the feeling that people are trying to make everything async, and that this isn’t even a bad thing.

In Java, code that would attempt to offload work to different threads as often as possible would seem very odd, and real performance advantages come from specific well thought out places where work is divided to different threads.

Is the discrepancy because of a different threading model? Because C# is often desktop code with a well known platform under it, whereas Java is mainly server side these days? Or have I just gotten a skewed image of its relevancy?

From https://markheath.net/post/async-antipatterns we have:

foreach(var c in customers) {     await SendEmailAsync(c); } 

as an example of acceptable code, but this seems to suggest “make everything asynchronous, you can always use await to synchronize”. Is it because the await already indicates that there’s actually no reason to switch threads, whereas in Java

for(Customer c : customer) {     Future<Result> res = sendEmailAsync(c);     res.get(); } 

would actually perform the work in a different thread, but get() would block, so it would be sequential work, but using 2 threads?

Of course with Java, the standard idiom would be to let the caller decide whether something needs to be async, rather than having the implementation decide it in advance E.g.

for(Customer c : customer) {     CompletableFuture<Void> cf = CompletableFuture.runAsync(() -> sendEmailSync(c));     // cf can be further used for chaining, exception handling, etc. } 

Is there a GET equivalent to Set-PnPListItemPermission?

I am trying to get a list of all the users that have been granted special permission to a list of files inside a library. I was able to set the permission using Set-PnpListItemPerission but can’t seem to find the reverse anywhere.

Can anyone suggest a way of listing all the users and permissions granted for a file (list item) in a library? Thanks!!

Equivalent condition for distributive property of $\mathcal{S}(M)$

$ \textbf{Definitions:}$

Let $ M$ be an $ A$ -module. The collection $ \mathcal{S}(M)$ of all submodules of $ M$ is partially ordered by the inclusion relation. The collection $ \mathcal{S}(M)$ is said to be distributive if and only if the following equivalent identities hold for all choices of $ N,P,Q\in\mathcal{S}(M)$ :

(a) $ N\cap(P+Q)=(N\cap P)+(N\cap Q)$

(b) $ N+(P\cap Q)=(N+P)\cap (N+Q)$

(c) $ (N\cap P)+(P\cap Q)+(Q\cap N)= (N+P)\cap (P+Q)\cap (Q+N)$

$ \textbf{Question:}$

Prove that $ \mathcal{S}(M)$ is distributive if and only if for $ N,P,Q\in\mathcal{S}(M)$ , if $ N\cap P=N\cap Q$ and $ N+P=N+Q$ , then $ P=Q$ .

$ \textit{Proof}:$ ($ \implies$ ) Let $ \mathcal{S}(M)$ be distributive and $ N,P,Q\in\mathcal{S}(M)$ havethe given properties.

Then \begin{equation} P = P\cap(N+P) =P\cap(N+Q) =P\cap N + P\cap Q\ = Q\cap N + P\cap Q =Q\cap(P+N) =Q\cap(Q+N) =Q. \end{equation}

I’m facing problem with proving the reverse implication. My idea of the proof is using contradiction.

If possible assume that $ \mathcal{S}(M)$ is not distributive. So there exist $ N,P,Q\in\mathcal{S}(M)$ such that $ (N\cap P)+(N\cap Q)\subsetneq N\cap(P+Q)$ . If I can come up with some submodule in between these two which will act as $ ‘N’$ in the property, then I’ll be done.

I would like to get a hint about this problem. You can suggest me another ways for the same, as well. Thanks in advance.