Hubbry Logo
Circular referenceCircular referenceMain
Open search
Circular reference
Community hub
Circular reference
logo
8 pages, 0 posts
0 subscribers
Be the first to start a discussion here.
Be the first to start a discussion here.
Circular reference
Circular reference
Circular reference
View on Wikipedia
from Wikipedia

A circular reference (or reference cycle[1]) is a series of references where the last object references the first, resulting in a closed loop.

Circular reference (in red)

Simple example

[edit]

A newcomer asks a local where the town library is. "Just in front of the post office," says the local. The newcomer nods, and follows up: "But where is the post office?"

"Why, that's simple," replies the local. "It's just behind the library!"

In language

[edit]

A circular reference is not to be confused with the logical fallacy of a circular argument. Although a circular reference will often be unhelpful and reveal no information, such as two entries in a book index referring to each other, it is not necessarily so that a circular reference is of no use. Dictionaries, for instance, must always ultimately be a circular reference since all words in a dictionary are defined in terms of other words, but a dictionary nevertheless remains a useful reference. Sentences containing circular references can still be meaningful:

Her brother gave her a kitten; his sister thanked him for it.

is circular, but not without meaning. Indeed, it can be argued that self-reference is a necessary consequence of Aristotle's law of non-contradiction, a fundamental philosophical axiom. In this view, without self-reference, logic and mathematics become impossible, or at least, lack usefulness.[2][3]

In computer programming

[edit]
For circular references between objects or resources, see Reference counting.

Circular references can appear in computer programming when one piece of code requires the result from another, but that code needs the result from the first. For example, the two functions, posn and plus1 in the following Python program comprise a circular reference:[further explanation needed] 

def posn(k: int) -> int:
    if k < 0:
        return plus1(k)
    return k

def plus1(n: int) -> int:
    return posn(n + 1)

Circular references like the above example may return valid results if they have a terminating condition. If there is no terminating condition, a circular reference leads to a condition known as livelock or infinite loop, meaning it theoretically could run forever. 

def posn(k: int) -> int:
    return plus1(k)

def plus1(n: int) -> int:
    return posn(n + 1)

In ISO Standard, SQL circular integrity constraints are implicitly supported within a single table. Between multiple tables circular constraints (e.g. foreign keys) are permitted by defining the constraints as deferrable (See CREATE TABLE for PostgreSQL and DEFERRABLE Constraint Examples for Oracle). In that case the constraint is checked at the end of the transaction not at the time the DML statement is executed. To update a circular reference, two statements can be issued in a single transaction that will satisfy both references once the transaction is committed.

Circular references can also happen between instances of data of a mutable type, such as in this Python script: 

mydict: dict[str, str] = {
  "this": "that",
  "these": "those"
}
mydict["myself"] = mydict
print(mydict)

The print(mydict) function will output {'this': 'that', 'these': 'those', 'myself': {...}}, where {...} indicates a circular reference, in this case, to the mydict dictionary.

In spreadsheets

[edit]

Circular references also occur in spreadsheets when two cells require each other's result. For example, if the value in Cell A1 is to be obtained by adding 5 to the value in Cell B1, and the value in Cell B1 is to be obtained by adding 3 to the value in Cell A1, no values can be computed. (Even if the specifications are A1:=B1+5 and B1:=A1-5, there is still a circular reference. It does not help that, for instance, A1=3 and B1=-2 would satisfy both formulae, as there are infinitely many other possible values of A1 and B1 that can satisfy both instances.)

Circular reference in worksheets can be a very useful technique for solving implicit equations such as the Colebrook equation and many others, which might otherwise require tedious Newton-Raphson algorithms in VBA or use of macros.[4]

A distinction should be made with processes containing a circular reference between those that are incomputable and those that are an iterative calculation with a final output. The latter may fail in spreadsheets not equipped to handle them but are nevertheless still logically valid.[3]

See also

[edit]

References

[edit]
Revisions and contributorsEdit on WikipediaRead on Wikipedia

Circular reference

