Blog | Heye's Blog

Semantic Public Learning

Tue, 12 Aug 2025 00:00:00 +0000

Post 2 of 2 in the Series: Semantic Public Learning Framework series

Evolving the Learn in Public method

In my last post I introduced the Learn in Public method. While practicing it, I noticed gaps in how knowledge creation and sharing works. These gaps revealed an opportunity to evolve the practice into something more powerful. While the core principle of learning openly remains powerful, I have begun developing an approach I call Semantic Public Learning: enhancing Learn in Public with academic rigor and semantic web integration.

Semantic Public Learning builds on Learn in Public’s foundation while adding:

Rigorous citation practices with proper bibliographies
Semantic markup for machine-readable knowledge artifacts
Integration with the knowledge graph through indexable structured data (like schema.org markup for articles)
Academic standards while maintaining accessibility

This isn’t about replacing Learn in Public, it’s about evolving it for deeper integration into our collective knowledge infrastructure. Just as Dan Abramov moved his blog off Medium ¹ to have more control over his content’s permanence and discoverability, we need to ensure our learning artifacts become lasting, findable contributions to the knowledge ecosystem.

The Four Pillars of Semantic Public Learning

To bridge the gap between casual learning documentation and semantic knowledge contribution, we need a systematic approach. Based on my analysis of the research and practice, I’ve identified four interconnected mechanisms through which Semantic Public Learning enhances the Learn in Public approach:

1. Semantically-Enhanced Documentation

Unlike private note-taking, learning in public requires documenting the learning process ² in ways that show thinking progression and can be used for future curriculum planning by both the learner and others. Semantic Public Learning adds structured data and proper markup to ensure machine readability.

2. Citation-Backed Explanation

Following Feynman’s principle, learning in public demands learning by simplifying ³ , breaking concepts into core components while making them accessible. Semantic Public Learning enhances this with proper citations and references, bringing academic credibility to accessible writing.

Learning by teaching effects occur even with non-interactive audiences ⁴ , but boundary conditions include having sufficient prior knowledge and the ability to generate high-quality explanations. Public feedback enables continuous improvement of both understanding and explanation quality.

4. Knowledge Graph Integration

Artifacts produced by learning in public become semantic knowledge networks ⁵ that allow analysis of connections between different disciplines and concepts. Semantic Public Learning ensures these connections are machine-readable and can be properly indexed (using semantic HTML tags like <article>, <cite>, and microdata).

Practicing Semantic Public Learning: Real-World Examples

These examples showcase aspects of an evolved version of learning in public, each demonstrating elements that Semantic Public Learning aims to integrate:

Academic Twitter: Researchers sharing work-in-progress, methodology questions, and “failed” experiments contribute to learning in public by making the typically private research process visible and collaborative ⁶ . Academic Twitter creates informal peer review networks ⁷ where knowledge is rapidly shared and validated, though the ephemeral nature of tweets limits long-term semantic integration.

Citation Style Language (CSL) Project: The CSL project ⁸ exemplifies open source documentation with academic rigor, maintaining over 10,000 citation styles with 1,000+ unique contributors ⁹ . The project creates semantic, machine-readable citation formats and demonstrates transparent version control, extensive documentation, and community-driven development. While excellent for citation infrastructure, it focuses more on tools than documenting learning journeys.

NileRed’s Chemistry Experiments: YouTuber NileRed ¹⁰ documents his chemistry experiments in real-time, showing failed attempts and explaining his reasoning process on his YouTube channel ¹¹ . Originally, Nigel only wanted to keep the documentation for personal reasons but in March 2014 decided ¹² to share his experiments with the world, transforming personal lab notes into public learning resources. His videos reveal the iterative problem-solving that leads to understanding, though they lack formal citations and bibliographies.

Mozilla Developer Network (MDN) Web Docs: The MDN Web Docs ¹³ demonstrate massive collaborative documentation. Each page shows contributors and modification dates, uses semantic HTML, and creates a living knowledge base. However, it rarely includes formal citations to academic sources or bibliographies.

3Blue1Brown’s Mathematical Explanations: Grant Sanderson ¹⁴ transforms abstract mathematical concepts into visual narratives, documenting his journey of understanding while creating resources that help others grasp complex topics through his YouTube videos ¹⁵ . He explains ¹⁶ concepts ranging from linear algebra to neural networks with a highly visual approach, offers his Manim visualization library ¹⁷ as open source, and includes extensive references in video descriptions. From the mentioned examples, this comes closest to Semantic Public Learning, combining accessible explanation with source attribution.

This Post as Semantic Public Learning: This very post demonstrates Semantic Public Learning in action. Notice the inline citations linking to sources, the complete bibliography at the end, and the semantic markup of meta information that makes this content discoverable and citable by others. The citation tools I’m developing as part of this project will enable this integration for Hugo Blox, to aid in creating knowledge artifacts that are both human-readable and machine-discoverable.

What Makes Semantic Public Learning Different

Semantic Public Learning occupies a unique space in the knowledge-sharing ecosystem. Unlike structured curricula that follow predetermined paths, it embraces the learner’s authentic discovery journey while adding layers of discoverability and verifiability. Think of it as sitting between traditional blogging and academic publishing, maintaining higher citation standards than typical blog posts while removing the high entry barriers of academic journals.

You don’t need formal peer review to share your learning journey. Peer review happens organically through reader comments and community engagement. What remains crucial is grounding your insights in evidence and acknowledging sources. That’s why you’ll find proper citations with hyperlinks throughout my posts, along with a complete bibliography at the end, bringing academic rigor to accessible writing.

The key differentiator: Semantic Public Learning creates machine-readable, discoverable, and verifiable knowledge artifacts that can be:

Found by search engines and AI agents
Cited by others with confidence
Built upon systematically
Verified through source tracking

The Broader Impact

When individuals practice Semantic Public Learning, their personal learning journeys become contributions to what researchers call knowledge commoning ¹⁸ , an iterative process between knowledge curation and dissemination guided by community demand and uptake potential.

This creates compounding benefits:

For Learners: Enhanced understanding through public accountability and community feedback
For Communities: Accessible knowledge resources that lower barriers to learning
For Knowledge: Dynamic, interconnected networks that reveal new connections and applications
For the Future: AI-discoverable knowledge that can be integrated into emerging systems

