Atheism in the DnD5e universe: is it a thing, and how common is it? Are clerics accepted to derive power from the divine?

My question comes up from a bit of weird exchange we had last session. Short version of the question: Is not believing in the existence of gods in most DnD universes really a widespread thing? Are clerics that can tap into these abilities very uncommon or believed to get their magic from some other source? And if no to these, how does one handle PC’s behaving as if this were so?

Long version: I ended up multiclassing cleric through a pretty cool set of story hooks that my DM did a good job working with me in setting up. I definitely wasn’t a stereotypical stoic priest preaching about my god or anything like that.

In terms of story as it played out when I revealed this new power to the rest of the party (which they were present OOC for me receiving), one of our party had a roleplay situation that came where I could use my new class to help, and I told the rest of party that if they would help me, I’d like to offer this help to the other PC (the object of the help was not present IC so didn’t react).

I was kinda bummed that the reception was anywhere from condescension to incredulity (both IC and OOC), at least one of them heavily implying that thinking a god exists is stupid, and I really felt like this was out of place; my impression (granted, as someone fairly new to this) was that the existence of gods in the DnD universes are no more contested than the existence of magic: it exists, everyone knows it exists whether or not they’ve directly been affected by it. Is this impression wrong? I feel as though nobody would have blinked if I multiclassed into warlock and made a pact with a supernatural being, but for some reason because it was explicitly a ‘god’ I attuned to there was a lot more incredulity.

I’m not really sure how to handle this going forward. Is this the sort of thing I should talk the DM about and get straight? Should I talk with the other players directly? Is my impression on the wide acceptance of gods just wrong? Not sure how to deal with this, IC or OOC. It sorta sucks, because I was really excited for this multiclass and I walked away feeling kinda dumb and not really being into it anymore. Thanks for suggestions.

E: Should have mentioned, we are using homebrew that seems to get material like this from Forgotten Realms based on our warlock’s already-existing pact. DM hasn’t mentioned to either of us to tailor our choices of being to his setting.

How to derive and integrate this interpolation function?

I have a problem with this function that I interpolated with a discrete data, I need to derive and then integrate to have a numerical values.

perfil = Import[data,"Table"]     Extrados = Table[perfil[[x]], {x, 1, 26}]; Intrados = Table[perfil[[x]], {x, 26, 51}]; \[Eta]u = Interpolation[Extrados]; \[Eta]i = Interpolation[Intrados]; \[Eta]c = 1/2 (\[Eta]u[x] + \[Eta]i[x]); d\[Eta]c = D[\[Eta]c, x] 

But I have the following output: So I can’t have a numerical values. I need to derive it and then integrate it

Subscript[B, 0] = 2/\[Pi] \!\( \*SubsuperscriptBox[\(\[Integral]\), \(0\), \(\[Pi]\)]\(d\[Eta]c \ \[DifferentialD]\[Theta]\)\) 

But the solution it’s the same. Someone know another solution about this? Why mathematica doesn’t gave me a symbolic function?

Tried to derive the Z combinator and instead derived another

I was working to derive the Z-Combinator by starting with the factorial function and ended up deriving a different fixed-point combinator. What did I derive? Did I make a subtle mistake?

Here are the steps I performed (in JavaScript)

1. Declare factorial function

let fact = n =>     n < 2 ? 1 : n * fact(n - 1) 

2. Convert to combinator (closed expression)

let fact = (self, n) =>     n < 2 ? 1 : n * self(n - 1) 

3. Thread self call

Based on signature fact(?, 7), passing fact as first argument seems reasonable fact(fact,7). So thread the parameter through the tail call:

let fact = (self, n) =>     n < 2 ? 1 : n * self(self, n - 1) 

Usage is now fact(fact,7)5040

4. Refactor to curried form

let fact = self =>     n => n < 2 ? 1 : n * self(self)(n - 1) 

5. Move self application to local declaration

let fact = self => {     let f = n => self(self)(n)     return n => n < 2 ? 1 : n * f(n - 1) } 

6. Convert let declaration to lambda expression

let fact = self =>     (f =>         n => n < 2 ? 1 : n * f(n - 1)     )(         n => self(self)(n)     ) 

Usage is still fact(fact)(7)5040

7. Separate the factorial expression

let _fact = f => n =>     n < 2 ? 1 : n * f(n - 1)  let fact = self =>     (         _fact     )(         n => self(self)(n)     ) 

8. Move self-application from caller to body

let _fact =     f => n => n < 2 ? 1 : n * f(n - 1)  let fact = (() => {     let innerFact = self =>         (             _fact         )(             n => self(self)(n)         )     return innerFact(innerFact) })() 