View on Grokipedia
from Grokipedia
A circular reference, also known as a reference cycle, occurs when two or more entities—such as objects, variables, formulas, definitions, or logical statements—reference each other in a way that forms a closed loop, where the final reference points back to the initial one. This creates a dependency chain that circles indefinitely, preventing straightforward resolution. Circular references arise in various fields, including , formal logic, , and . In contexts, circular references are a common challenge across programming languages, data structures, and applications like spreadsheets. In , circular references typically arise when objects hold mutual pointers or references, such as object A referencing object B and object B referencing object A. This structure complicates in languages using reference-counting garbage collection, as each maintains a non-zero reference count despite being unreachable from the program's roots. To address this, languages like Python implement cyclic garbage collectors that traverse object graphs to detect and collect such cycles, requiring custom support in container types via mechanisms like traversal callbacks. In contrast, languages using , such as and C#, handle circular references automatically without special measures for memory leaks, as the collector identifies unreachable objects regardless of cycles. In spreadsheet applications like , a circular reference manifests when a cell's directly or indirectly depends on itself—for instance, a in cell A1 that includes A1 (=A1+1) or chains through other cells back to A1. This triggers an error warning, displays a zero value or the last computed result, and can halt calculations unless iterative computation is explicitly enabled, which repeats s up to a set limit to approximate convergence. While sometimes intentional for iterative modeling (e.g., solving equations), circular references often stem from errors and degrade performance by slowing refreshes. Beyond software, circular references pose challenges in areas like and , where interdependent queries or calculations can create irresolvable loops, necessitating tools for detection and refactoring to ensure and computational efficiency. Overall, avoiding circular references through , acyclic graphs, and validation tools is a to prevent logical inconsistencies, resource exhaustion, and difficulties.

Fundamentals

Definition

A reference, in the context of logic and , is a relation that connects representational entities—such as statements, terms, or objects—to the items, properties, or concepts they denote or depend upon. This relational structure allows for the expression of dependencies or indications between distinct elements, forming the foundational prerequisite for understanding more complex referential patterns. A circular reference arises when a sequence of such references creates a closed loop, with the final element pointing back to the initial one, often resulting in ambiguity, , or failure of termination in analytical processes. This structure contrasts with linear references, where dependencies resolve hierarchically without cycling, and can undermine the clarity or validity of reasoning by presupposing what needs to be established. Circular references manifest in various domains but share the core feature of non-terminating dependency chains that challenge foundational assumptions. Circular references can be classified into direct and indirect types. Direct circularity occurs when two entities mutually reference each other, such as entity A depending on B and B depending on A, creating an immediate loop. Indirect circularity involves a longer chain, where multiple entities form a cycle, for example, A references B, B references C, and C references A, extending the loop across more steps. These distinctions highlight how the scale of the cycle affects the detection and implications of the circularity, though both types equally disrupt acyclic resolution. The origins of circular references trace to , with addressing them in his discussions of demonstration around 350 BCE, where he rejected circular proofs as invalid because they fail to establish premises as prior to conclusions, reducing to tautological assertions like "if A is, then A must be." In the Posterior Analytics, argues that such loops cannot yield scientific knowledge, as true demonstration requires non-circular foundations known through insight (nous). This critique laid early groundwork for analyzing referential cycles in logic, influencing subsequent philosophical treatments of regress and justification.

Simple Example

A simple example of a circular reference arises in everyday navigation scenarios. Consider a traveler seeking directions to the local . A passerby instructs them to visit the nearby for an updated that marks the . Upon arriving at the library, the staff directs the traveler to the post office to obtain the library's directory, which includes access details for the map. This mutual referral forms an endless loop, preventing the traveler from reaching their destination. This illustration highlights the core mechanics of a circular reference—a self-reinforcing cycle of dependencies with point or resolution. The traveler's quest stalls in perpetual redirection, mirroring how such loops can cause inefficiency and in real-world interactions, as the process demands an unattainable starting resolution to proceed. Similar circular patterns occur in instructional guides or public , such as steps that refer to a defined in an appendix, which in turn points back to the main instructions for clarification, trapping the user in unresolved back-and-forth without advancing the task.