The Semantic Public Learning Movement

We’re at a unique moment. Knowledge-sharing is becoming the preferred method ¹⁹ over traditional learning interventions, with employees increasingly training at their own pace and supporting each other through knowledge-sharing in multiple formats.

Semantic Public Learning harnesses this shift by making individual learning processes visible, valuable, and findable to others. It transforms the traditional model where learning happens in isolation and knowledge remains trapped in individual minds or unsearchable formats.

Instead of asking “What do I need to learn?” Semantic Public Learning asks: “How can my learning process create lasting, discoverable value for others while accelerating my own understanding?”

Your Semantic Public Learning Challenge

Semantic Public Learning isn’t just a concept, it’s a practice to embrace. The most powerful way to grasp its potential is to experience it yourself.

Here’s your challenge: Pick one thing you’re currently learning and document it with semantic rigor to create a lasting, citable resource. It could be:

A complex concept you’re struggling with at work
A skill you’re developing in your free time
A research question you’re investigating
A book or paper you’re working through

Start with these steps:

Choose a specific concept you’re actively learning (not something you already know)
Write a clear explanation as if teaching someone new to the topic
Add proper citations for every source that informed your understanding
Include semantic markup (proper headings, meta descriptions, structured data)
Share your questions and confusion points openly
Publish it publicly on your blog, GitHub, or any platform that supports proper formatting

Share your learning experiment: Use #SemanticPublicLearning or #LearnInPublic when you post about your learning journey so others can discover and learn from your process. Whether on social media, your blog, or any platform where you share knowledge, make your learning visible and findable.

The knowledge you’re about to discover will not just belong to you. It will belong to everyone who might benefit from watching you discover it, now and in the future.

Join the Semantic Public Learning Journey

Speaking of making knowledge tools accessible: I’m using Hugo Blox for managing my blog and have been developing enhanced citation and bibliography features along with semantic integration capabilities. These tools powering the citations you see throughout this post, enable the semantic integration that makes Semantic Public Learning possible. All of these tools together form a framework that I’ll be sharing over the coming weeks. Follow me on LinkedIn, Twitter/X, or Medium to be the first to know and see Semantic Public Learning in action. You can also have a look at the Semantic Public Learning project page, it serves as a living document that tracks the journey as it develops. For best integration, you can also add the RSS feed of my blog, to always stay up to date without the need for a social media account. Comment below, share your perspectives, and help make it the interactive process it’s meant to be. Your questions and insights often become the catalyst for my next learning breakthrough.

Remember: every expert was once a beginner who learned in public. By adding semantic layers to our learning, we ensure that knowledge remains discoverable for future learners. See you in the comments!

References

1. Abramov, D. (2019, 23). Why My New Blog Isn’t on Medium Medium. Retrieved 1, 2025, from https://medium.com/@dan_abramov/why-my-new-blog-isnt-on-medium-3b280282fbae
2. Martirena, C. C. (n.d.). How Teachers Can Use Pedagogical Documentation for Reflection and Planning Edutopia. Retrieved 29, 2025, from https://www.edutopia.org/article/how-teachers-can-use-pedagogical-documentation-reflection-and-planning/
3. Founder, T. H. & TeachThought, D. (2019, 9). What Is The Feynman Technique? TeachThought. Retrieved 29, 2025, from https://www.teachthought.com/learning-posts/how-to-use-the-feynman-technique-learning-by-simplifying/
4. Lachner, A., Hoogerheide, V., Gog, T. & Renkl, A. (2022). Learning-by-Teaching Without Audience Presence or Interaction: When and Why Does it Work? Educational Psychology Review 34 (2), 575-607 https://doi.org/10.1007/s10648-021-09643-4
5. Kiv, A., Soloviev, V., Tarasova, E., Koycheva, T. & Kolesnykova, K. (n.d.). Semantic knowledge networks in education ResearchGate. https://doi.org/10.1051/e3sconf/202016610022
6. Mojarad, S. (2020, 20). A Beginners Guide to Academic Twitter Medium. Retrieved 29, 2025, from https://medium.com/@smojarad/a-beginners-guide-to-academic-twitter-f483dae86597
7. Stewart, B. (2016). Twitter as method: Using twitter as a tool to conduct research ISBN: 978-1-4739-1632-6
8. (n.d.). Citation Style Language Citation Style Language. Retrieved 1, 2025, from https://citationstyles.org/
9. (n.d.). citation-style-language/styles: Official repository for Citation Style Language (CSL) citation styles. Retrieved 1, 2025, from https://github.com/citation-style-language/styles
10. (n.d.). NileRed - Official Website NileRed. Retrieved 29, 2025, from https://nile.red
11. Brawn, N. (n.d.). NileRed YouTube. Retrieved 1, 2025, from https://www.youtube.com/channel/UCFhXFikryT4aFcLkLw2LBLA
12. Rajapaksha, M. (2023, 24). Who Is Behind NileRed? | The Untold Story of the TikTok Chemist Taking the Internet by Storm. Starsbiopedia.com. Retrieved 1, 2025, from https://starsbiopedia.com/nilered-nigel-braun-age-biography/
13. (n.d.). MDN Web Docs GitHub. Retrieved 1, 2025, from https://github.com/mdn
14. (n.d.). 3Blue1Brown Retrieved 29, 2025, from https://www.3blue1brown.com/3blue1brown.com
15. (n.d.). 3Blue1Brown YouTube. Retrieved 1, 2025, from https://www.youtube.com/channel/UCYO_jab_esuFRV4b17AJtAw
16. Wei, P. (2020, 24). 3Blue1Brown creator Grant Sanderson ’15 talks engaging with math using stories and visuals Retrieved 1, 2025, from https://stanforddaily.com/2020/01/24/3blue1brown-creator-grant-sanderson-15-talks-engaging-with-math-using-stories-and-visuals/
17. Sanderson, G. (2025). 3b1b/manim https://github.com/3b1b/manim
18. Qureshi, I., Bhatt, B., Parthiban, R., Sun, R., Shukla, D. M., Hota, P. K. & Xu, Z. (2022). Knowledge Commoning: Scaffolding and Technoficing to Overcome Challenges of Knowledge Curation Information and Organization 32 (2), 100410 https://doi.org/10.1016/j.infoandorg.2022.100410
19. Spiro, K. & Bhamidi, V. (2021, 16). Open learning and knowledge sharing in a remote working world Chief Learning Officer. Retrieved 29, 2025, from https://www.chieflearningofficer.com/2021/08/16/open-learning-and-knowledge-sharing-in-a-remote-working-world/

