temp

2024/documents/by-course/phil-1/paper-1/package.nix

@@ -0,0 +1,49 @@
+{
+  pkgs,
+  typstPackagesCache,
+  typixLib,
+  ...
+}:
+let
+  src = typixLib.cleanTypstSource ./.;
+  commonArgs = {
+    typstSource = "main.typ";
+
+    fontPaths = [
+      # Add paths to fonts here
+      # "${pkgs.roboto}/share/fonts/truetype"
+    ];
+
+    virtualPaths = [
+      # Add paths that must be locally accessible to typst here
+      # {
+      #   dest = "icons";
+      #   src = "${inputs.font-awesome}/svgs/regular";
+      # }
+    ];
+
+    XDG_CACHE_HOME = typstPackagesCache;
+  };
+
+  # Compile a Typst project, *without* copying the result
+  # to the current directory
+  build-drv = typixLib.buildTypstProject (
+    commonArgs
+    // {
+      inherit src;
+    }
+  );
+
+  # Compile a Typst project, and then copy the result
+  # to the current directory
+  build-script = typixLib.buildTypstProjectLocal (
+    commonArgs
+    // {
+      inherit src;
+    }
+  );
+
+  # Watch a project and recompile on changes
+  watch-script = typixLib.watchTypstProject commonArgs;
+in
+build-drv

2024/flake.lock

@@ -0,0 +1,99 @@
+{
+  "nodes": {
+    "flake-utils": {
+      "inputs": {
+        "systems": "systems"
+      },
+      "locked": {
+        "lastModified": 1726560853,
+        "narHash": "sha256-X6rJYSESBVr3hBoH0WbKE5KvhPU5bloyZ2L4K60/fPQ=",
+        "owner": "numtide",
+        "repo": "flake-utils",
+        "rev": "c1dfcf08411b08f6b8615f7d8971a2bfa81d5e8a",
+        "type": "github"
+      },
+      "original": {
+        "owner": "numtide",
+        "repo": "flake-utils",
+        "type": "github"
+      }
+    },
+    "nixpkgs": {
+      "locked": {
+        "lastModified": 1729256560,
+        "narHash": "sha256-/uilDXvCIEs3C9l73JTACm4quuHUsIHcns1c+cHUJwA=",
+        "owner": "NixOS",
+        "repo": "nixpkgs",
+        "rev": "4c2fcb090b1f3e5b47eaa7bd33913b574a11e0a0",
+        "type": "github"
+      },
+      "original": {
+        "owner": "NixOS",
+        "ref": "nixos-unstable",
+        "repo": "nixpkgs",
+        "type": "github"
+      }
+    },
+    "root": {
+      "inputs": {
+        "flake-utils": "flake-utils",
+        "nixpkgs": "nixpkgs",
+        "typix": "typix",
+        "typst-packages": "typst-packages"
+      }
+    },
+    "systems": {
+      "locked": {
+        "lastModified": 1681028828,
+        "narHash": "sha256-Vy1rq5AaRuLzOxct8nz4T6wlgyUR7zLU309k9mBC768=",
+        "owner": "nix-systems",
+        "repo": "default",
+        "rev": "da67096a3b9bf56a91d16901293e51ba5b49a27e",
+        "type": "github"
+      },
+      "original": {
+        "owner": "nix-systems",
+        "repo": "default",
+        "type": "github"
+      }
+    },
+    "typix": {
+      "inputs": {
+        "nixpkgs": [
+          "nixpkgs"
+        ]
+      },
+      "locked": {
+        "lastModified": 1728290750,
+        "narHash": "sha256-piLZT8398O69hy0e3gX8hUWqSzbCslMCt10pT8d6c8E=",
+        "owner": "loqusion",
+        "repo": "typix",
+        "rev": "62d032735ad32a9a90225c06cb0857677fc753ee",
+        "type": "github"
+      },
+      "original": {
+        "owner": "loqusion",
+        "repo": "typix",
+        "type": "github"
+      }
+    },
+    "typst-packages": {
+      "flake": false,
+      "locked": {
+        "lastModified": 1729252723,
+        "narHash": "sha256-xdaQYNw1GApaJnXJO4WnUTNuYeRXisxIUSuAzVXFEW4=",
+        "owner": "typst",
+        "repo": "packages",
+        "rev": "9bcf190c85da91be6df9f5fc25a93ce5812489cc",
+        "type": "github"
+      },
+      "original": {
+        "owner": "typst",
+        "repo": "packages",
+        "type": "github"
+      }
+    }
+  },
+  "root": "root",
+  "version": 7
+}