In Language and Logic

In Natural Language

In , circular references frequently occur in dictionaries, where a word's incorporates synonyms or related terms whose own definitions eventually cycle back to the original word or a close variant, forming a definitional loop. This circularity is not inherently problematic but serves a practical purpose due to the hierarchical structure of dictionaries, which organizes entries from simpler, primitive concepts to more complex ones, enabling users to resolve meaning through incremental clarification rather than strict linearity. A prominent pitfall of circular references arises in through the fallacy known as or petitio principii (begging the question), where an argument's assume the truth of its conclusion, offering no independent support and thus undermining persuasive validity. For instance, the claim "This book is true because it says so within its pages" exemplifies this by relying on the book's content to validate itself, creating a self-reinforcing loop that fails to advance understanding or evidence. Such constructions can mislead in debates or , highlighting the need for external verification to break the cycle. Self-referential phrases in introduce milder forms of circularity by directly commenting on their own properties, often generating interpretive in casual communication. The classic example, "This sentence is false," loops by asserting its own falsity, which, if true, renders it false, and vice versa, illustrating how such devices can playfully or unintentionally complicate straightforward expression in writing or speech. Cultural expressions like proverbs and idioms often employ circular references descriptively, reinforcing norms through tautological loops that describe without resolving deeper inquiry. Phrases such as "Boys will be boys" tautologically affirm expected male behavior as inherent, providing social acceptance but little explanatory insight, while "It is what it is" circularly acknowledges unchangeable circumstances, offering rhetorical closure in everyday discourse. These examples demonstrate the utility of circularity in natural language for conciseness and cultural resonance, despite their potential to evade analytical depth.

In Formal Logic

In formal logic, circular references manifest as self-referential structures that challenge the consistency and completeness of deductive systems. A paradigmatic example is the , which arises from a statement such as "This sentence is false." This creates a direct circular reference: if the sentence is true, then it must be false as it asserts its own falsity; conversely, if it is false, then it must be true since it accurately describes itself as false. Formally, this can be represented as a sentence LL where L≡¬\Tr(⌜L⌝)L \equiv \neg \Tr(\ulcorner L \urcorner), with \Tr\Tr denoting the truth predicate and ⌜L⌝\ulcorner L \urcorner its Gödel number, leading to the contradiction \Tr(⌜L⌝)∧¬\Tr(⌜L⌝)\Tr(\ulcorner L \urcorner) \wedge \neg \Tr(\ulcorner L \urcorner). This paradox violates the and, via the principle of explosion (ex falso quodlibet), renders the entire system trivial by implying every statement is both true and false. Aristotle laid foundational principles to mitigate such circularities in . In his Metaphysics (Book IV), he articulated , stating that "it is impossible for the same thing to belong and not to belong at the same time to the same thing and in the same respect," positioning it as an indemonstrable essential for all rational . This law directly counters paradoxical self-references by prohibiting contradictory predications within a single context. Furthermore, in the , Aristotle rejected circular definitions and demonstrations in syllogistic logic, insisting that premises must be prior and better known than conclusions to ensure non-circular proofs; syllogisms, as chains of categorical propositions (e.g., "All A are B; all B are C; therefore, all A are C"), rely on acyclic hierarchies of universals to avoid . Self-reference extends to broader limitations in formal systems through Kurt Gödel's incompleteness theorems of 1931. The first theorem constructs a self-referential sentence GG in any consistent FF capable of basic arithmetic, such that GG asserts its own unprovability: G≡¬\ProvF(⌜G⌝)G \equiv \neg \Prov_F(\ulcorner G \urcorner), where \ProvF\Prov_F is the provability predicate. If FF proves GG, then GG is false (since it claims unprovability), contradicting consistency; if FF disproves GG, then GG is true (unprovable yet true), again yielding inconsistency. Thus, GG remains undecidable within FF, revealing inherent incompleteness due to circular self-assessment of provability. The second theorem compounds this by showing that no consistent FF can prove its own consistency (\Cons(F)\Cons(F)), as such a proof would circularly rely on unverified assumptions about the system's reliability. To resolve these circular references, logicians employ hierarchical axioms and stratified languages in . Alfred Tarski's 1933 semantic theory of truth introduces a hierarchy of languages, where truth predicates apply only to object languages from a higher-level , preventing self-reference; for instance, truth for sentences in language L0L_0 is defined in L1L_1, but L1L_1 cannot refer to its own truth without ascending further, thereby breaking cycles and avoiding paradoxes like the Liar. This approach ensures adequacy (T-schema satisfaction: \Tr(⌜p⌝)↔p\Tr(\ulcorner p \urcorner) \leftrightarrow p) while maintaining formal correctness, influencing subsequent proof systems by enforcing acyclic type structures.