Learn in Public

Tue, 05 Aug 2025 00:00:00 +0000

From Individual Discovery to Collective Intelligence

Post 1 of 2 in the Series: Semantic Public Learning Framework series

View All →

Picture this: You’re struggling to understand how human memory works. Mid-explanation to a friend, you say: “… kind of like when we tried to piece together that party from last year: you remembered the music, I remembered the cake, Sarah remembered who was there. None of us had the full memory, but together it all came back…” Then it hits you. That might just be how the brain remembers, not stored in a single location, but distributed across a vast neural network. You just understood in 30 seconds what hours of reading couldn’t clarify.

Now, why does explaining in the open unlock insights that studying alone never could? The answer reveals something remarkable about how knowledge is built.

The Teaching Paradox

Nobel Prize-winning physicist Richard Feynman believed that true understanding meant being able to explain complex ideas simply. His colleague David Goodstein recounted how Feynman once said about explaining a complex physics concept: “I couldn’t reduce it to the freshman level. That means we really don’t understand it" ¹ . This philosophy, that if you can’t explain something simply, you don’t truly understand it, became the foundation for what we now call the “Feynman Technique.” However, the systematic four-step technique commonly attributed to him appears to be a modern construction based on his general approach ² rather than something he explicitly formulated.

The technique involves: choose a concept, explain it as if teaching a sixth-grader, identify knowledge gaps, and simplify further. While this method is sound, I propose adding one crucial step that amplifies its benefits for everyone: document your learning journey and share it publicly.

Traditional learning: You’re learning how LLMs choose the next token. You write an explanation on paper, pretending to teach it to an imaginary sixth-grader: “The AI looks at all possible words and picks the most likely one based on what it learned during training.” You realize you don’t understand the probability calculation, study more, and refine your explanation. The learning remains private.

Learning in public: You follow the same process but document and publish that explanation on your blog, explicitly noting your confusion about the probability calculation. Now the magic happens: a machine learning engineer comments with a clearer explanation, someone shares a helpful visualization, and a student asks a question that reveals another gap. Your learning becomes collaborative.

The difference? When you teach to an imaginary audience, learning stops with you. When you learn publicly, knowledge spreads and grows within learning communities ³ , transforming individual understanding into collective intelligence.

Discovering Learn in Public

As I developed this concept while writing this post, I initially called it “public learning.” But in the spirit of the practice itself (openly documenting my learning journey), I discovered I wasn’t the first to explore this territory. Shawn Wang (swyx) ⁴ had already articulated a framework called Learn in Public ⁵ that captured much of what I was describing. This discovery exemplifies the principle I’m exploring: by working through ideas openly, I found existing wisdom that sharpened my understanding. I’ve adopted the term Learn in Public, building on this foundation while adding my perspective and contributions. I’ll use the more natural phrase learning in public when it fits better in context, but both refer to the same core idea.

Learn in Public is the practice of deliberately documenting and sharing your learning process in real-time, creating openly accessible knowledge artifacts that benefit both your understanding and the broader learning community.

The Research Foundation

Learning in public’s effectiveness is backed by converging research findings that explain why this approach transforms individual learning into collective intelligence.

The foundation starts with the act of teaching itself. Research shows that both preparing for and actually teaching academic content significantly enhance learning outcomes ⁶ . When you prepare to teach material publicly, you engage in more sophisticated cognitive processing than private study requires. The more complex the teaching activity, the more opportunities to learn by teaching ⁷ , and public documentation is inherently complex, requiring you to anticipate questions, structure information clearly, and fill knowledge gaps you might otherwise ignore.

This enhanced processing leads directly to improved retention. Weinstein et al. showed ⁸ that bringing information to mind directly improves memory for that information, and public documentation forces continuous retrieval and reorganization of knowledge. Unlike traditional teaching in a classroom, learning in public makes this process transparently visible and persistently accessible, creating artifacts that serve as both personal reference and community resource.

But the real magic happens at the community level. Learning in public transforms individual study into systematic knowledge documentation where learners acquire life skills along with subject matter ⁹ while creating resources others can build upon. Knowledge sharing contributes to success ¹⁰ through positive impacts on creativity, learning, and performance. The public dimension creates what educational research terms learning communities ³ where participants experience higher retention rates, with belonging and support contributing to increased persistence and success.

Perhaps most importantly for our digital age, documenting learning creates knowledge graphs that significantly promote collaborative knowledge building, group performance, and social interaction ¹¹ . Each concept you explain becomes what researchers call a semantic node ¹² in a broader knowledge network. These artifacts must be machine-readable to maximize impact, just as search engines need to understand your content to rank it effectively, your learning artifacts need proper structure, clear terminology, and semantic markup (like a Wikipedia page the internet links to). This makes them discoverable by indexers so both humans and AI agents can find them. This is commonly known as search engine optimization (SEO), but it’s more than that: by properly linking and annotating your writing, you ensure your knowledge contributions integrate into the expanding web of human understanding.

When you learn in public, you’re improving your own understanding while participating in the collaborative construction of knowledge itself.

Semantic Public Learning

While Learn in Public provides the foundation, I’ll show you in my next post in this series how we can enhance it further with what I call Semantic Public Learning by adding academic rigor and machine-readability to maximize both personal learning and collective knowledge building.

Follow me on LinkedIn, Twitter/X, or Medium to be the first to know and see Semantic Public Learning in action. You can also have a look at the Semantic Public Learning project page, it serves as a living document that tracks the journey as it develops. For easy integration, you can also add the RSS feed of that page, or the RSS feed of my blog, to always stay up to date without the need for a social media account. Comment below, share your perspectives, and help make it the interactive process it’s meant to be. Your questions and insights often become the catalyst for my next learning breakthrough.

Remember: every expert was once a beginner who learned in public.

See you in the comments!

References