Usage is now fact(7)5040

9. Convert let declaration to lambda expression

let _fact =     f => n => n < 2 ? 1 : n * f(n - 1)  let fact = (() => {     return (         innerFact => innerFact(innerFact)     )(         self => (_fact)(n => self(self)(n))     ) })() 

10. Simplify expression

let _fact =     f => n => n < 2 ? 1 : n * f(n - 1)  let fact =     (innerFact => innerFact(innerFact))     (self => (_fact)(n => self(self)(n))) 

Sanity check. Usage is still fact(7)5040

11. Rename variables

The usage of innerFact and self look suspiciously similar. Rename to the same variable to discover a pattern. Separate lexical scopes so safe to do:

let _fact =     f => n => n < 2 ? 1 : n * f(n - 1)  let fact =     (u => u(u))     (u => (_fact)(n => u(u)(n))) 

12. Abstract _fact usage and rename fact

Rename fact to setup and abstract _fact in body by replacing with parameter f

let _fact =     f => n => n < 2 ? 1 : n * f(n - 1)  let setup = f =>     (u => u(u))     (u => (f)(n => u(u)(n)))  let fact = setup(_fact) 

No need for separate _fact declaration so inline:

let setup = f =>     (u => u(u))     (u => (f)(n => u(u)(n)))  let fact = setup(     f => n => n < 2 ? 1 : n * f(n - 1) ) 

13. Rename setup

Rename it to what? What combinator is this? According to Wikipedia The Z combinator is:

let Z = f =>      (u => f(v => u(u)(v)))     (u => f(v => u(u)(v))) 

But what I’ve derived is:

let setup = f =>     (u => u(u))     (u => (f)(n => u(u)(n))) 

Defining fact in terms of either seems equivalent in behavior. Did I make a mistake? Did I accidentally rediscover another well-known combinator?

Can Homotopy Type Theory be used to derive more efficient algorithms on more efficient data representations from less efficient ones?

I’ve read here that in HoTT, compilers could swap out less efficient representations of data for more efficient ones and I’m wondering whether my interpretation of this statement is correct.

Say we have two different ways of representing the natural numbers, unary (zero and successor) and binary. Here is a function that checks evenness on the former representation:

even : UnaryNat -> Bool even zero = true even (succ zero) = false even (succ (succ n)) = even n 

If we then have an isomorphism between the unary and binary representations, we trivially get an evenness function for the binary representation “for free”, simply by converting a given binary natural number to a unary one, applying the even function, and converting the result back to the binary representation. Obviously, this is not very efficient, and we also don’t need HoTT for this.

A better way to check whether a binary natural number is even would be to check if its least significant digit is a zero. My question is: Could we derive this more efficient algorithm for binary natural numbers from our definition of evenness for unary natural numbers using HoTT? If so, would this also be possible for other data types? I haven’t studied any HoTT yet and since its appears to be a pretty complex subject I would like to find out whether it’s as exciting as I think it is. Thanks!

Domain of definition for the following variables: is it possible to derive in Mathematica?

Consider 4 4-vectors $ $ P_{0} = (E_{0},0,0,\sqrt{E_{0}^{2}-m_{0}^{2}}), \quad P_{i} = (E_{i},p_{i}s(\theta_{i})c(\phi_{i}),p_{i}s(\phi_{i})s(\theta_{i}),p_{i}c(\theta_{i})), $ $ with $ c \equiv \cos, s \equiv \sin$ , $ p_{i}\equiv \sqrt{E_{i}^{2}-m_{i}^{2}}$ and the scalar products $ $ P_{i}\cdot P_{j} \equiv P_{i}^{0}P_{j}^{0} – \sum_{k = 1}^{3}P_{i}^{k}P_{j}^{k} $ $ $ m_{0-3},E_{0}$ play the role of real parameters, with $ E_{0}> m_{0}>m_{1}+m_{2}+m_{3}$ and $ E_{i}\geqslant m_{i}$ , while $ E_{i},\theta_{i},\phi_{i}$ are variables.