In Mathematics

Graph Theory Representation

In , circular references are formalized as cycles within a G=(V,E)G = (V, E), where the vertex set VV represents entities (such as variables or objects), and the edge set EE consists of directed edges (u,v)(u, v) indicating that entity uu references entity vv. A circular reference manifests as a directed cycle, a closed path where following the edges returns to the starting vertex without repetition of vertices except at the end. This model captures the recursive dependency inherent in circular references, distinguishing them from acyclic structures that allow topological ordering. Cycle detection in such graphs is efficiently performed using depth-first search (DFS), which traverses the graph while tracking visitation states to identify back edges leading to vertices in the current recursion stack. The algorithm assigns colors to vertices—white (unvisited), gray (visiting), and black (visited and finished)—to detect cycles: a gray neighbor indicates a cycle. A pseudocode outline for the DFS-based detection is as follows:

function DFS(node): color[node] = GRAY for each neighbor in graph[node]: if color[neighbor] == GRAY: return true // Cycle detected if color[neighbor] == WHITE and DFS(neighbor): return true color[node] = BLACK return false // Run for all nodes for each node in V: if color[node] == WHITE and DFS(node): cycle exists

function DFS(node): color[node] = GRAY for each neighbor in graph[node]: if color[neighbor] == GRAY: return true // Cycle detected if color[neighbor] == WHITE and DFS(neighbor): return true color[node] = BLACK return false // Run for all nodes for each node in V: if color[node] == WHITE and DFS(node): cycle exists

This approach runs in O(∣V∣+∣E∣)O(|V| + |E|) time, making it suitable for analyzing dependency graphs. Key properties of circular references in this representation include their relation to strongly connected components (SCCs), maximal subgraphs where every pair of vertices is mutually reachable via directed paths. An SCC containing more than one vertex necessarily includes at least one directed cycle, as mutual reachability implies cyclic paths; trivial SCCs (single vertices) are acyclic. The girth of the graph, defined as the length of the shortest directed cycle (or infinity if acyclic), quantifies the minimal circular reference size and influences graph sparsity and computational complexity in cycle-related problems. In mathematical applications, this graph-theoretic model aids in analyzing dependencies within systems of equations, where vertices represent variables and edges denote reliance in definitions or constraints; cycles signal inconsistencies or non-unique solutions, as seen in constraint propagation or variants. Similarly, in , cycles in graph embeddings on surfaces correspond to non-trivial homology classes capturing "holes" in the space, facilitating computations in .

Other Mathematical Contexts

