# Define the pillars
pillars = [
"Pillar of Mercy",
"Pillar of Balance",
"Pillar of Severity"
]
# Assign each Sephirot to a pillar
sephirot_pillars = {
"Keter": "Pillar of Balance",
"Chokhmah": "Pillar of Mercy",
"Binah": "Pillar of Severity",
"Chesed": "Pillar of Mercy",
"Gevurah": "Pillar of Severity",
"Tiferet": "Pillar of Balance",
"Netzach": "Pillar of Mercy",
"Hod": "Pillar of Severity",
"Yesod": "Pillar of Balance",
"Malkuth": "Pillar of Balance",
}
# Initialize the tensor with zeros
tensor = np.zeros((len(pillars), len(sephirot), len(sephirot*~~
# Populate the tensor with connections from the adjacency matrix
for i in range(len(sephirot)):
for j in range(len(sephirot)):
if sephirot_matrix[i][j] == 1:
pillar = sephirot_pillars[sephirot[i]]
pillar_index = pillars.index(pillar)
tensor[pillar_index, i, j] = 1
for p in range(len(pillars)):
print(f"nConnections in the {pillars[p]}:")
for i in range(len(sephirot)):
if sephirot_pillars[sephirot[i]] == pillars[p]:
print(f"{sephirot[i]} is connected to: ", end="")
for j in range(len(sephirot)):
if tensor[p, i, j] == 1:
print(sephirot[j], end=", ")
print()
Imagine doing all these mental gymnastics to try to reconcile polytheism with monotheism when Hinduism already created the perfect, elegant solution (Brahman, the eternal spiritual force that pervades all of existence)
public interface God
{
class Father implements God
{
private Father() { }
}
class HolySpirit implements God
{
private HolySpirit() { }
}
class Son implements God
{
private int seconds;
private ScheduledExecutorService time = Executors.newSingleThreadScheduledExecutor();
public Son()
{
run();
}
class HolyTrinity:
def __init__(self):
self.TheFather = Entity("The Father", "The Creator of Heaven and Earth")
self.TheSon = Entity("The Son", "Jesus Christ, who was conceived by the Holy Spirit, born of the Virgin Mary, suffered under Pontius Pilate, was crucified, died and was buried; he descended into hell; on the third day he rose again from the dead")
self.TheHolySpirit = Entity("The Holy Spirit", "The Lord and giver of life, who proceeds from the Father and the Son, who with the Father and the Son is adored and glorified, who has spoken through the prophets")
>36 posts >no correct answer
public void God(string name)
{
//name can be the father, the son, the holy spirit, allah, flying spaghetti monster or anything you wish!
return null;
}
crack.smoke()
God = [ths, tf, ts]
public class God : IFather, ISon, IHolySpirit
{
public static void Main()
{
Console.WriteLine("Let there be light");
}
}
Of course, I should also make it singleton.
int CompareEquality(char *thing1, char *thing2)
{
if (!Strcmp(thing1, "God") || !Strcmp(thing2, "God")) return 1;
else return 0;
}
class Person {
constructor(name) {
this.name = name;
}
}
class God extends Person {
constructor(name) {
super(name);
}
}
let Father = new God('Father');
let Son = new God('Son');
let Spirit = new God('Spirit');
function question() {
let isFatherGod = Father instanceof God;
let isSonGod = Son instanceof God;
let isSpiritGod = Spirit instanceof God;
let isFatherNotSon = Father !== Son;
let isSonNotFather = Son !== Father;
let isNeitherSpirit = Father !== Spirit && Son !== Spirit;
if (isFatherGod && isSonGod && isSpiritGod && isFatherNotSon && isSonNotFather && isNeitherSpirit) {
return true;
} else {
return false;
}
}
console.log(question());
>let Son = new God('Son');
now THIS is heresy
this is the work of satan obviously you trying to trick me devil into your nefarious schemes checkmate i aint got to code shit
This meme should be an argument against using this devil worshipper language
Accompanying audio: https://www.whyp.it/tracks/100212/trinity-diagram-audio?token=0owVt
data God = Father | Son | HolySpirit
What language is this?
Quenderin
ITT: people who dont understand the trinity
Feel free to enlighten us.
>code it
You can't
the father is user, the son is avatar and the holy spirit is the code.
But what about this """""""thing""""""""
the pit
>the father is user, the son is avatar and the holy spirit is the code
Best analogy I've seen in a while.
israeli mysticism is the deepest rabbit hole that exists, decades of study and you barely scratch the surface, idk wtf they're onto
Most likely to be schizophrenic
They just copied the tree of life. Actually indus have put more insight into it.
import numpy as np
# Define the Sephirot
sephirot = [
"Keter",
"Chokhmah",
"Binah",
"Chesed",
"Gevurah",
"Tiferet",
"Netzach",
"Hod",
"Yesod",
"Malkuth"
]
# Define the adjacency matrix
sephirot_matrix = [
[0, 1, 1, 0, 0, 0, 0, 0, 0, 0],
[1, 0, 1, 1, 1, 0, 0, 0, 0, 0],
[1, 1, 0, 1, 1, 0, 0, 0, 0, 0],
[0, 1, 1, 0, 1, 1, 1, 0, 0, 0],
[0, 1, 1, 1, 0, 1, 1, 0, 0, 0],
[0, 0, 0, 1, 1, 0, 1, 1, 1, 0],
[0, 0, 0, 1, 1, 1, 0, 1, 1, 0],
[0, 0, 0, 0, 0, 1, 1, 0, 1, 1],
[0, 0, 0, 0, 0, 1, 1, 1, 0, 1],
[0, 0, 0, 0, 0, 0, 0, 1, 1, 0]
]
# Define the pillars
pillars = [
"Pillar of Mercy",
"Pillar of Balance",
"Pillar of Severity"
]
# Assign each Sephirot to a pillar
sephirot_pillars = {
"Keter": "Pillar of Balance",
"Chokhmah": "Pillar of Mercy",
"Binah": "Pillar of Severity",
"Chesed": "Pillar of Mercy",
"Gevurah": "Pillar of Severity",
"Tiferet": "Pillar of Balance",
"Netzach": "Pillar of Mercy",
"Hod": "Pillar of Severity",
"Yesod": "Pillar of Balance",
"Malkuth": "Pillar of Balance",
}
# Initialize the tensor with zeros
tensor = np.zeros((len(pillars), len(sephirot), len(sephirot*~~
# Populate the tensor with connections from the adjacency matrix
for i in range(len(sephirot)):
for j in range(len(sephirot)):
if sephirot_matrix[i][j] == 1:
pillar = sephirot_pillars[sephirot[i]]
pillar_index = pillars.index(pillar)
tensor[pillar_index, i, j] = 1
for p in range(len(pillars)):
print(f"nConnections in the {pillars[p]}:")
for i in range(len(sephirot)):
if sephirot_pillars[sephirot[i]] == pillars[p]:
print(f"{sephirot[i]} is connected to: ", end="")
for j in range(len(sephirot)):
if tensor[p, i, j] == 1:
print(sephirot[j], end=", ")
print()
Imagine doing all these mental gymnastics to try to reconcile polytheism with monotheism when Hinduism already created the perfect, elegant solution (Brahman, the eternal spiritual force that pervades all of existence)
Do believers of that religion say "bruh" instead of "amen"?
if true == false
if terry was alive he would know how
>trinityfags
enum class Trinity : int {non_trinity, father, son, holy_spirit};
bool is_god(Trinity t) {
return t == Trinity::father || t == Trinity::son || t == Trinity::holy_spirit;
}
const God = {
Father: "Father",
Son: "Son",
HolySpirit: "Holy Spirit",
} as const;
type GodForm = keyof typeof God;
const holyTypeGuard = (
godForm: GodForm,
god: keyof typeof God,
): godForm is typeof god => {
return godForm === god;
}
const godForms = Object.keys(God) as Array<GodForm>;
const Father = godForms.filter((form) => holyTypeGuard(form, "Father"));
console.log(Father) // prints ["Father"]
#include <iostream>
class God;
class TheFather;
class TheSon;
class TheHolySpirit;
class God {
public:
bool operator==(TheFather&) { return true; }
bool operator==(TheSon&) { return true; }
bool operator==(TheHolySpirit&) { return true; }
};
class TheFather {
public:
bool operator==(God&) { return true; }
bool operator==(TheSon&) { return false; }
bool operator==(TheHolySpirit&) { return false; }
};
class TheSon {
public:
bool operator==(God&) { return true; }
bool operator==(TheFather&) { return false; }
bool operator==(TheHolySpirit&) { return false; }
};
class TheHolySpirit {
public:
bool operator==(God&) { return true; }
bool operator==(TheFather&) { return false; }
bool operator==(TheSon&) { return false; }
};
int main() {
God god;
TheFather the_father;
TheSon the_son;
TheHolySpirit the_holy_spirit;
std::cout << (god==the_father) << std::endl;
std::cout << (god==the_son) << std::endl;
std::cout << (god==the_holy_spirit) << std::endl;
std::cout << (the_father==the_son) << std::endl;
std::cout << (the_father==the_holy_spirit) << std::endl;
std::cout << (the_holy_spirit==the_son) << std::endl;
return 0;
}
interface IsGod
Father implements IsGod
Son implements IsGod
HolySpirit implements IsGod
and don't use interface defeating the whole point of having an interface
public interface God
{
class Father implements God
{
private Father() { }
}
class HolySpirit implements God
{
private HolySpirit() { }
}
class Son implements God
{
private int seconds;
private ScheduledExecutorService time = Executors.newSingleThreadScheduledExecutor();
public Son()
{
run();
}
private void run()
{
seconds++;
if(seconds < 86745600)
{
time.schedule(this::run, 1, TimeUnit.SECONDS);
}
else
{
System.exit(1);
}
}
}
static void main(String[] args)
{
// Other classes don't need to be initialized
new Son();
}
}
(Note that your OS needs to be synchronized with universal time to have accurate time tracking)
class Entity:
def __init__(self, name, description):
self.name = name
self.description = description
def __str__(self):
return f'{self.name}: {self.description}'
class HolyTrinity:
def __init__(self):
self.TheFather = Entity("The Father", "The Creator of Heaven and Earth")
self.TheSon = Entity("The Son", "Jesus Christ, who was conceived by the Holy Spirit, born of the Virgin Mary, suffered under Pontius Pilate, was crucified, died and was buried; he descended into hell; on the third day he rose again from the dead")
self.TheHolySpirit = Entity("The Holy Spirit", "The Lord and giver of life, who proceeds from the Father and the Son, who with the Father and the Son is adored and glorified, who has spoken through the prophets")
def __str__(self):
return str(self.TheFather) + 'n' + str(self.TheSon) + 'n' + str(self.TheHolySpirit)
def main():
trinity = HolyTrinity()
print(trinity)
if __name__ == "__main__":
main()
when you try to teach AI to be politically correct
absolutely blasphemous
>36 posts
>no correct answer
public void God(string name)
{
//name can be the father, the son, the holy spirit, allah, flying spaghetti monster or anything you wish!
return null;
}
god = None
checkmate christfags
I already exist so there's no point in it.
>paganism
>on LULZ
I hate christians
itt:modalist heretics