1. Goodstein, D. L. (1989). Richard P. Feynman, Teacher Physics Today 42 (2), 70-75 https://doi.org/10.1063/1.881195
2. Gleick, J. (1993). Genius: the life and science of Richard Feynman Vintage Books ISBN: 978-0-679-74704-8
3. Zamiri, M. & Esmaeili, A. (2024). Methods and Technologies for Supporting Knowledge Sharing within Learning Communities: A Systematic Literature Review Administrative Sciences 14 (1), 17 https://doi.org/10.3390/admsci14010017
4. (n.d.). swyx.io/about Retrieved 29, 2025, from https://www.swyx.io/about
5. (n.d.). Learn In Public Retrieved 29, 2025, from https://www.swyx.io/learn-in-public
6. Fiorella, L. & Mayer, R. E. (2013). The relative benefits of learning by teaching and teaching expectancy Contemporary Educational Psychology 38 (4), 281-288 https://doi.org/10.1016/j.cedpsych.2013.06.001
7. Duran, D. (2017). Learning-by-teaching. Evidence and implications as a pedagogical mechanism Innovations in Education and Teaching International 54 (5), 476-484 https://doi.org/10.1080/14703297.2016.1156011
8. Weinstein, Y., Madan, C. R. & Sumeracki, M. A. (2018). Teaching the science of learning Cognitive Research: Principles and Implications 3 (1), 2 https://doi.org/10.1186/s41235-017-0087-y
9. Burow, O. & Bornemann, S. (Eds.) (2018). Das große Handbuch Unterricht & Erziehung in der Schule Carl Link ISBN: 978-3-556-07336-0
10. Fan, Z. & Beh, L. (2024). Knowledge sharing among academics in higher education: A systematic literature review and future agenda Educational Research Review 42 , 100573 https://doi.org/10.1016/j.edurev.2023.100573
11. Zheng, L., Niu, J., Long, M. & Fan, Y. (2023). An automatic knowledge graph construction approach to promoting collaborative knowledge building, group performance, social interaction and socially shared regulation in CSCL British Journal of Educational Technology 54 (3), 686-711 https://doi.org/10.1111/bjet.13283
12. (n.d.). Semantic network Wikipedia. https://en.wikipedia.org/w/index.php?title=Semantic_network&oldid=1299856638 Retrieved 29, 2025, from https://en.wikipedia.org/w/index.php?title=Semantic_network&oldid=1299856638

Understanding Superposition in Neural Networks: A Guide Through Analogies

Tue, 08 Jul 2025 00:00:00 +0000

One of the most fascinating and challenging concepts in mechanistic interpretability is superposition, the way neural networks cleverly pack multiple features into the same computational space. If you’re coming from a background in knowledge representation or semantic systems, superposition can seem quite alien at first. But with the right analogies, it becomes understandable and genuinely elegant.

What is Superposition?

In traditional knowledge systems like the semantic web, concepts are typically stored in dedicated, clearly labeled locations. You might have distinct slots for “Person,” “hasAge,” and “livesIn” - each with its own well-defined space in your ontology.

Neural networks face a different challenge entirely. They need to represent potentially millions of concepts, but they have limited “storage space” in the form of neurons and dimensions. Superposition is their solution: multiple distinct features are encoded in the same set of neurons, rather than each feature having its own dedicated slot.

Think of it like having a library where you need to store a million books, but you only have shelf space for a thousand. Superposition would be like discovering a clever way to store multiple books in the same physical space, perhaps by layering them in a way that you can still retrieve individual books when needed.

The Compression Analogy

Superposition is fundamentally a form of learned compression. But unlike traditional compression algorithms like ZIP or JPEG, where you have explicit rules for packing and unpacking data, superposition is a compression scheme that the neural network discovers on its own.

Imagine you’re trying to compress a massive dataset, but instead of using a pre-designed algorithm, you let the system figure out its own compression method through trial and error. The network learns to pack features together in a way that preserves the information it needs while fitting within its constraints.

The tricky part? There’s no clean “decompression algorithm.” When multiple features are superimposed in the same neurons, the separation of them becomes a complex inference problem. It’s like having a brilliantly space-efficient storage system, but now you need to figure out how to extract individual items without clear labels.

The River Delta: Information Flow

Perhaps the most intuitive way to understand superposition is through the metaphor of a river delta with controllable dams.

In this analogy:

Water flow represents information/activation flowing through the network
Controllable dams represent the weights and biases that can be adjusted
Different streams represent different features or concepts
The destination represents the final output (like predicting the next token)

When you present a neural network with an image of a cat, multiple “streams” of information flow simultaneously: visual texture features, shape features, color features, and higher-level concept features. These streams don’t take separate paths, they flow through the same “channels” (neurons) in the network.

The magic happens in how the network learns to adjust its “dam settings” (weights) so that when you need the “cat” concept, the right combination of streams naturally flows to produce that output. Multiple features share the same waterways, but the flow patterns are orchestrated so that the right information reaches the right destinations.

The Electrical Circuit Perspective

For those with electrical engineering backgrounds, superposition works remarkably like voltage and current in complex circuits.

Neural network activations are like voltages at different points in the circuit. Weights control the “resistance” of connections, determining how much signal passes through. Information flows through weighted connections like current through resistors. Using this analogy you can measure the “voltage” (activation level) at any point in the network just as you might use a multimeter to measure voltage at different points in a circuit. Now researchers basically use “virtual meters” to measure activation levels throughout the network. They can trace how changing the “voltage” at one point affects the final output, essentially measuring the signal flow from input to output.

This electrical perspective helps explain why mechanistic interpretability is so challenging: you’re trying to reverse-engineer a circuit with billions of components, where multiple signals are running through the same wires simultaneously.

Why Superposition Matters

Understanding superposition is crucial because it explains why neural networks are so hard to interpret. In traditional symbolic systems, if you want to know whether the system understands “cats,” you might look for a dedicated “cat” module. In neural networks with superposition, the “cat” concept might be distributed across thousands of neurons, mixed in with concepts for “furry textures,” “pointed ears,” and “domestic animals.”

This is not a bug, it’s a feature! Superposition allows neural networks to be incredibly parameter-efficient, representing far more concepts than they have neurons. But it also means that understanding what these networks have learned requires sophisticated mathematical tools to disentangle the superimposed features.

The Path Forward

The beauty of superposition is that it represents a fundamentally different approach to information storage and processing. Instead of the explicit, structured representations we’re used to in traditional AI systems, neural networks discover their own compression schemes that are often more efficient than anything we could design by hand.