In mathematical contexts beyond , circular references manifest in implicit equations and recursive structures where a quantity is defined in terms of itself, often requiring fixed-point analysis to resolve. Consider implicit systems of the form x=f(x)x = f(x), where xx is a vector in a compact and ff is a continuous mapping. Such equations exhibit because the value of xx depends on applying ff to itself. Brouwer's fixed-point theorem guarantees the existence of at least one solution x∗x^* such that f(x∗)=x∗f(x^*) = x^* for continuous functions on the closed unit ball in nn-dimensional . This theorem, established by in 1912, provides a foundational tool for proving solvability in these self-referential systems without constructing the solution explicitly. Recursive definitions in often rely on fixed points to handle apparent circularity, particularly in or functions defined iteratively. A well-founded recursive definition, such as the function where 0!=10! = 1 and n!=n⋅(n−1)!n! = n \cdot (n-1)! for positive integers nn, avoids true circularity by terminating at a base case, ensuring finite computation. However, in infinite or non-terminating , circular pitfalls arise if the process loops indefinitely without convergence, leading to unless analyzed via fixed points. For instance, a recursive xn+1=f(xn)x_{n+1} = f(x_n) may converge to a fixed point L=f(L)L = f(L) under conditions like contractivity, as per the , which ensures uniqueness and iterative solvability in complete metric spaces. Without such guarantees, circular can fail to yield a meaningful limit, highlighting the need for base cases or convergence criteria in mathematical . In algebra, circular references appear in structures like circular permutations, where arranging nn distinct objects in a circle equates rotations of the same arrangement, creating a cyclic dependency in counting distinct configurations. The number of such permutations is given by (n−1)!(n-1)!, accounting for the that identifies equivalent orderings. This contrasts with linear permutations (n!n!) by treating the circular arrangement as self-referential under rotation. Dependencies in matrix inverses can also exhibit circularity in solving systems where iterative methods, such as Gauss-Seidel, approximate solutions to Ax=bAx = b by updating components that depend on previous estimates, potentially looping until convergence at a fixed point. Historically, Leonhard Euler explored self-referential terms in infinite series during the , using analytical methods to sum sequences by setting up equations where the sum SS appears on both sides. In his 1732–1733 work Methodus generalis summandi progressiones, Euler manipulated expressions like S=1+xSS = 1 + xS for , solving self-referentially to derive closed forms, such as S=11−xS = \frac{1}{1-x} for ∣x∣<1|x| < 1. This approach extended to continued fractions, where Euler's 1737 formula connected infinite series to self-referential quotients, like a1b1+a2b2+a3b3+⋯\frac{a_1}{b_1 + \frac{a_2}{b_2 + \frac{a_3}{b_3 + \cdots}}}, providing a framework for evaluating divergent or circularly defined expressions.

In Computer Science

In Programming Languages

Circular references in programming languages often manifest as infinite loops during execution, particularly in recursive functions where mutual calls create a cycle without a proper termination condition. For instance, in Python, consider two mutually recursive functions: one defining whether a number is even by calling a function to check if it is odd, and the other doing the reverse without adequate base cases. This leads to unbounded recursion, exhausting the call stack and raising a RecursionError due to stack overflow. In object-oriented languages, circular references arise in memory management when objects reference each other cyclically, potentially hindering garbage collection if the system relies on reference counting. In Java, two classes might each hold a reference to an instance of the other, forming a cycle; however, the JVM's tracing garbage collector identifies such objects as collectible if they are unreachable from garbage collection roots like threads or static variables, preventing leaks despite the cycle. Similarly, in C++, using std::shared_ptr for mutual references between objects increments reference counts in a loop, keeping counts above zero and causing memory leaks unless broken with std::weak_ptr, which provides non-owning access without affecting the count. Languages implement specific mechanisms to detect or mitigate these issues. Python's sys.setrecursionlimit function allows adjusting the maximum recursion depth to avert stack overflows from deep or cyclic calls, though exceeding the underlying C stack limit can still crash the interpreter. Rust's ownership and borrowing model, introduced in its 1.0 stable release in 2015, enforces single ownership at compile time to prevent reference cycles in safe code, but shared ownership via Rc<T> and interior mutability with RefCell<T> can introduce cycles; these are addressed using Weak<T> to break loops without claiming ownership. In modular systems, circular references appear as import cycles. Post-2015 ES6 module adoption, detects potential circular dependencies during compilation through module resolution analysis, issuing warnings or errors in tools like the compiler when modules import each other cyclically, which can lead to at runtime if not resolved by refactoring exports. These occurrences can be abstracted as cycles in a representing function calls or object references.

In Data Structures

