diff --git a/work/2024/phil-1/paper-1/main.pdf b/2024/documents/by-course/phil-1/paper-1/main.pdf similarity index 100% rename from work/2024/phil-1/paper-1/main.pdf rename to 2024/documents/by-course/phil-1/paper-1/main.pdf diff --git a/work/2024/phil-1/paper-1/main.typ b/2024/documents/by-course/phil-1/paper-1/main.typ similarity index 100% rename from work/2024/phil-1/paper-1/main.typ rename to 2024/documents/by-course/phil-1/paper-1/main.typ diff --git a/2024/documents/by-course/phil-1/paper-1/package.nix b/2024/documents/by-course/phil-1/paper-1/package.nix new file mode 100644 index 0000000..f5cccee --- /dev/null +++ b/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 diff --git a/work/2024/phil-1/paper-1/prelude.typ b/2024/documents/by-course/phil-1/paper-1/prelude.typ similarity index 100% rename from work/2024/phil-1/paper-1/prelude.typ rename to 2024/documents/by-course/phil-1/paper-1/prelude.typ diff --git a/work/2024/phil-1/paper-1/refs.bib b/2024/documents/by-course/phil-1/paper-1/refs.bib similarity index 100% rename from work/2024/phil-1/paper-1/refs.bib rename to 2024/documents/by-course/phil-1/paper-1/refs.bib diff --git a/2024/flake.lock b/2024/flake.lock new file mode 100644 index 0000000..88aaaeb --- /dev/null +++ b/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 +} diff --git a/2024/flake.nix b/2024/flake.nix new file mode 100644 index 0000000..426e999 --- /dev/null +++ b/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 + # ]; + # }; + } + ); +} diff --git a/materials/textbooks/2024-2025/fall/phil-1/Common Writing Mistakes.pdf b/2024/materials/fall/phil-1/Common Writing Mistakes.pdf similarity index 100% rename from materials/textbooks/2024-2025/fall/phil-1/Common Writing Mistakes.pdf rename to 2024/materials/fall/phil-1/Common Writing Mistakes.pdf diff --git a/materials/textbooks/2024-2025/fall/phil-1/Maudlin - Distilling Metaphysics from Quantum Physics (COMPRESSED).pdf b/2024/materials/fall/phil-1/Maudlin - Distilling Metaphysics from Quantum Physics (COMPRESSED).pdf similarity index 100% rename from materials/textbooks/2024-2025/fall/phil-1/Maudlin - Distilling Metaphysics from Quantum Physics (COMPRESSED).pdf rename to 2024/materials/fall/phil-1/Maudlin - Distilling Metaphysics from Quantum Physics (COMPRESSED).pdf diff --git a/materials/textbooks/2024-2025/fall/phil-1/Textbook.pdf b/2024/materials/fall/phil-1/Textbook.pdf similarity index 100% rename from materials/textbooks/2024-2025/fall/phil-1/Textbook.pdf rename to 2024/materials/fall/phil-1/Textbook.pdf diff --git a/flake.nix b/2024/nix/utils/default.nix similarity index 100% rename from flake.nix rename to 2024/nix/utils/default.nix diff --git a/notes/2024/as-am-5/week-1.md b/2024/notes/as-am-5/week-1.md similarity index 100% rename from notes/2024/as-am-5/week-1.md rename to 2024/notes/as-am-5/week-1.md diff --git a/notes/2024/as-am-5/week-2.md b/2024/notes/as-am-5/week-2.md similarity index 100% rename from notes/2024/as-am-5/week-2.md rename to 2024/notes/as-am-5/week-2.md diff --git a/notes/2024/math-4a/week-1/main.pdf b/2024/notes/math-4a/week-1/main.pdf similarity index 100% rename from notes/2024/math-4a/week-1/main.pdf rename to 2024/notes/math-4a/week-1/main.pdf diff --git a/notes/2024/math-4a/week-1/main.typ b/2024/notes/math-4a/week-1/main.typ similarity index 100% rename from notes/2024/math-4a/week-1/main.typ rename to 2024/notes/math-4a/week-1/main.typ diff --git a/notes/2024/math-4a/week-1/refs.bib b/2024/notes/math-4a/week-1/refs.bib similarity index 100% rename from notes/2024/math-4a/week-1/refs.bib rename to 2024/notes/math-4a/week-1/refs.bib diff --git a/notes/2024/math-4a/week-2/main.pdf b/2024/notes/math-4a/week-2/main.pdf similarity index 100% rename from notes/2024/math-4a/week-2/main.pdf rename to 2024/notes/math-4a/week-2/main.pdf diff --git a/notes/2024/math-4a/week-2/main.typ b/2024/notes/math-4a/week-2/main.typ similarity index 100% rename from notes/2024/math-4a/week-2/main.typ rename to 2024/notes/math-4a/week-2/main.typ diff --git a/notes/2024/math-4a/week-2/refs.bib b/2024/notes/math-4a/week-2/refs.bib similarity index 100% rename from notes/2024/math-4a/week-2/refs.bib rename to 2024/notes/math-4a/week-2/refs.bib diff --git a/notes/2024/mes-45/peace-dialogue-notes.md b/2024/notes/mes-45/peace-dialogue-notes.md similarity index 100% rename from notes/2024/mes-45/peace-dialogue-notes.md rename to 2024/notes/mes-45/peace-dialogue-notes.md diff --git a/notes/2024/mes-45/peace-dialogue.typ b/2024/notes/mes-45/peace-dialogue.typ similarity index 100% rename from notes/2024/mes-45/peace-dialogue.typ rename to 2024/notes/mes-45/peace-dialogue.typ diff --git a/notes/2024/mes-45/week-1.md b/2024/notes/mes-45/week-1.md similarity index 100% rename from notes/2024/mes-45/week-1.md rename to 2024/notes/mes-45/week-1.md diff --git a/notes/2024/phil-1/week-1.md b/2024/notes/phil-1/week-1.md similarity index 100% rename from notes/2024/phil-1/week-1.md rename to 2024/notes/phil-1/week-1.md diff --git a/2024/work/phil-1/paper-1-typix/.gitignore b/2024/work/phil-1/paper-1-typix/.gitignore new file mode 100644 index 0000000..fcfc4a1 --- /dev/null +++ b/2024/work/phil-1/paper-1-typix/.gitignore @@ -0,0 +1 @@ +result* diff --git a/2024/work/phil-1/paper-1-typix/flake.lock b/2024/work/phil-1/paper-1-typix/flake.lock new file mode 100644 index 0000000..88aaaeb --- /dev/null +++ b/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 +} diff --git a/2024/work/phil-1/paper-1-typix/flake.nix b/2024/work/phil-1/paper-1-typix/flake.nix new file mode 100644 index 0000000..d4bd532 --- /dev/null +++ b/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 + ]; + }; + } + ); +} diff --git a/2024/work/phil-1/paper-1-typix/main.typ b/2024/work/phil-1/paper-1-typix/main.typ new file mode 100644 index 0000000..9083311 --- /dev/null +++ b/2024/work/phil-1/paper-1-typix/main.typ @@ -0,0 +1,2 @@ += Lorem ipsum +#lorem(30) diff --git a/2024/work/phil-1/paper-1/main.pdf b/2024/work/phil-1/paper-1/main.pdf new file mode 100644 index 0000000..f2d047b Binary files /dev/null and b/2024/work/phil-1/paper-1/main.pdf differ diff --git a/2024/work/phil-1/paper-1/main.typ b/2024/work/phil-1/paper-1/main.typ new file mode 100644 index 0000000..f4832af --- /dev/null +++ b/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, , 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. + ] + ], + ), +) + + += 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], +) 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], +) 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(, +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(, 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], + ), + ) +] + +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. ], +) + +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(, 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.] +] diff --git a/2024/work/phil-1/paper-1/package.nix b/2024/work/phil-1/paper-1/package.nix new file mode 100644 index 0000000..f5cccee --- /dev/null +++ b/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 diff --git a/2024/work/phil-1/paper-1/prelude.typ b/2024/work/phil-1/paper-1/prelude.typ new file mode 100644 index 0000000..226aa28 --- /dev/null +++ b/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(), + ) +] + + diff --git a/2024/work/phil-1/paper-1/refs.bib b/2024/work/phil-1/paper-1/refs.bib new file mode 100644 index 0000000..25f6815 --- /dev/null +++ b/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} +}