For researchers in mechanistic interpretability, superposition presents both the central challenge and the key to understanding these systems. By developing tools to decompose superimposed features, like sparse auto-encoders and other mathematical techniques, we’re slowly learning to read the compressed language that neural networks speak.

The next time you interact with a language model or image classifier, remember that behind its responses lies an intricate dance of superimposed features, flowing through shared computational channels in patterns too complex for us to fully grasp - yet. The quest to understand these patterns is what makes mechanistic interpretability one of the most fascinating frontiers in AI research.

References and Further Reading

The concepts explored in this article are grounded in cutting-edge research in mechanistic interpretability. Here are the key sources that support and extend these ideas:

Core Theoretical Foundations

Elhage, N., et al. (2022). Toy Models of Superposition. arXiv:2209.10652. [Paper]
The foundational work that introduces minimal settings where polysemanticity arises from storing sparse features in superposition. This paper provides the theoretical backbone for understanding the compression analogy discussed above.

Hänni, S., et al. (2024). Mathematical Models of Computation in Superposition. arXiv:2408.05451. [Paper]
Formalizes how neural networks can compute Boolean circuits in superposition using sub-linear neuron counts, providing mathematical rigor to the “river delta” information flow concepts.

Sparse Coding and Decomposition Techniques

(2025). From Superposition to Sparse Codes: Interpretable Representations in Neural Networks. arXiv:2503.01824. [Paper]
Recent work explaining how evidence for linear overlay of concepts motivates extraction of monosemantic features via sparse autoencoders — the natural next step after understanding superposition.

Olshausen, B. A., & Field, D. J. (1996). Emergence of simple‐cell receptive field properties by learning a sparse code for natural images. Nature, 381, 607–609. [Paper]
The classic neuroscience foundation for sparse coding, showing that superposition isn’t unique to artificial neural networks but appears in biological vision systems.

Interpretability Methods and Visualizations

Olah, C., et al. (2018). The Building Blocks of Interpretability. Distill. [Paper]
Combines feature visualization, attribution, and dimensionality reduction to explore how individual neurons encode multiple features — the “virtual meter” approach to measuring neural activations.

Olah, C., Mordvintsev, A., & Schubert, L. (2017). Feature Visualization. Distill. [Paper]
Details techniques for reverse-engineering neuron-specific activation patterns, essential tools for detecting and understanding superimposed features.

Olah, C., et al. (2020). Zoom In: An Introduction to Circuits. Distill. [Paper]
Introduces the “circuit” metaphor for interpreting subgraphs of neurons and weights, which becomes particularly complex under superposition.

Advanced Topics and Current Research

Adler, M., & Shavit, N. (2024). On the Complexity of Neural Computation in Superposition. arXiv:2409.15318. [Paper]
Presents theoretical bounds for computing logical operations in superposition, highlighting the computational advantages of this representational strategy.

Chang, E., et al. (2025). SAFR: Neuron Redistribution for Interpretability. arXiv:2501.16374. [Paper]
Proposes methods to encourage monosemantic allocations in transformers, directly addressing the challenges posed by feature superposition.

Broader Context

Murdoch, W. J., et al. (2019). Interpretable Machine Learning: Definitions, Methods, and Applications. arXiv:1901.04592. [Paper]
Provides taxonomies of interpretability methods that frame superposition-focused techniques within the broader landscape of explainable AI.

This post represents one perspective on superposition in neural networks, built through collaborative exploration of analogies and concepts. The field of mechanistic interpretability is rapidly evolving, and our understanding of these phenomena continues to deepen.

ChatGDT — Chatting with Graph-based Digital Twins

Thu, 13 Mar 2025 00:00:00 +0000

Part 1: The Challenge of Natural Language Interfaces for Knowledge Graphs

This post was originally written in June 2023, and the research for this project started in the beginning of 2023, when GPT-3.5-turbo was state-of-the-art. While technology has evolved significantly since then, the core insights and methodologies remain valuable.

Introduction

Let’s say you have a question and a database that contains all the information you need to answer it, but no idea how to query it.

Since 2020, I’ve been working as a data engineer in the construction industry, modeling a digital twin using a knowledge graph expressed in RDF facts. A digital twin is a comprehensive digital representation of physical entities, capturing various aspects of their structure, systems, and behavior. It can act as a central database of information that can be queried using SPARQL.

In order to make a graph-based digital twin available to external parties I went on a journey to find a translator that can take natural language queries as input, search the graph, and convert the results back into natural language.

What You’ll Learn From This Series

By reading this series, you’ll discover:

The practical challenges of connecting knowledge graphs with LLMs and how to approach them
Why simpler prompting strategies sometimes outperform complex ones (a counterintuitive finding that challenged my assumptions)
How to systematically test and evaluate different prompting techniques
Techniques for iteratively exploring knowledge graphs using LLMs
Insights about how LLMs reason with structured information
How more recent advances like constrained decoding might improve these approaches

Whether you’re working with knowledge graphs, building interfaces for complex systems, or just curious about practical LLM applications beyond standard chatbots, this series offers both technical details and real-world lessons from my journey of trial and error.

Technical Foundation

Before diving into my experiments, it’s helpful to understand the basic building blocks of what we’re working with. This section covers the key concepts and tools that form the foundation of this exploration.

Knowledge Graphs and RDF

Knowledge graphs represent information as interconnected entities and relationships. They model the world as a network of facts, expressing each fact as a triple: subject, predicate, and object. This structure is intrinsically more machine-readable than natural language while preserving semantic meaning.

The Resource Description Framework (RDF) provides a standard model for expressing these facts. In RDF, each component of a triple can be:

A URI (Uniform Resource Identifier) representing an entity or relationship
A literal value (like a string or number)
A blank node (representing an unnamed resource, though I deliberately avoided these in my examples)

For example, a simple fact like “Alice knows Bob” would be expressed as:

ex:alice foaf:knows ex:bob .

Where ex: and foaf: are namespace prefixes that expand to full URIs.

FOAF Ontology

For my experiments, I used the Friend of a Friend (FOAF) ontology, which is a simple vocabulary for describing people and their relationships. FOAF includes terms like:

foaf:Person - A class representing a person
foaf:name - A property for a person’s name
foaf:knows - A relationship between two people
foaf:age - A property for a person’s age