In data structures, circular references manifest as cycles within linked representations or dependency relations, impacting traversal, compilation, and concurrency. A prominent example is the circular linked list, a variation of the where the last node's pointer references the first node, creating a closed loop. This design facilitates efficient full-list traversal from any node without checking for a null terminator, which is advantageous for applications like or circular buffers. However, it introduces risks such as infinite loops during iteration if the traversal logic fails to detect the cycle or implement a termination condition, like tracking the starting node. Circular references also arise in dependency graphs used by compilers and build systems to order module compilation or linking. For instance, mutual include dependencies between source files form cycles that prevent determining a valid build sequence, leading to failures or incomplete builds. These cycles are detected through algorithms applied to the of dependencies; if a cycle exists, the graph is not acyclic, and tools report errors to resolve the issue manually. In GNU Make, such loops trigger warnings like "Circular dependency dropped," ensuring the build halts or skips problematic edges to avoid infinite . Algorithmically, mutual references in concurrent data structures can precipitate livelock, where processes or threads remain active but fail to progress due to perpetual state changes in response to one another, often stemming from cyclic . Unlike deadlock, where entities are frozen, livelock involves continuous retries, such as threads yielding locks in a loop without resolution, exacerbating non-termination in parallel algorithms. To mitigate circular references in memory management, weak references provide an optimization by allowing garbage collectors to reclaim objects involved in cycles without strong retention. In languages with like , structures such as WeakHashMap employ weak references for keys, automatically removing entries when keys are no longer strongly reachable elsewhere, thus preventing memory leaks from unintended cycles in caches or graphs. Introduced in JDK 1.2, this mechanism ensures cycles do not indefinitely prolong object lifetimes.

Practical Applications

In Spreadsheets

In spreadsheets, a circular reference occurs when a formula in one cell directly or indirectly refers back to itself, creating a dependency loop that prevents normal calculation. For instance, if cell A1 contains the formula =A2+1 and cell A2 contains =A1+1, the mutual dependency forms a cycle, which spreadsheet software like flags as an error to avoid infinite loops and incorrect results. Modern spreadsheet applications detect circular references during formula evaluation and alert users through error messages displayed in the status bar or formula auditing tools. In Excel, the status bar highlights the first cell involved in the loop, and users can access the Formulas tab to select Error Checking > Circular References, which lists all affected cells for sequential navigation. Additionally, the Trace Precedents and Trace Dependents features visualize arrows connecting dependent cells, helping users identify and break the loop by editing s or restructuring dependencies. These tools ensure prompt resolution, as unresolved circular references can halt calculations and lead to unreliable data. Despite typically being errors, circular references can be used intentionally for iterative calculations that approximate solutions to implicit equations, such as those requiring convergence over multiple passes. In Excel, this is enabled via File > Options > Formulas > Enable iterative calculation, which limits iterations (default maximum of 100) and sets a change threshold (default 0.001) to stop when values stabilize. A common application is in , like solving for (NPV) where circular formulas iteratively adjust interest rates or cash flows that depend on prior outputs until convergence. This feature, refined in Excel 97, allows controlled while warning users of potential performance impacts from excessive loops. Early spreadsheets like , released in 1979, lacked sophisticated dependency tracking and iterative support, often resulting in "" messages upon detecting circular references during recalculation. Users relied on manual workarounds, such as forcing a full recalculation with the exclamation command (!) to restore approximate values or restructuring formulas to avoid loops, as the program recalculated the entire sheet without distinguishing dependencies.

In Databases

In relational databases, circular references manifest as cycles in constraints, where one table references another and vice versa, complicating data insertion and updates because constraints are typically checked immediately after each operation. For instance, inserting records into both tables requires temporary violations of , which can lead to transaction failures unless handled explicitly. To address this, many management systems (RDBMS) implement deferrable constraints, allowing checks to be postponed until transaction commit. , for example, introduced support for deferrable foreign keys in version 7.1, released on April 13, 2001, enabling declarations like DEFERRABLE INITIALLY DEFERRED to resolve cycles by validating all changes atomically at the end. Similarly, supports deferrable foreign keys, with tools for detecting cyclic dependencies during schema validation. In document-oriented databases like , circular references often arise in denormalized embeddings, where documents mutually include sub-documents from each other, risking data inconsistency during updates since changes in one document do not automatically synchronize across references. Application logic must therefore enforce consistency, such as through atomic updates or avoiding deep nesting to prevent propagation errors and storage bloat. Common resolutions for circular references in databases include adopting surrogate keys—artificial unique identifiers like auto-incrementing integers—to decouple natural dependencies and eliminate cycles without altering , or redesigning schemas to enforce acyclicity through normalization principles. In contrast, modern graph databases such as , first released in 2007, intentionally accommodate cycles in node-relationship models, treating them as valid representations of interconnected data like bidirectional links, without relying on constraint-based enforcement.

