# To Do > [!multi-column] > >> [!bug] Overdue >> ```tasks >> not done >> (due before today) >> hide task count >> hide due date >> hide edit button >> short mode >> ``` > >> [!success] Today >> ```tasks >> not done >> (due on today) >> hide task count >> hide due date >> hide edit button >> short mode >> ``` > [!multi-column] > >> [!note] Current Papers >> ```dataview >> LIST WITHOUT ID file.link >> FROM #paper/current >> SORT file.ctime ASC >> ``` # Health Tracking > [!multi-column] > >> [!abstract] Weight Tracker >> ```tracker >> searchType: frontmatter >> searchTarget: weight >> folder: / >> line: >> title: "Weight Over Time" >> yAxisLabel: Weight (kg) >> lineColor: "#69b3a2" >> ``` > >> [!danger] Beer Tracker >> ```tracker >> searchType: frontmatter >> searchTarget: beer500ml >> folder: / >> line: >> title: "Weekly Beer Pattern (500ml bottles)" >> yAxisLabel: "Bottles" >> lineColor: "#ff6b6b" >> ``` >> >> ```tracker >> searchType: frontmatter >> searchTarget: beer500ml >> folder: / >> summary: >> template: "🍺 Weekly Beer Status:\n- Bottles this week: {{sum()}}/8\n- Remaining: {{8 - sum()}}\n- Standard drink equivalent: {{sum() * 1.52}}\n\n📊 Status: {{8 - sum() >= 0 ? '✅ On track!' : '⚠️ Over budget'}}\n\nℹ️ Quick Reference:\n1 bottle = 1.5 drinks\n2 bottles = 3 drinks\n3 bottles = 4.5 drinks (over limit)\n\n🎯 Session Targets:\n- Ideal: 2 bottles (3 drinks)\n- Max: 3 bottles (4.5 drinks)" >> style: "color:var(--text-normal); background-color: var(--background-secondary); padding: 10px; border-radius: 5px;" >> ``` # Notes > [!multi-column] > >> [!summary]- Created Today >> ```dataview >> LIST WITHOUT ID file.link >> FROM "" >> WHERE file.cday = this.file.day AND file.name != this.file.name >> SORT file.ctime ASC >> ``` > >> [!example]- Modified Today >> ```dataview >> LIST WITHOUT ID file.link >> FROM "" >> WHERE file.mday = this.file.day AND file.name != this.file.name AND file.cday != this.file.day >> SORT file.mtime ASC >> ``` > [!multi-column] > >> [!danger]- Created Yesterday >> ```dataview >> LIST WITHOUT ID file.link >> FROM "" >> WHERE file.cday = date(this.file.day-1) AND file.name != this.file.name >> SORT file.ctime ASC >> ``` > >> [!info]- Created Two Days Ago >> ```dataview >> LIST WITHOUT ID file.link >> FROM "" >> WHERE file.cday = date(this.file.day-2) AND file.name != this.file.name >> SORT file.ctime ASC >> ``` > [!multi-column] > >> [!abstract] Recent Thoughts >> ```dataview >> LIST WITHOUT ID file.link >> FROM #thought >> WHERE date(today) - file.cday <= dur(14 days) >> SORT file.ctime DESC >> ``` ## Quick Links > [!multi-column] > >> [!example] Quick Links >> ```dataview >> LIST WITHOUT ID file.link >> FROM #quicklink >> SORT file.cday DESC >> ``` # [[Scratch Pad]] ## Other Plan ### 1. Introducing LLMs for [[Philosophical Understanding]] - Large [[Language Models]] (LLMs) with advanced reasoning capacities can support philosophers in refining or extending their understanding of various issues. - They are [[more than]] tools for brainstorming. - Reasoning model LLMs allow philosophical prompters (specialised users) enhance representation of [[dependency relations]]. --- ### 2. Characterising “[[Philosophical Understanding]]” #### 2.1 The Core of Understanding - **Representation of [[Dependence Relations]]** - In §3.2 of Dellsén et al. (2024), understanding is analysed in terms of accurately capturing the **network of [[dependence relations]]** among phenomena. - To understand some phenomenon XXX involves representing how XXX depends—or does not depend—on other elements, and, conversely, how other elements might depend—or fail to depend—on XXX. - **Accuracy and Comprehensiveness** - One’s understanding is evaluated by the **accuracy** (the extent to which one’s representation of these dependencies is correct) and the **comprehensiveness** (the extent to which the representation captures all relevant dependencies) of the depiction. - For instance, a partial theory of knowledge that correctly identifies some dependencies (e.g. knowledge’s reliance on truth) but misses others (e.g. features suggested by Gettier cases) still counts as an increment of understanding, even if incomplete. - **No Strict Requirement of Justification or Belief** - [[This approach]] holds that, although **knowledge** or **justification** helps sustain reliable philosophical positions, **understanding** itself does not require either full belief or unassailable justification. - One can grasp a theory’s network of dependencies in an accurate manner without personally endorsing every proposition in it. The bar is that a person (or group) be in a position to represent how a phenomenon relates to others. - **Implications for Philosophical Discussion** - Even if philosophers do not converge unanimously on a single ‘correct’ theory, incremental gains in representing specific dependencies—knowing more accurately what knowledge does and does not depend on, for instance—can deepen overall understanding. - Errors can still foster progress if they inspire more refined views, prompting corrections or expansions that bring philosophers and students closer to a more complete picture of how the phenomenon in question operates. --- ### 3. LLMs and Advanced Reasoning Features - Many large models rely on pattern matching, but some reasoning-oriented LLMs use stepwise logic, multi-turn chaining of thought, or iterative revision. - These advanced abilities include: - **Multi-branch search** (e.g. best-of-N sampling), - **Self-consistency** and self-correction, - **Iterative refinement**, - The capacity to compare divergent solutions. - While these features can be prone to “hallucinations,” a discerning prompter can benefit from them to examine multiple competing arguments. --- ### 4. The Coding Analogy vs. Philosophical Prompters - **Coders** can rely on the binary ‘runs/fails’ criterion for rapid feedback. - **Philosophical prompters** must judge whether a position holds conceptually: there is no simple success condition akin to ‘code that compiles’. - Because philosophical truth is factive, [[the question]] is how well arguments align with genuine conceptual dependencies, [[not just]] internal coherence. --- ### 5. Engaging the Reasoning Model for Philosophical Ends - Philosophical prompters can press the LLM to clarify ambiguous steps or propose alternative perspectives. - Although a user might not explicitly mention “[[dependency relations]],” they effectively test them whenever they investigate whether premise XXX truly supports conclusion YYY. - Where the model uses multi-branch search or self-correction, it can approximate the sorts of idealisations and abstractions philosophers allow, provided it does not lose sight of how the phenomena actually connect. --- ### 6. Novices vs. Professional Philosophers - **Novices** may lack the usual methodological guide rails, so they need robust self-evaluation features in the model. - Professional philosophers, with their familiarity with debates and distinctions, can get more sophisticated assistance from LLMs, benefiting from advanced reasoning prompts. --- ### 7. Objections and Replies - **Objection:** “If [[philosophical understanding]] is factive, and LLMs often err, then they offer no reliable help.” - **Reply:** Even mistakes can stimulate reflection. Philosophers can discard flawed claims while retaining insights that refine genuine dependency structures. - **Objection:** “Philosophy is so open-ended that a model cannot replicate its success conditions.” - **Reply:** While there is no ‘compile error’ test, stepwise reasoning (multi-branch expansions, best-of-N sampling, iterative revision) systematically probes alternatives, offering vantage points for deeper scrutiny. - **Objection:** “Non-specialists cannot judge correctness at all.” - **Reply:** If the model makes reasoning explicit (outlining micro-steps, self-corrections), it offers partial structure that even novices can compare, thereby spotting basic contradictions or confusions. - **Objection:** “Philosophical subtleties are too fine-grained for LLMs.” - **Reply:** Iterative refinement allows a model to offer progressively more [[nuanced distinctions]] or expansions, which professionals can evaluate for subtle correctness. - **Objection:** “Models hallucinate or fabricate arguments, thus misleading users.” - **Reply:** A prudent philosophical prompter applies critical examination to each premise. Multi-branch or iterative processes help flag inconsistencies, exposing faulty inferences. --- ### 8. Illustrating the Reasoning Model’s Mechanics - **Multi-branch search**: The LLM proposes a spectrum of potential arguments or solutions for comparison and refinement. - **Sequential/iterative revision**: The LLM revisits earlier premises or conclusions in light of new prompts. - **Self-consistency checks**: The system attempts to unify or choose among competing lines of thought, highlighting contradictions along the way. - **Hierarchical expansions**: Instead of one monolithic answer, the system can break its reasoning into steps, helping philosophers see precisely where a position remains sound (or unsound). --- ### 9. Summation of the Synergy - **LLMs** supply rapid, wide-ranging ideas and can generate alternative possibilities that a single human mind might overlook. - **Philosophers** contribute evaluative discernment, factual demands, and an understanding of delicate conceptual issues. - Jointly, these interactions can bring philosophers closer to the accurate representation of phenomena central to ongoing debates, though final arbitration lies with philosophical judgement and evidence. # Plan ## 1. Introduction - - [_Addition_: **Recall from [[the authors]]’ account in Section 3.2 that philosophical understanding involves accurately and comprehensively representing a phenomenon’s relevant network of dependence relations, in a factive sense. Thus, LLMs might contribute to this understanding if they can assist us in mapping those dependencies or improving accuracy/comprehensiveness of our representations, even if we don’t fully ‘know’ each claim.**] ## 2. Philosophical Understanding - [this section should draw heavily on the ideas in 3.2 of Delsin et. al.] - ### a) Understanding as Representing Networks of Dependence Relations 1. **Dependence Relations as the Core of Understanding** - The authors draw on the idea that to _understand_ a phenomenon XXX is, at root, to grasp how XXX depends on other phenomena, and how other phenomena depend on XXX. - These _dependence relations_ could include causation, grounding, constitution, supervenience, truthmaking, conceptual entailment, and more. The key point is that there really are (in the world) facts about whether and how XXX depends on various other things—and _understanding_ XXX requires correctly representing those facts. 2. **Accuracy and Comprehensiveness** - Understanding is _graded_ rather than all-or-nothing. It comes in degrees. One’s degree of understanding depends on (i) **accuracy**—how _correct_ one’s representation of these dependence relations is, and (ii) **comprehensiveness**—how _broad_ or _complete_ that representation is. - In other words, a person can understand XXX _more or less_, depending on how many genuine dependence relations (and lack of relations) they capture, and whether they omit or misrepresent any crucial connections. 3. **Factivity** - The authors stress that understanding is _factive_ in the sense that an agent’s representation has to match the _actual_ network of dependence relations. If someone’s mental model of how XXX depends on YYY is thoroughly incorrect, then they do not genuinely _understand_—or, at least, their degree of understanding is thereby decreased. - That said, sometimes _idealizations_ and _abstractions_ can be allowed insofar as they genuinely help with capturing a phenomenon at some level of systematic coherence. The authors note that those idealizations or omissions are permissible only so long as the overall representation remains close enough to the real dependence structure. --- ### b) An Epistemically “Undemanding” View of Understanding (No Strict Requirement of Justification or Knowledge) 4. **Not Identical to Knowledge** - Although understanding is factive, the authors hold that it does _not_ require an agent to _know_ particular propositions about XXX in the traditional epistemological sense. In particular, it does not require having _justification_ or _warrant_ that rises to the level of “knowledge” for specific claims. - One can lack knowledge or justification regarding a particular claim about XXX, yet still have a reasonably accurate _overall_ representation of how XXX is embedded in broader dependence networks. 5. **Not Necessarily Belief-Based** - Similarly, the authors do not see understanding as necessarily involving outright _belief_ in each of the claims about XXX. What matters is the agent’s _internal mental representation_: how the agent (perhaps in a more model-like way) “maps” XXX to the phenomena on which XXX depends and the phenomena that depend on XXX. - Thus, on their account, someone might entertain a model or view of the dependencies for the sake of inquiry, without fully endorsing it as “certain.” As long as that representation is _accurate_, they count as having some degree of understanding. 6. **Why This ‘Undemanding’ Epistemology Still Matters** - Crucially, an agent might not be able to _prove_ every piece of the model to the highest standard, yet could still be credited with understanding if their _overall representation_ is largely correct and robust. - This allows for _partial_ or _incremental_ philosophical progress. Even if we cannot show certain claims to be definitively true, we can improve how well we map out the relevant dependencies—which, on the authors’ view, is enough to move understanding forward. --- ### c) The Value of Understanding: Systematicity and Applicability 7. **Systematic Connectedness** - Another important facet is that understanding is _systematic_—it concerns how things “hang together.” When we _accurately_ and _comprehensively_ represent how some philosophical phenomenon connects with related phenomena, we are then better able to: - Explain that phenomenon (by citing the dependence relations). - Predict or anticipate new scenarios (by tracing how changes upstream or downstream in the network would affect XXX). - Manipulate or intervene (by adjusting those things on which XXX depends). 8. **Factive but Not Utopian** - Since understanding is factive, it is anchored to the way things really are (i.e., the phenomenon’s real dependencies). However, the authors emphasize that partial or imperfect models can also yield partial or approximate understanding, as long as the main structure of dependencies is not grievously off-base. - This means that philosophical work can lead to real progress by refining or correcting earlier partial pictures, thereby improving the _accuracy_ and/or _comprehensiveness_ of our representations—even if we don’t arrive at “the one, definitive, final theory.” - quotations from the text to put the view on the table [_Addition_: **We can explicitly invoke the authors’ idea that to understand a phenomenon is to represent how it depends on other phenomena (and vice versa) in a way that is both (i) accurate and (ii) comprehensive. The authors emphasize that this is a ‘factive’ notion: one’s understanding must match the actual dependencies, even if no single proposition is fully justified.**] - - LLMs and Reasoning Models - LLMs training seems to produce some sort of common sense reasoning, but very fragile, unsophisticated and often wrong - The strategies employed by reasoning models are… - The results of this are… [_Addition_: **According to the authors’ ‘undemanding’ epistemology of understanding, an LLM needn’t supply conclusive knowledge or proof to promote understanding. Even partial or approximate outputs—if they help highlight or correct certain dependence relations—could move us closer to more accurate or comprehensive representations.**] - Reasoning Models and Dependency Relations _(put all of the following in terms of dependency relations and factiveness)_ - The Philosophical Prompter - Can differentiate between good philosophy and bad, knows about philosophy - Compare to the pormpter coder - almost all coders at the moment are professionals working with these sorts of systems. - Knows about code, knows the difference between good and bad. - arguably you _can_ get code that works for you by smashing away at an LLM and trial and error. - but, as well as being inelegant, this approach relies on their being a success condition, the code runs or it doesn’t, achieves the goal or it does(?) - no such state is in play (at least not obviously) for philosophical understanding, especially for a non-philosopher. [_Addition_: **From the perspective of the authors’ approach: the measure of success in philosophical understanding is how far we progress in accurate and comprehensive modeling of philosophical dependencies. Unlike coding, where success is tested by executability, philosophical success is tested by whether we actually refine or correct these factive dependence structures in ways that can be publicly shared.**] - A Philosophical Prompter and an LLM - Through discussions with an LLM a philosopher prompter can increase/enhance their philosophical understanding - this can be made sense of in terms of dependency relations. [_Addition_: **Again, as the authors note, because understanding is a matter of representing dependence relations, an LLM’s suggestions might clarify overlooked connections or highlight mistaken assumptions, thereby increasing the thoroughness (comprehensiveness) and truth-likeness (accuracy) of one’s conceptual map.**] - Further, could an untrained philosopher ever be in the position to enhance their philosophical understanding?