The implicit region of the definition of $ E_{i},\theta_{i},\phi_{i}$ is given by $ $ \tag 1 P_{3} = P_{0}-P_{1}-P_{2}, $ $ $ $ \tag 2 s_{12,\text{min}}(s_{23})<s_{12}<s_{12,\text{max}}(s_{23}), \quad s_{23,\text{min}}<s_{23}<s_{23,\text{max}}, $ $ where $ s_{ij} = m_{i}^{2}+m_{j}^{2}+2P_{i}\cdot P_{j}$ , and $ $ \tag 3 s_{12,\text{min}/\text{max}} = m_{1}^{2}+m_{2}^{2}-\frac{1}{2s_{23}}\bigg(s_{23}-m_{0}^{2}+m_{1}^{2})(s_{23}-m_{2}^{2}-m_{3}^{2}) \pm \ \pm \sqrt{\lambda(s_{23},m_{0}^{2},m_{1}^{2})\lambda(s_{23},m_{2}^{2},m_{3}^{2})}\bigg), $ $ $ $ \tag 4 s_{23,\text{min}} = (m_{2}+m_{3})^{2}, \quad s_{23,\text{max}} = (m_{0}-m_{1})^{2}, \quad \lambda(a,b,c) = (a-b-c)^{2}-4bc $ $

I need to integrate a function $ f(E_{i},\theta_{i},\phi_{i})$ over the domain of the definition $ (1)-(4)$ of the mentioned variables. Is it possible to derive the domain of definition in Mathematica, at least implicitly, in order to perform the integration? There are so many variables…

If I derive an encryption key from an SSH private key, will it be “secure”

I would like to leverage my SSH keys for encryption my data. Since it is fairly trivial to unlock my SSH key on login, I can easily connect an SSH agent and get my private key rather than have to maintain another passphrase.

If I am using AES to encrypt my data with a 256 bit key, then I have to ensure my key is that size which will not be the case with using my SSH key directly, generally speaking. That means, I could hash my private key directly with SHA256.

Now, would it provide additional “security” if I hash my private key many times? Additionally, if I include a random salt unique to each “secret”, would that further help to secure the “secret”?


  1. unlock private SSH key via SSH agent
  2. use SSH agent to get private key
  3. generate random salt
  4. hash salt with private key many times to generate unique key for the secret
  5. store salt and secret

To Decrypt

  1. use stored salt and rehash to generate unique key
  2. ecrypt with generated unique key

Can Aasimar derive from stock other than human?

Inspired by this question: Can Tieflings derive from stock other than human?
Separated out from this question: Can Genasi derive from stock other than human?

Crudely speaking, tieflings are half-human, half-devil. However, as the answer to the other question (the one about tieflings) points out, non-human half-devils/demons exist, such as the Fey’ri, who are half-elven, half-demon.

Aasimar are half-human, half-angel (again, crudely speaking; it’s more like mostly human and a tiny fraction part-angel, as I understand it). Taken from Volo’s Guide to Monsters, pg. 104, here are some quotes that explain why I believe them to be so:

They are descended from humans with a touch of the power of Mount Celestia, the divine realm of many lawful good deities. Aasimar are born to serve as champions of the gods, their births hailed as blessed events. They are a people of otherworldly visages, with luminous features that reveal their celestial heritage.


Conflicted Souls

Despite its celestial origin, an aasimar is mortal and possesses free will.

Hence I conclude that they are part angel, even if it’s not necessarily down to genetics (that is not what this question is about anyway). This question is about the human part, and whether that must always be the case.

Are there any non-human half-angels races, such as a half-elven, half-angel race?

I’m not that interested in a specific setting, but if setting matters, let’s go with the Forgotten Realms (or at the very least, not Eberron/Ravnica).

Derive a while loop, which seemingly have some logarithmic traits, runs in $\Theta(n)$

I know for a fact that algorithm A runs in $ \Theta(n)$ , but how does one derive that?

Algorithm A

i = 1 while i ≤ n   s = 0   while s ≤ i     s = s + 1   i = 2 ∗ i 

The inner loop is clearly $ O(i)$ (linear time).

The outer loop is clearly $ O(\log n)$ (logarithmic time).

A visualitation of the loop in terms of an input $ n$ would look as follows:

enter image description here , the black lines represents the amount of work or iterations required in terms of $ n$ .

Derive a while loop runs in $\Theta( \sqrt{n} )$

I know for a fact that algorithm A runs in $ \Theta(\sqrt{n})$ , but how does one derive that fact?

Algorithm A

i = 0 s = 0 while s <= n:     s += i     i += 1 

Here is what I am thinking. We know that A is upper-bounded by O(n), as we increment $ s$ by more than 1 in each iteration. We also know that it must be lower-bounded by $ \log n$ , as we increment $ s$ with by something less than $ 2^i$ in each iteration. (Correct me if I am wrong, these are just my thoughts …).

Now, what else can we say about A? How do we derive that its time complexity is $ \Theta(\sqrt{n})$ ?