In Artificial Intelligence

In artificial intelligence, circular references manifest in recursive neural network architectures, where computational dependencies form loops that enable the processing of hierarchical data structures. A prominent example is the Tree-LSTM model, introduced in 2015, which extends (LSTM) networks to tree-structured topologies for tasks. In this architecture, outputs from child nodes in a are aggregated and fed back as inputs to parent nodes through specialized gates (input, forget, and output), allowing the model to capture syntactic and semantic relationships in sentences. This recursive feedback mechanism, while powerful for tasks like on the Stanford Sentiment Treebank, requires careful design to avoid unintended infinite recursions during training or inference, as the bottom-up propagation can amplify errors in cyclic-like dependencies within non-acyclic inputs. Circular references also arise in AI reasoning systems, particularly within knowledge graphs used for , where cyclic dependencies can lead to computational undecidability. In ontologies based on the (OWL) 2 Full, for instance, subproperty chain axioms can create mutual references between properties, such as defining "hasUncle" in terms of "hasCousin" and vice versa, forming closed loops that challenge reasoners' ability to terminate. Unlike the decidable OWL 2 DL, which prohibits such cycles through syntactic restrictions, OWL 2 Full's expressivity permits these structures, rendering entailment and consistency checking undecidable due to potential infinite derivations in the underlying RDF semantics. This issue is critical in AI applications like , where cyclic ontologies can cause reasoners to enter non-terminating loops, necessitating stratified or acyclic approximations for practical deployment. To address circular references in AI graph-based models, detection tools play a vital role in identifying and mitigating cycles during development and deployment. The NetworkX library, a widely used Python package for graph analysis, provides robust functions such as simple_cycles for enumerating elementary circuits in directed graphs and find_cycle for detecting a single cycle via , enabling developers to validate AI knowledge graphs before . Updated to version 3.3 in April 2024, NetworkX supports efficient computation and girth estimation, which are essential for recursive architectures or ontologies in AI pipelines, ensuring scalability in large-scale applications like neural symbolic reasoning. Recent advancements in large language models (LLMs), such as the GPT series introduced post-2020, highlight ongoing challenges with circular references in self-referential prompting, where models generate outputs that loop back as inputs, exacerbating hallucinations—fabricated or inconsistent responses. Self-referential prompts, like instructing an LLM to critique its own generation iteratively, can induce "hallucination loops" by reinforcing probabilistic biases in token prediction, leading to divergent or infinite-like reasoning chains without external anchors. Mitigation strategies emphasize grounding techniques, such as retrieval-augmented generation (RAG), which integrates external knowledge retrieval to break cycles by verifying outputs against verifiable sources, significantly reducing hallucination rates. These approaches prioritize hybrid systems combining LLMs with structured graphs to enforce acyclicity in inference paths.