2024/flake.nix

@@ -0,0 +1,86 @@
+{
+  description = "Compiling work in 2024 in a reproducible manner";
+
+  inputs = {
+    nixpkgs.url = "github:NixOS/nixpkgs/nixos-unstable";
+
+    typix = {
+      url = "github:loqusion/typix";
+      inputs.nixpkgs.follows = "nixpkgs";
+    };
+
+    flake-utils.url = "github:numtide/flake-utils";
+
+    typst-packages = {
+      url = "github:typst/packages";
+      flake = false;
+    };
+
+    # Example of downloading icons from a non-flake source
+    # font-awesome = {
+    #   url = "github:FortAwesome/Font-Awesome";
+    #   flake = false;
+    # };
+  };
+
+  outputs =
+    inputs@{
+      nixpkgs,
+      typix,
+      flake-utils,
+      ...
+    }:
+    flake-utils.lib.eachDefaultSystem (
+      system:
+      let
+        pkgs = nixpkgs.legacyPackages.${system};
+      in
+      let
+        typstPackagesSrc = "${inputs.typst-packages}/packages";
+
+        typstPackagesCache = pkgs.stdenv.mkDerivation {
+          name = "typst-packages-cache";
+          src = typstPackagesSrc;
+          dontBuild = true;
+          installPhase = ''
+            mkdir -p "$out/typst/packages"
+            cp -LR --reflink=auto --no-preserve=mode -t "$out/typst/packages" "$src"/*
+          '';
+        };
+      in
+      let
+        inherit pkgs;
+        typixLib = typix.lib.${system};
+      in
+      {
+        # checks = {
+        #   inherit build-drv build-script watch-script;
+        # };
+
+        packages.default = import ./documents/by-course/phil-1/paper-1/package.nix {
+          inherit pkgs typixLib typstPackagesCache;
+        };
+        #   apps = rec {
+        #     default = watch;
+        #     build = flake-utils.lib.mkApp {
+        #       drv = build-script;
+        #     };
+        #     watch = flake-utils.lib.mkApp {
+        #       drv = watch-script;
+        #     };
+        #   };
+        #
+        #   devShells.default = typixLib.devShell {
+        #     inherit (commonArgs) fontPaths virtualPaths;
+        #     packages = [
+        #       # WARNING: Don't run `typst-build` directly, instead use `nix run .#build`
+        #       # See https://github.com/loqusion/typix/issues/2
+        #       # build-script
+        #       watch-script
+        #       # More packages can be added here, like typstfmt
+        #       pkgs.typstyle
+        #     ];
+        #   };
+      }
+    );
+}

2024/work/phil-1/paper-1-typix/.gitignore

@@ -0,0 +1 @@
+result*

2024/work/phil-1/paper-1-typix/flake.lock

@@ -0,0 +1,99 @@
+{
+  "nodes": {
+    "flake-utils": {
+      "inputs": {
+        "systems": "systems"
+      },
+      "locked": {
+        "lastModified": 1726560853,
+        "narHash": "sha256-X6rJYSESBVr3hBoH0WbKE5KvhPU5bloyZ2L4K60/fPQ=",
+        "owner": "numtide",
+        "repo": "flake-utils",
+        "rev": "c1dfcf08411b08f6b8615f7d8971a2bfa81d5e8a",
+        "type": "github"
+      },
+      "original": {
+        "owner": "numtide",
+        "repo": "flake-utils",
+        "type": "github"
+      }
+    },
+    "nixpkgs": {
+      "locked": {
+        "lastModified": 1729256560,
+        "narHash": "sha256-/uilDXvCIEs3C9l73JTACm4quuHUsIHcns1c+cHUJwA=",
+        "owner": "NixOS",
+        "repo": "nixpkgs",
+        "rev": "4c2fcb090b1f3e5b47eaa7bd33913b574a11e0a0",
+        "type": "github"
+      },
+      "original": {
+        "owner": "NixOS",
+        "ref": "nixos-unstable",
+        "repo": "nixpkgs",
+        "type": "github"
+      }
+    },
+    "root": {
+      "inputs": {
+        "flake-utils": "flake-utils",
+        "nixpkgs": "nixpkgs",
+        "typix": "typix",
+        "typst-packages": "typst-packages"
+      }
+    },
+    "systems": {
+      "locked": {
+        "lastModified": 1681028828,
+        "narHash": "sha256-Vy1rq5AaRuLzOxct8nz4T6wlgyUR7zLU309k9mBC768=",
+        "owner": "nix-systems",
+        "repo": "default",
+        "rev": "da67096a3b9bf56a91d16901293e51ba5b49a27e",
+        "type": "github"
+      },
+      "original": {
+        "owner": "nix-systems",
+        "repo": "default",
+        "type": "github"
+      }
+    },
+    "typix": {
+      "inputs": {
+        "nixpkgs": [
+          "nixpkgs"
+        ]
+      },
+      "locked": {
+        "lastModified": 1728290750,
+        "narHash": "sha256-piLZT8398O69hy0e3gX8hUWqSzbCslMCt10pT8d6c8E=",
+        "owner": "loqusion",
+        "repo": "typix",
+        "rev": "62d032735ad32a9a90225c06cb0857677fc753ee",
+        "type": "github"
+      },
+      "original": {
+        "owner": "loqusion",
+        "repo": "typix",
+        "type": "github"
+      }
+    },
+    "typst-packages": {
+      "flake": false,
+      "locked": {
+        "lastModified": 1729252723,
+        "narHash": "sha256-xdaQYNw1GApaJnXJO4WnUTNuYeRXisxIUSuAzVXFEW4=",
+        "owner": "typst",
+        "repo": "packages",
+        "rev": "9bcf190c85da91be6df9f5fc25a93ce5812489cc",
+        "type": "github"
+      },
+      "original": {
+        "owner": "typst",
+        "repo": "packages",
+        "type": "github"
+      }
+    }
+  },
+  "root": "root",
+  "version": 7
+}

2024/work/phil-1/paper-1-typix/flake.nix

@@ -0,0 +1,126 @@
+{
+  description = "A Typst project";
+
+  inputs = {
+    nixpkgs.url = "github:NixOS/nixpkgs/nixos-unstable";
+
+    typix = {
+      url = "github:loqusion/typix";
+      inputs.nixpkgs.follows = "nixpkgs";
+    };
+
+    flake-utils.url = "github:numtide/flake-utils";
+
+    typst-packages = {
+      url = "github:typst/packages";
+      flake = false;
+    };
+
+    # Example of downloading icons from a non-flake source
+    # font-awesome = {
+    #   url = "github:FortAwesome/Font-Awesome";
+    #   flake = false;
+    # };
+  };
+
+  outputs =
+    inputs@{
+      nixpkgs,
+      typix,
+      flake-utils,
+      ...
+    }:
+    flake-utils.lib.eachDefaultSystem (
+      system:
+      let
+        pkgs = nixpkgs.legacyPackages.${system};
+      in
+      let
+        typstPackagesSrc = "${inputs.typst-packages}/packages";
+
+        typstPackagesCache = pkgs.stdenv.mkDerivation {
+          name = "typst-packages-cache";
+          src = typstPackagesSrc;
+          dontBuild = true;
+          installPhase = ''
+            mkdir -p "$out/typst/packages"
+            cp -LR --reflink=auto --no-preserve=mode -t "$out/typst/packages" "$src"/*
+          '';
+        };
+      in
+      let
+        inherit pkgs;
+        typixLib = typix.lib.${system};
+
+        src = typixLib.cleanTypstSource ./.;
+        commonArgs = {
+          typstSource = "main.typ";
+
+          fontPaths = [
+            # Add paths to fonts here
+            # "${pkgs.roboto}/share/fonts/truetype"
+          ];
+
+          virtualPaths = [
+            # Add paths that must be locally accessible to typst here
+            # {
+            #   dest = "icons";
+            #   src = "${inputs.font-awesome}/svgs/regular";
+            # }
+          ];
+        };
+
+        # Compile a Typst project, *without* copying the result
+        # to the current directory
+        build-drv = typixLib.buildTypstProject (
+          commonArgs
+          // {
+            inherit src;
+            XDG_CACHE_HOME = typstPackagesCache;
+          }
+        );
+
+        # Compile a Typst project, and then copy the result
+        # to the current directory
+        build-script = typixLib.buildTypstProjectLocal (
+          commonArgs
+          // {
+            inherit src;
+            XDG_CACHE_HOME = typstPackagesCache;
+          }
+        );
+
+        # Watch a project and recompile on changes
+        watch-script = typixLib.watchTypstProject commonArgs;
+      in
+      {
+        checks = {
+          inherit build-drv build-script watch-script;
+        };
+
+        packages.default = build-drv;
+
+        apps = rec {
+          default = watch;
+          build = flake-utils.lib.mkApp {
+            drv = build-script;
+          };
+          watch = flake-utils.lib.mkApp {
+            drv = watch-script;
+          };
+        };
+
+        devShells.default = typixLib.devShell {
+          inherit (commonArgs) fontPaths virtualPaths;
+          packages = [
+            # WARNING: Don't run `typst-build` directly, instead use `nix run .#build`
+            # See https://github.com/loqusion/typix/issues/2
+            # build-script
+            watch-script
+            # More packages can be added here, like typstfmt
+            pkgs.typstyle
+          ];
+        };
+      }
+    );
+}

2024/work/phil-1/paper-1-typix/main.typ

@@ -0,0 +1,2 @@
+= Lorem ipsum
+#lorem(30)

2024/work/phil-1/paper-1/main.typ

@@ -0,0 +1,302 @@
+#import "@preview/unequivocal-ams:0.1.1": ams-article, theorem, proof
+#import "@preview/wordometer:0.1.3": word-count, total-words
+
+#import "prelude.typ": indented-argument
+
+#show: ams-article.with(
+  title: [The Argument for Betting on God and the Possibility of Infinite Suffering],
+  bibliography: bibliography("refs.bib"),
+)
+
+#show: word-count.with(exclude: (heading, <wordcount-exclude>, table))
+
+#align(
+  center,
+  table(
+    columns: (auto, auto),
+    [
+      Perm: A2V4847
+    ],
+    [
+      Word Count: #total-words
+      #footnote[
+        Figure computed programmatically during document compilation. Discounts
+        content in tables and the AI contribution statement.
+      ]<wordcount-exclude>
+    ],
+  ),
+)
+
+
+= Introduction
+
+The argument for Betting on God says that you should believe in God, regardless
+of other evidence, purely out of self-interest. In this paper, I challenge this
+argument by assessing the premise that believing in a particular God always
+guarantees the greatest expected utility.
+
+The author's argument for belief in God #cite(supplement: [p. 38],
+<Korman2022-KORLFA>) goes as follows:
+
+#indented-argument(
+  title: "The Argument for Betting on God",
+  abbreviation: "BG",
+  [One should always choose the option with the greatest expected utility.],
+  [Believing in God has a greater expected utility than not believing in God.],
+  [So, you should believe in God.],
+)
+
+BG1 should be uncontroversial. If you expect an action to bring you the most
+utility (i.e. be the most useful), it's rational to do it.
+
+To justify BG2, the author uses a so-called "decision matrix" to compute the
+expected utility of each combination of action and possible outcome. The
+possible actions are placed on the rows, and the possible outcomes are placed
+on the columns, except for the last column, which is the calculated expected
+utility. At each intersection of a row and column, we place the utility we gain
+from that combination of action and outcome. The expected utility for a given
+action is computed by multiplying the utility of each action-outcome pair in
+that row by the probability of the corresponding outcome occurring, and summing
+up all of those values.
+
+Here is the decision matrix the author proposes on #cite(supplement: [p. 38],
+<Korman2022-KORLFA>) which gives the expected utility for believing or not
+believing in God.
+
+#show table.cell.where(x: 0): strong
+#show table.cell.where(y: 0): strong
+
+#figure(
+  caption: [Author's decision matrix],
+  align(
+    center,
+    table(
+      columns: (auto, auto, auto, auto),
+      table.header(
+        [],
+        [God exists ($50%$)],
+        [God doesn't exist ($50%$)],
+        [Expected utility],
+      ),
+
+      [ Believe in God ], [$infinity$], [2], [$infinity$],
+      [
+        Don't believe in God
+      ],
+      [1],
+      [3],
+      [2],
+    ),
+  ),
+)
+
+Note that the numerical utility values themselves have no meaning, and they are
+meant to be viewed relative to each other. Utility doesn't literally provide an
+empirical measure of "usefulness" or "happiness."
+
+We assign the various finite utilities as we see fit, based on how much each
+scenario benefits us. In the case where God does exist, and you believed in
+God, then you are rewarded with an eternal afterlife of bliss and pleasure in
+heaven. This reward is infinitely greater than any possible reward on earth, so
+it has a utility of $infinity$.
+
+So, the expected utility for not believing is $0.5 times 1 + 0.5 times 3 = 2$,
+and the expected utility is $0.5 times infinity + 0.5 times 2 = infinity$. If,
+according to BG1, you should pick the option with greatest expected utility,
+clearly you should choose to believe in God, because the expected utility is
+$infinity$.
+
+The exact utilities don't matter much, since any finite utility you could gain
+for atheism cannot possibly be greater than the infinite expected utility of
+believing in God. Also, as the author points out on #cite(<Korman2022-KORLFA>,
+supplement: [p. 40]), the exact probabilities don't matter either since
+multiplying them by $infinity$ still results in the expected utility of
+$infinity$.
+
+I will show that the Argument for Betting on God fails because BG2 fails. In
+section 2, I argue you cannot determine whether or not believing in God has the
+greatest expected utility because the decision matrix approach fails when
+possible outcomes involving infinitely negative utilities are introduced. In
+section 3, I address a possible response to this objection.
+
+= Possibility of Infinite Suffering
+
+It is possible there are more gods than just the one that sends you to an
+eternal afterlife for believing? The author partially addresses this in
+#cite(<Korman2022-KORLFA>, supplement: [pp. 43-44]), using the example of Zeus.
+Zeus will only reward those who believe in him with an eternal afterlife of
+pleasure. So, if you believe in the wrong god, you don't go to the afterlife.
+The author concludes either believing in Zeus or the Christian God still has
+expected utilities of $infinity$, while being an atheist does has a finite
+expected utility. Therefore, it is still preferable to believe in _some_ god
+that may grant you an eternal afterlife, although no argument is made for
+_which_ god.
+
+However, this leaves out the possibility of gods who punish you for some
+reason. For instance, suppose there exists an _Evil God_ who sends anyone who
+believes in any god to hell for eternity, and does nothing to atheists.
+
+Let us modify our decision matrix to model an outcome where the Evil God
+exists.
+
+#pagebreak()
+
+#[
+  #set figure()
+  #figure(
+    caption: [Possibility of an Evil God],
+    table(
+      columns: (auto, auto, auto, auto, auto),
+      align: center,
+      table.header(
+        [],
+        [Correct god exists ($33.3%$)],
+        [No god exists ($33.3%$)],
+        [Evil God exists ($33.3%$)],
+        [E.U.],
+      ),
+
+      [ Believe in some God ], [$infinity$], [1], [$-infinity$], [$?$],
+      [
+        Don't believe in any God
+      ],
+      [2],
+      [3],
+      [4],
+      [4.5],
+    ),
+  )
+]<other-gods-table>
+
+We've added the new option to our matrix. For the sake of argument, let's say
+each option has an equally likely outcome. Again, the exact probabilities don't
+really matter when we're multiplying them by infinity.
+
+The utilities are mostly the same as before. Not believing in any god and the
+Evil God existing is now the best case for the atheist since they avoided
+infinite suffering. However, the theist now faces the possibility of the worst
+case of all: eternal punishment for believing in the wrong god. If eternal
+bliss in heaven has a utility of $infinity$, then it follows that we should
+represent eternal punishment in hell with a utility of $-infinity$.
+
+There is a problem: how do we calculate the expected utility of believing in
+god? We have $0.333 times infinity + 0.333 times 1 + 0.333 times -infinity$.
+What is $infinity - infinity$? A naive answer might be 0, but infinity is not a
+number in the traditional sense. It makes no sense to add or subtract infinite
+values. For instance, try and subtract the total amount of integers
+($infinity$) from the total amount of real numbers (also $infinity$)
+#footnote[Famously, this infinity is "larger" than the infinite number of
+integers in the sense of cardinality (G. Cantor). But subtracting them still
+makes no mathematical or physical sense.]. Clearly, this notion is meaningless
+and we cannot obtain a solution. So, we consider $infinity - infinity$ an
+_indeterminate form_. So, the expected utility is now _undefined_.
+
+Consider the following Indeterminate Utilities argument:
+
+#indented-argument(
+  title: "The Indeterminate Utilities argument",
+  abbreviation: "IU",
+  [If the expected utility of believing in god is undefined, then we
+    cannot compare the expected utilities of believing in god or not believing
+    in god.],
+  [The expected utility of believing in god is undefined.],
+  [So, we cannot compare the expected utilities of believing in god or
+    not believing in god.
+  ],
+  [If we cannot compare the expected utilities of believing in god or
+    not believing in god, then we cannot determine if believing in god has a
+    higher expected utility than not believing in god.
+  ],
+  [So, we cannot determine if believing in god has a higher expected
+    utility than not believing in god. ],
+)<wordcount-exclude>
+
+We just showed why the premise IU2 is true, and the conclusion IU5 is in direct
+contradiction with BG2. So, if IU5 holds, then BG2 must fail.
+
+It's important to note that the Indeterminate Utilities argument doesn't say
+that the _opposite_ of BG2 is true. It doesn't argue that the expected utility
+of being an atheist is greater. In fact, it doesn't say anything about the
+expected utilities, except that they cannot be compared. If they can't be
+compared, then we can't say for certain which option has the higher expected
+utility. Since BG2 claims that believing in god must have the higher expected
+utility, it is a false premise.
+
+= Addressing Objections
+
+// == Believing in a god is still preferable to atheism
+//
+// One might argue that believing in a god that rewards believers is always
+// preferable to atheism since you at least have the _opportunity_ to receive
+// eternity in heaven. Perhaps there exists a god who punishes non-believers with
+// eternal damnation. Then, even without the exact expected utility calculation,
+// it's clear that the expected utility of believing in some god must be higher
+// than believing in none as you stand to gain more. Either as a theist or
+// atheist, you run the risk of eternal punishment, but you only have the
+// opportunity to go to heaven by believing in some god rather than none.
+//
+// Fair, the possibility that you are punished for believing in the wrong god
+// doesn't imply that you should be an atheist either. Indeed, there may be a god
+// that punishes atheists. However, there could also exist a god who sends
+// everyone to heaven regardless. Or perhaps they only send atheists to heaven.
+// Either way, there is also the possibility of attaining the infinite afterlife
+// in heaven by being an atheist, so it's still impossible to say that the
+// expected utility of believing in god is must be higher.
+
+== The Evil God is not plausible
+
+One might argue that it is not plausible there is an Evil God who punishes all
+theists, including their own believers. Many religions present a god that
+rewards believers and at most punishes disbelievers. None of the major world
+religions propose an Evil God who punishes all believers. It's much more likely
+that a benevolent god exists than an evil one.
+
+I contend that it doesn't matter whether or not the Evil God is less plausible
+than a benevolent god. Surely, if a rational atheist who is unconvinced by all
+the world's scriptures can still concede that there is at least a non-zero
+chance that some god exists, the rational theist should also concede that there
+is a non-zero chance that the Evil God exists. All it takes is that non-zero
+chance, no matter how small, because multiplying it by $-infinity$ still
+results in the undefined expected utility.
+
+== Finite utilities
+
+One might argue that we can avoid using $infinity$ to ensure that all expected
+utility calculations are defined. Instead, suppose that the utility of going to
+heaven is just an immensely large finite number. The utility of going to hell
+is likewise a very negative number. All of our expected utility calculations
+will be defined, and given sufficiently large utilities, we should be able to
+make a similar argument for believing in god.
+
+// The problem with this argument is that we now open our expected utilities up to
+// individual subjective determination. A core feature of the previous argument
+// involving infinite utilities is that they can effectively bypass numerical
+// comparison. If, instead, finite utilities were used, then each person may
+// assign different utilities to each possible outcome based on their own beliefs.
+// Also, the probabilities are no longer irrelevant, so they must be analyzed as
+// well. This greatly complicates the decision matrix.
+
+The problem with this argument is that infinity has a special property the
+argument relies on. Namely, any number multiplied by $infinity$ is still
+$infinity$, so the exact probabilities we set for the existence of God don't
+matter. This is important for defending against the objection the author
+mentions on #cite(<Korman2022-KORLFA>, supplement: [p. 40]), that the
+probabilities are possibly incorrect, since the numbers don't matter anyways.
+
+If, instead, only finite utilities were used, then the theist must contend with
+the concern that the probabilities in the matrix are wrong. There could
+conceivably exist a matrix with probabilities for a benevolent god and an Evil
+God such that the expected utility of atheism is actually higher. The issue is
+we cannot say for sure what the probabilities of the benevolent god and the
+Evil God existing are. If we cannot know what the actual probabilities are,
+then we cannot know the final outcome of our matrix. So, without knowing the
+final outcome of the matrix, we still cannot determine whether or not believing
+in god has greater expected utility, and BG2 still fails.
+
+#pagebreak()
+
+#[
+  = AI Contribution Statement
+
+  #quote[I did not use AI whatsoever in the writing of this paper.]
+]<wordcount-exclude>

2024/work/phil-1/paper-1/package.nix

@@ -0,0 +1,49 @@
+{
+  pkgs,
+  typstPackagesCache,
+  typixLib,
+  ...
+}:
+let
+  src = typixLib.cleanTypstSource ./.;
+  commonArgs = {
+    typstSource = "main.typ";
+
+    fontPaths = [
+      # Add paths to fonts here
+      # "${pkgs.roboto}/share/fonts/truetype"
+    ];
+
+    virtualPaths = [
+      # Add paths that must be locally accessible to typst here
+      # {
+      #   dest = "icons";
+      #   src = "${inputs.font-awesome}/svgs/regular";
+      # }
+    ];
+
+    XDG_CACHE_HOME = typstPackagesCache;
+  };
+
+  # Compile a Typst project, *without* copying the result
+  # to the current directory
+  build-drv = typixLib.buildTypstProject (
+    commonArgs
+    // {
+      inherit src;
+    }
+  );
+
+  # Compile a Typst project, and then copy the result
+  # to the current directory
+  build-script = typixLib.buildTypstProjectLocal (
+    commonArgs
+    // {
+      inherit src;
+    }
+  );
+
+  # Watch a project and recompile on changes
+  watch-script = typixLib.watchTypstProject commonArgs;
+in
+build-drv

2024/work/phil-1/paper-1/prelude.typ

@@ -0,0 +1,21 @@
+#set cite(style: "institute-of-electrical-and-electronics-engineers")
+#set text(fractions: true)
+
+#let indented-argument(title: "", abbreviation: "", ..args) = [
+  #set par(first-line-indent: 0pt)
+
+  #pad(left: 12pt, smallcaps(title))
+
+  #let arg-numbering = (..nums) => nums.pos().map(n => (
+    "(" + abbreviation + str(n) + ")"
+  )).join()
+
+  #enum(
+    numbering: arg-numbering,
+    indent: 16pt,
+    tight: false,
+    ..args.pos(),
+  )
+]
+
+

2024/work/phil-1/paper-1/refs.bib

@@ -0,0 +1,7 @@
+@book{Korman2022-KORLFA,
+	author = {Daniel Z. Korman},
+	editor = {},
+	publisher = {The PhilPapers Foundation},
+	title = {Learning From Arguments: An Introduction to Philosophy},
+	year = {2022}
+}