I extended this with some additional relationship types (using the rel: prefix) to create more complex scenarios:

rel:siblingOf - A relationship between siblings
rel:childOf - A relationship between a child and parent
rel:employedBy - A relationship between an employee and employer
rel:employerOf - Inverse ofrel:employedBy

SPARQL

SPARQL (pronounced “sparkle”) is the query language for RDF graphs. It allows you to search for patterns in the graph and retrieve matching data. A basic SPARQL query looks like:

PREFIX foaf: <http://xmlns.com/foaf/0.1/>
PREFIX ex: <https://example.com/people#>

SELECT ?name WHERE {
 ex:alice foaf:knows ?person .
 ?person foaf:name ?name .
}

This query would return the names of all people that Alice knows.

Large Language Models and Their Capabilities

When ChatGPT was released in late 2022, I realized that large language models (LLMs) were becoming accessible tools for anyone, even non-experts, because they understand natural language. Better yet, these models can work with multiple languages and translate between them by comprehending the meaning of entire sentences and paragraphs. And importantly, “language” here isn’t limited to human languages but includes artificial ones like programming and query languages.

The LLM I used for most of my experiments was GPT-3.5-turbo (the model powering ChatGPT at the time of writing the original post in July 2023). These models have several capabilities that make them potentially useful for knowledge graph interaction:

Natural language understanding: They can parse and comprehend human questions, even when ambiguous.
Code generation: They can generate structured code, including SPARQL queries.
In-context learning: They can adapt to new information provided in the prompt without additional training.
Reasoning: They can follow chains of relationships to draw conclusions from facts.

However, they also have limitations:

Context window: They have a limited context window (4,000 tokens for GPT-3.5-turbo at that time), which restricts how much of the knowledge graph can be provided at once.
Hallucinations: When uncertain, they can generate plausible but incorrect information, which is particularly problematic when generating structured queries.
Consistency: When choosing a temperature above 0, their performance can vary between runs, even with identical prompts.

Note: As of 2025, newer models have significantly larger context windows and gained the ability to do explicit reasoning. However, the core challenge of hallucinations persists, particularly for knowledge-intensive tasks.

Test Dataset

I created a small knowledge graph for testing with fictional people and their relationships. The graph was intentionally designed to test different inference capabilities:

ex:person1 rdf:type foaf:Person .
ex:person1 foaf:name "Alice" .
ex:person1 foaf:age 30 .
ex:person1 foaf:gender "female" .
ex:person1 rel:siblingOf ex:person2 .
ex:person1 rel:siblingOf ex:person3 .

ex:person2 rdf:type foaf:Person .
ex:person2 foaf:name "Bob" .
ex:person2 foaf:age 35 .
ex:person2 foaf:gender "male" .
ex:person2 rel:siblingOf ex:person1 .
ex:person2 rel:siblingOf ex:person3 .

ex:person3 rdf:type foaf:Person .
ex:person3 foaf:name "Eve" .
ex:person3 foaf:age 28 .
ex:person3 foaf:gender "female" .
ex:person3 rel:siblingOf ex:person1 .
ex:person3 rel:siblingOf ex:person2 .

# ...

Note: I deliberately used generic identifiers (ex:person1, ex:person2) in my test dataset rather than identifiers that include names (ex:alice, ex:bob). This was intentionally done to prevent the LLM from making assumptions based on the entity IDs. In some early experiments, I found that when using name-based identifiers, the model would sometimes correctly answer questions by pattern matching on the identifiers rather than properly traversing the relationships in the graph. Using generic identifiers ensured that the model could not cheat but had to actually understand and follow the relationships expressed in the triples.

This graph includes direct relationships (like Alice being a child of Person4) and implicit relationships that require inference (like determining that Person2 is Alice’s brother because they share a parent).

By designing questions that required traversing multiple relationships (like “Who is the mother of the person that the colleague of Alice’s brother lives with?”), I could test the limits of LLM-based querying approaches.

LLM Integration Tools

Two main tools were used in these experiments:

LlamaIndex: A data framework for connecting custom data sources to LLMs, which includes vector store capabilities for retrieval.
LangChain: A framework for creating LLM-powered applications, which includes tools for prompting, agents, and custom tool creation.

These tools provide different approaches to the same fundamental challenge: how to effectively connect structured data with the natural language capabilities of LLMs.

Initial Approaches

My journey to connect LLMs with knowledge graphs wasn’t straightforward. I explored several approaches before finding something that actually worked. Let me walk you through what I tried, where I failed, and what I learned along the way.

Using LlamaIndex

My colleague Maqbool showed me a small prototype he had built over the weekend using LlamaIndex that could report knowledge in certain cases when the information was presented in a very simple format.

His prototype followed a simple yet effective approach: import the RDF graph into LlamaIndex’s VectorStore and query it with unprocessed user questions. The vector store would retrieve relevant triples based on embedding similarity and send these as context to the LLM, which would then generate an answer based on this limited view on the graph.

Results and Analysis

This approach worked surprisingly well for small graphs and simple questions like “What is the age difference between Alice and Bob?” The LLM could use in-context learning to reason over the facts provided. For example, with these RDF triples:

ex:person1 rdf:type foaf:Person .
ex:person1 foaf:name "Alice" .
ex:person1 foaf:age 30 .
ex:person1 foaf:gender "female" .
ex:person1 rel:siblingOf ex:person2 .

ex:person2 rdf:type foaf:Person .
ex:person2 foaf:name "Bob" .
ex:person2 foaf:age 35 .
ex:person2 foaf:gender "male" .
ex:person2 rel:siblingOf ex:person1 .

The model could understand the entities and correctly answer: “The age difference between Alice and Bob is 5 years. Alice is 30, Bob is 35 years old.”

As long as the entire graph fits within the prompt, the model can answer simple questions correctly. However, larger graphs wouldn’t fit within the 4,000 token context window of GPT-3.

To give some perspective, this very short description of Alice already used 58 tokens that are competing for space with further instructions and reasoning. A graph of 60 people would barely fit into a 4,000 token context window, leaving almost no room for the actual inference.

The solution of storing the facts in a VectorStore and only retrieving the relevant facts to overcome this limitation is a first step, but retrieval based on a simple query imposes the risk of missing the relevant facts. Let me give you an example:

Let’s say we have a graph with facts of a million people, and Alice and Bob are not located close together but far apart:

ex:person1 rdf:type foaf:Person .
ex:person1 foaf:name "Alice" .
ex:person1 foaf:age 30 .
ex:person1 foaf:gender "female" .
ex:person1 rel:siblingOf ex:person546398 .

# ... ex:person2 to ex:person546397

ex:person546398 rdf:type foaf:Person .
ex:person546398 foaf:name "Bob" .
ex:person546398 foaf:age 35 .
ex:person546398 foaf:gender "male" .
ex:person546398 rel:siblingOf ex:person1 .

# ... ex:person546400 to ex:person1000000

When querying the VectorStore with slightly more complex questions, such as “What is the age difference between Alice and her brother?”, the vector search might retrieve the fact ex:person1 foaf:name "Alice" . because the name “Alice” is directly mentioned in the query. Depending on the embedding model, it might even return some relationships of the form ex:personX rel:siblingOf ex:personY . , since the word “brother” in the query hints at siblings being relevant. Though it is questionable if facts like ex:personX foaf:gender "male" . would be picked up just because the word “brother” refers to male individuals. Therefore, with a million people in the graph, it is almost certain that no facts about the specific individual ex:person546398 (Bob) would be retrieved, as vector search is not capable enough to determine that “Bob” is the particular sibling we’re looking for. For this, we need to do some form of reasoning as part of the retrieval process.

The model would admit insufficient information at best when given an insufficient subset of facts. However, due to the aforementioned problem of hallucinations, it might confidently produce an answer like “The age difference between Alice and her brother is 3 years” without any factual basis.

Key Insight

I learned something important: the model could perform complex inference if all the necessary knowledge was available. Determining that Alice was Bob’s sibling and that Bob, being male, was Alice’s brother might seem trivial to humans, but it represented genuine logical reasoning for the model.

Finding Alice’s brother is intuitive for a human looking at a graph: we start with Alice and follow the most promising relationships. But programming this flexibility is challenging. What if the relationship was labeled ex:hasBrother instead of rel:siblingOf? What if siblings weren’t directly connected but shared common parents? The complexity grows quickly.

Learnings

I realized I needed to retrieve a small but complete subgraph containing all facts relevant to answering a question. As long as this subgraph fits into the context window, the LLM could reason over it effectively. Unfortunately, as described before, a simple VectorStore using embeddings wasn’t sophisticated enough to retrieve the right subgraph for slightly advanced queries.

Using LangChain

My next attempt involved LangChain, which offers prompting chains, agents, and custom tools. I created a sparql_query tool that accepted valid SPARQL queries as input and returned results as observations for the model.

While this sounded promising, LangChain’s prompts were quite verbose, and the parsing of responses was inconsistent. I spent too much time trying to inject additional instructions into LangChain prompts, eventually deciding it would be easier to craft my own from scratch:

=== PROMPT ===
### Situation
You are a knowledge graph expert. Your high-level objective is to answer the following question given by a non-expert user: "Who is Alice's brother?"

### Tools
split_question: You can split the question into a list of subquestions. Arguments:
- [<list of subquestions>]
vector_store: You have access to a vector store, which you can query with natural language questions to gain some insights that help you understand the structure of relevant parts of the graph. Arguments:
- <natural language question>
sparql_query: You can query the graph by writing lines of SPARQL that will be inserted into a template. Arguments:
- `<SPARQL query>`

### Task
You have to decide what to do next.=

### Knowledge

=== RESPONSE FORMAT ===
### Thoughts
<your thoughts about the current state of knowledge and progress in the strategy>

### Progress
<Estimate progress in percent>%. <Message with how you would formulate the final answer with your findings so far; add as much concrete information as possible>

### Next Step
<Which tool would you use next and why?>

### Tool Selection
<split_question|vector_store|sparql_query> <arguments>

### Final Remarks
<Anything else you want to say to the user>
=== END ===

This approach was better, especially since I could easily modify the prompt. I was expecting the model to write queries like:

SELECT ?age_alice ?age_brother WHERE {
 ?alice rdf:type foaf:Person ;
 foaf:name "Alice" ;
 foaf:age ?age_alice ;
 rel:siblingOf ?brother .

 ?brother rdf:type foaf:Person ;
 foaf:age ?age_brother ;
 foaf:gender "male" ;
 rel:siblingOf ?alice .
}

Maybe even add an additional line to calculate the age difference, like BIND( ?age_diff = ?age_alice - ?age_brother ). And sometimes it actually did, or nearly did. If you have ever tried to execute code written by an LLM, you have probably experienced that it’s often not working on the first try. Unfortunately, an empty response will be returned if the query is syntactically correct but semantically wrong. Therefore, the model can’t differentiate if it made a mistake or the information it was querying for does not exist in the graph. Consequently, it will simply assume that the graph does not contain the information required to answer the question. And it happens too often that the model simply tries to use a predicate that doesn’t exist, such as rel:sibling (as opposed to rel:siblingOf). While it is clear what the intention is for an expert user, a non-expert will likely not be able to guide the model in the right direction to fix the SPARQL query.

UPDATE (2025): Newer approaches using constrained decoding could potentially solve the specific issue of using, e.g., predicates that don’t exist. This technique restricts the model to generating SPARQL queries using predicates that actually exist in the ontology. By filtering the model’s output to only allow valid predicates like rel:siblingOf and preventing invalid ones like rel:sibling, we could guarantee syntactically valid queries against our specific knowledge graph. While this wasn’t available during my original experiments, it represents a promising direction for improving reliability in LLM-to-knowledge-graph interfaces.

However, these were not the only hallucinations. Sometimes, actually, quite often, the model simply started to assume names of entities, e.g., Bob (which I must admit was a good guess) or John for Alice’s brother. Though, more unoriginal names, such as Alice's brother, were also assumed. It is highly unlikely that this would be the name of the entity in question, but the model does not consider this. In the end, it just generates more or less random text, which surprisingly often generates results that are good enough for a human that can easily do the needed interpretation on their end but, unfortunately, not good enough for a computer program such as a querying engine.

Iterative Query Building

My next idea mimicked how humans typically explore knowledge graphs. When I write queries, I start with something simple to get a feel for the structure of the graph, such as:

=== PROMPT ===
### System Message
You are an expert in exploring RDF knowledge graphs using SPARQL. Your high-level objective is to answer the following question: "What is the age difference between Alice and her brother?".

### Capabilities
You can query the graph by writing lines of SPARQL that will be inserted into the following template:
"""
prefix rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#>
prefix rdfs: <http://www.w3.org/2000/01/rdf-schema#>
prefix foaf: <http://xmlns.com/foaf/0.1/>
prefix rel: <http://purl.org/vocab/relationship/>
prefix ex: <https://example.com/people#>

SELECT * WHERE {
 {INPUT_LINES_INSERTION}
}
"""
The query will be executed, and the results will be returned to you. You only have to concern yourself with modifying lines in the WHERE clause.

### History
You can learn from this history of previous attempts and their respective results:
{get_previous_queries_and_results()}

### Task
You should iteratively improve the query step by step. It will be executed, and its results will be available in the history in the next iteration. This is the current query and the results it returned:
{get_last_working_query_and_results()}

### Strategy
First, write out your thoughts. Does the current query yield results that will help you answer the question with some improvements? Is it going in the right direction when considering the results of previous queries? If not, what has to be changed? If yes, what can be improved to get closer to your goal? Consider previous queries so that you don't try things again that did not yield results previously. You are done when you think you have enough knowledge to answer the question.
To be able to iteratively improve the query, you should only do one of the following things: add a line, remove a line, or change a line.

=== RESPONSE FORMAT ===
### Thoughts
<your thoughts about the current query and its results. Does it provide **all** needed information, or how would you improve it?>

### Are we done?
<yes|no>

### Current state of knowledge
<Message with how you would formulate the final answer with your findings so far; add as much concrete information as possible>
If not done, come up with 3 different ideas on how to improve the query.

### Idea <1/2/3>
<your idea>

Select the idea that you believe is the simplest yet most effective. Explain your reasoning for this choice and describe the modifications you would make to the query. In order to provide you with more detailed feedback from the execution, each line will be added one after the other, and the partial query will be executed. Every execution with a non-empty result set will be added to the provided history.
First, write down step-by-step what you want to achieve with each line added and order the lines in a way that allows you to gain the most insights about the graph with each execution, as mentioned before. Also, add your reasoning for the order of each step.

### Step-by-step description
a. <First step> (<reasoning why this step should be first>)
b. <Second step> (<reasoning why this step should be second>)
...

Remember to end each line with a `.`.

### Modifications
[
{{"line": <line number>, "action": "<add>", "text": "<new text> ."}},
{{"line": <line number>, "action": "<edit>", "text": "<modified text>. "}},
{{"line": <line number>, "action": "<delete>", "text": "<text to be deleted> . "}},
...
]
=== END ===

At the placeholders for history and previous queries ({get_previous_queries_and_results()} and {get_last_working_query_and_results()}), I’d insert the actual history of queries and results. My idea was to provide all the information needed for the model to understand how I wanted to collaborate.

This complex approach was token-intensive, but after many attempts, it sometimes managed to find Alice’s brother. However, it tended to overcomplicate things, such as using SPARQL as a calculator to calculate simple age differences in very complex ways or retrieving unnecessary information. It wasn’t efficient or robust, but it was the first of all tried approaches so far that produced somewhat useful results.

I considered building on this foundation, letting the model gradually gain knowledge about the graph until it felt confident to answer. However, the whole system fell apart once I introduced more complex queries. The model started running in circles, creating increasingly complex queries, effectively wandering aimlessly hoping to stumble upon relevant information. Realistically speaking, I wasn’t getting any closer to a viable solution. So, I was back to square one.

What’s Next

After multiple attempts with sophisticated prompts and complex query strategies, I was still stuck without a reliable solution. The approaches I’d tried so far all had fundamental limitations: either they couldn’t handle large graphs, generated hallucinated information, or simply wandered aimlessly without finding the correct answer.

But I wasn’t ready to give up. I realized I needed to approach the problem in a completely different way. If complex prompting strategies weren’t working, perhaps I should try something radically simpler? How about creating a systematic testing approach with incrementally more complex questions so that I could get a comprehensive understanding of the model’s capabilities and limitations?

In Part 2, I’ll share how I developed a rigorous testing methodology that led to a surprising discovery: sometimes, the most straightforward approach is the most effective. I’ll reveal how my most sophisticated prompting techniques were consistently outperformed by something far more basic and how this counterintuitive finding completely changed my approach to connecting LLMs with knowledge graphs.

I’ll also share my process for creating a systematic testing framework that allowed me to measure performance across different prompting strategies with varying question complexity. This data-driven approach led to better results and revealed interesting insights about how LLMs actually reason with structured knowledge.

Blog | Heye's Blog

Semantic Public Learning

Evolving the Learn in Public method

The Four Pillars of Semantic Public Learning

1. Semantically-Enhanced Documentation

2. Citation-Backed Explanation

3. Community-Validated Refinement

4. Knowledge Graph Integration

Practicing Semantic Public Learning: Real-World Examples

What Makes Semantic Public Learning Different

The Broader Impact

The Semantic Public Learning Movement

Your Semantic Public Learning Challenge

Join the Semantic Public Learning Journey

References

Learn in Public

From Individual Discovery to Collective Intelligence

The Teaching Paradox

Discovering Learn in Public

The Research Foundation

Semantic Public Learning

References

Understanding Superposition in Neural Networks: A Guide Through Analogies

What is Superposition?

The Compression Analogy

The River Delta: Information Flow

The Electrical Circuit Perspective

Why Superposition Matters

The Path Forward

References and Further Reading

Core Theoretical Foundations

Sparse Coding and Decomposition Techniques

Interpretability Methods and Visualizations

Advanced Topics and Current Research

Broader Context

ChatGDT — Chatting with Graph-based Digital Twins

Part 1: The Challenge of Natural Language Interfaces for Knowledge Graphs

Introduction

What You’ll Learn From This Series

Technical Foundation

Knowledge Graphs and RDF

FOAF Ontology

SPARQL

Large Language Models and Their Capabilities

Test Dataset

LLM Integration Tools

Initial Approaches

Using LlamaIndex

Results and Analysis

Key Insight

Learnings

Using LangChain

Iterative Query Building

What’s Next