References

  1. https://support.microsoft.com/en-us/office/remove-or-allow-a-circular-reference-in-excel-8540bd0f-6e97-4483-bcf7-1b49cd50d123
  2. https://docs.python.org/3/c-api/gcsupport.html
  3. https://www.baeldung.com/java-gc-cyclic-references
  4. https://www.c-sharpcorner.com/article/understanding-garbage-collection-and-cyclic-references-in-c-sharp/
  5. https://www.fe.training/free-resources/investment-banking/what-are-circular-references-in-financial-modeling/
  6. https://plato.stanford.edu/entries/reference/
  7. https://plato.stanford.edu/archives/sum2012/entries/nonwellfounded-set-theory/
  8. https://shawn-standefer.github.io/pdfs/non-classical-circular-definitions.pdf
  9. https://classics.mit.edu/Aristotle/posterior.1.i.html
  10. https://plato.stanford.edu/entries/aristotle-logic/
  11. https://link.aps.org/doi/10.1103/Physics.5.s148
  12. https://www.researchgate.net/publication/388410095_Circularity_and_fuzzy_classes_in_word_definition
  13. https://owl.purdue.edu/owl/general_writing/academic_writing/logic_in_argumentative_writing/fallacies.html
  14. https://philosophy.lander.edu/logic/circular.html
  15. https://www.cs.utexas.edu/~dnp/frege/back-to-the-law-of-the-excluded-middle.html
  16. https://www.scribbr.com/rhetoric/tautology/
  17. https://link.springer.com/article/10.1007/BF01068094
  18. https://plato.stanford.edu/entries/liar-paradox/
  19. https://plato.stanford.edu/entries/goedel-incompleteness/
  20. https://plato.stanford.edu/entries/tarski-truth/
  21. https://algs4.cs.princeton.edu/lectures/keynote/42DirectedGraphs-2x2.pdf
  22. https://www.cs.williams.edu/~shikha/teaching/spring20/cs256/lectures/Lecture04.pdf
  23. https://cp-algorithms.com/graph/strongly-connected-components.html
  24. https://people.maths.ox.ac.uk/keevash/papers/bojanq.pdf
  25. https://www.cambridge.org/core/journals/design-science/article/attribute-dependency-graphs-modelling-cause-and-effect-in-systems-design/1245474D85F366D8AD86943D9C806B5A
  26. https://dccg.upc.edu/irp2018/wp-content/uploads/2018/04/Notes_BojanMohar.pdf
  27. https://mathworld.wolfram.com/BrouwersFixed-PointTheorem.html
  28. https://plato.stanford.edu/entries/recursive-functions/
  29. https://mathworld.wolfram.com/BanachFixed-PointTheorem.html
  30. https://www.ms.uky.edu/~droyster/ma114F16/RecursiveSequences.pdf
  31. https://mathworld.wolfram.com/CircularPermutation.html
  32. https://math.mit.edu/~gs/linearalgebra/ila5/linearalgebra5_1-3.pdf
  33. https://www.sciencedirect.com/science/article/pii/S0315086019300400
  34. https://www.sciencedirect.com/science/article/pii/S0315086014000044
  35. https://docs.python.org/3/library/sys.html#sys.setrecursionlimit
  36. https://en.cppreference.com/w/cpp/memory/weak_ptr
  37. https://doc.rust-lang.org/book/ch04-01-what-is-ownership.html
  38. https://doc.rust-lang.org/book/ch15-06-reference-cycles.html
  39. https://www.typescriptlang.org/docs/handbook/2/modules.html
  40. https://2ality.com/2014/09/es6-modules-final.html
  41. https://www.geeksforgeeks.org/dsa/circular-linked-list/
  42. https://www.baeldung.com/java-deadlock-livelock
  43. https://docs.oracle.com/javase/8/docs/api/java/util/WeakHashMap.html
  44. https://www.microsoft.com/en-us/microsoft-365/blog/2012/02/17/circular-reference-excels-most-popular-error-message-explained/
  45. https://support.microsoft.com/en-us/office/change-formula-recalculation-iteration-or-precision-in-excel-73fc7dac-91cf-4d36-86e8-67124f6bcce4
  46. https://www.ablebits.com/office-addins-blog/circular-reference-excel/
  47. https://mirrors.apple2.org.za/ftp.apple.asimov.net/documentation/applications/misc/visicorp_visicalc_manual_ocr.pdf
  48. https://www.cybertec-postgresql.com/en/foreign-keys/
  49. https://db-engines.com/en/system/Neo4j
  50. https://arxiv.org/abs/1503.00075
  51. https://arxiv.org/pdf/1108.0155
  52. https://www.w3.org/TR/owl2-syntax/
  53. https://networkx.org/documentation/stable/reference/algorithms/cycles.html
  54. https://networkx.org/documentation/stable/release/release_3.3.html
Add your contribution
Related Hubs
User Avatar
No comments yet.