Functional Concept Graphs (FCGs)

• Functional Concept Graphs (FCGs) are graph-based representations that organize functional purposes and mechanisms into hierarchical problem–solution maps.
• They utilize advanced NLP techniques like GPT-3 and Sentence-BERT for extracting and clustering concepts from large-scale patent data.
• FCGs span diverse applications from design ideation to software analysis and arithmetic dynamics, each with distinct semantics and methodological approaches.

Searching arXiv for recent and directly relevant papers on Functional Concept Graphs and neighboring usages of the acronym FCG. First, I’ll retrieve the core paper that explicitly defines Functional Concept Graphs in the design-ideation sense, then gather papers covering adjacent uses of “FCG” and related graph formalisms to map the term’s broader technical landscape. Functional Concept Graphs (FCGs) are graph-based representations in which the semantics of nodes and edges are organized around function rather than surface form. In the explicit design-ideation formulation, an FCG is a directed graph whose nodes are functional concepts—specifically purposes and mechanisms—where a purpose-to-mechanism edge states that the mechanism can help achieve the purpose, and a purpose-to-purpose edge states that the first purpose is an abstraction of the second. The cited literature also uses the acronym FCG for function call graphs in program analysis, while adjacent mathematical work studies functional graphs generated by self-maps on finite sets. Across these papers, the term therefore denotes a family of graph abstractions rather than a single universally fixed formalism (Sweed et al., 5 Sep 2025, Hossain et al., 24 Dec 2025, Mans et al., 2022).

1. Terminological scope and formal disambiguation

In the design-support literature, FCGs are explicitly semantic graphs of problems and solutions. In software-security papers, FCGs are interprocedural graphs of functions and calls. In arithmetic dynamics, the central object is the functional graph of a map $f$, usually with edges $u \to v \Longleftrightarrow f(u)=v$. These are not equivalent uses of the term; they differ in ontology, edge semantics, and intended inference (Sweed et al., 5 Sep 2025, Hossain et al., 24 Dec 2025, Mans et al., 2017).

Usage	Nodes and edges	Representative papers
Functional Concept Graph	Purpose nodes, mechanism nodes; purpose $\to$ mechanism and purpose $\to$ abstract-purpose edges	(Sweed et al., 5 Sep 2025)
Function Call Graph	Functions or methods as nodes; directed call relations as edges	(Hossain et al., 24 Dec 2025, Chen et al., 2 Sep 2025, Jia et al., 24 Jun 2025)
Functional graph	State-space elements as nodes; $u \to f(u)$ or union over several functions	(Mans et al., 2022, Mans et al., 2017, Nara, 16 Sep 2025, Bors et al., 2023)

A common source of confusion is to assume that all FCGs are concept hierarchies. The design-ideation formulation is the only one in the cited set that defines FCGs as a hierarchy of problem abstractions linked to solution mechanisms. The software and arithmetic usages instead treat graphs as abstractions of execution or iteration.

2. Semantic structure in the design-ideation formulation

The design-ideation formulation introduces FCGs to address fixation: innovators often remain trapped in familiar solutions or narrow formulations of a problem. The graph is intended to support abstraction, problem reframing, and analogical inspiration by letting a user move upward to a more general purpose, laterally to sibling problems that share that abstraction, and downward through purpose-to-mechanism links to concrete solution mechanisms. In that sense, the graph is a navigable functional map rather than a keyword index (Sweed et al., 5 Sep 2025).

Formally, the nodes are functional concepts of two kinds: purposes and mechanisms. A directed edge from a purpose node to a mechanism node means that the mechanism can help achieve that purpose. A directed edge from one purpose node to another means that the first purpose is an abstraction of the second. The resulting structure is a hierarchy of problem abstractions connected to concrete solution mechanisms. The paper’s example of problem reframing moves from “protect plants from sun” to “protect organisms from sun,” then to another concrete problem such as “protect skin from sun,” making the analogical route explicit rather than implicit (Sweed et al., 5 Sep 2025).

This formulation is also distinguished from earlier analogy-mining graphs by the explicit treatment of abstraction. The paper states that prior graph constructions were noisy, difficult to scale, and weakly grounded in explicit abstraction because they relied heavily on crowd annotations and simple corpus co-occurrence. The new construction instead encodes abstraction as a first-class edge type.

3. Construction pipeline, hierarchy induction, and MUSE

The large-scale construction pipeline has three stages: extract purposes and mechanisms from patent text, cluster those tags into purpose and solution nodes, and add edges for abstraction and problem-solution relations, then enhance connectivity. The patents come from PatentsView; the corpus is restricted to three CPC top-level categories—Human Necessities (A), Operations and Transport (B), and Mechanical Engineering (F)—which left about 3 million patents, from which 500K patents were sampled for the final graph because of compute and budget limits. For each patent, annotation yields purpose tags $P_d=\{p_1,\dots,p_n\}$ and mechanism tags $M_d=\{m_1,\dots,m_\ell\}$. Mechanisms are derived from CPC tags reduced from over 250,000 tags to about 8,500 CPC tags after cleaning and removal of overly specific lowest-level tags; a manually labeled set of 1,500 tags supports a fine-tuned RoBERTa binary classifier with F1 score $0.88$. Purposes are extracted with GPT-3 in an in-context learning setup, with GPT-3 (Babbage) reported as the best cost-performance tradeoff for tagging 500K patents (Sweed et al., 5 Sep 2025).

Purpose nodes are constructed by embedding purpose tags with Sentence-BERT and clustering with a two-phase strategy: K-means first creates many loose clusters, and agglomerative clustering is then run within each loose cluster with similarity threshold $0.2$. On a small manually clustered evaluation set, the paper reports purity $1.0$ and NMI $u \to v \Longleftrightarrow f(u)=v$0. Across the corpus, purpose tags are clustered into $u \to v \Longleftrightarrow f(u)=v$1. Solution nodes are not formed by pure lexical similarity; they are induced from the purpose clustering, so that two mechanism tags are grouped together if their patents’ purpose tags were clustered together in the previous step. This aligns solution nodes with similar problem contexts rather than surface resemblance (Sweed et al., 5 Sep 2025).

Two edge types are then added. A purpose $u \to v \Longleftrightarrow f(u)=v$2 mechanism edge is created if at least one patent was assigned a purpose tag in the first node and a mechanism tag in the second. A purpose $u \to v \Longleftrightarrow f(u)=v$3 abstract-purpose edge is created by a pretrained NLI model, specifically DeBERTa-V3-large, after representative purpose tags are prefixed by short templates such as “I want” or “The patent provides.” The final entailment threshold is $u \to v \Longleftrightarrow f(u)=v$4, and the prefix “I want” gives recall $u \to v \Longleftrightarrow f(u)=v$5 and precision $u \to v \Longleftrightarrow f(u)=v$6 on a manually checked abstraction set. Cycles are broken by a hierarchy-cleanup method, and redundant edges are removed by keeping only the longest paths. Connectivity is further increased with two classes of virtual nodes: LLM-based abstraction nodes proposed by Llama 3.1 8B Instruct, and verb-based nodes induced from WordNet synonym sets (Sweed et al., 5 Sep 2025).

MUSE, the “Mining Unexpected Solutions Engine,” operates on this graph. Given a target problem $u \to v \Longleftrightarrow f(u)=v$7, it embeds the text with Sentence-BERT, locates the closest graph node $u \to v \Longleftrightarrow f(u)=v$8 using a Faiss index, and samples inspirations along controlled abstraction trajectories. The allowed path patterns are “up, down” and “up, up, down,” corresponding to a v-structure in which the method ascends to a more abstract problem and then descends to a sibling problem. Paths are categorized as NLI-nodes if all edges are NLI-based abstraction edges, LLM-nodes if at least one edge is an LLM-based abstraction edge, and Verb-nodes if at least one edge is verb-based. To enforce diversity, MUSE uses MMR to select up to 5 nodes from each path/source category, for up to 30 inspirations total.

4. Empirical evaluation, creative ideation, and dataset release

The empirical evaluation uses a user study in which participants solve everyday problems such as “Seal a leak” and “Cool a room” under four conditions: Purpose, Purpose + mechanism, Purpose + mechanism sentence, and Empty. Creativity is defined as a combination of feasibility/utility and novelty. The paper reports that inspirations from MUSE improved idea quality, yielding up to 19% more creative solutions in absolute count, with 75% creative ideas in the best inspiration condition versus 49% without inspirations. The sentence-based inspiration condition performs best overall, and the paper suggests that purpose+mechanism snippets may have been harder for users to interpret, whereas natural-language sentences made the analogies easier to grasp (Sweed et al., 5 Sep 2025).

The source-type comparison further indicates that explicit abstraction is especially useful. NLI-based and LLM-based trajectories generally produced more feasible and creative ideas than verb-only trajectories, although verb-based inspirations still had nontrivial value. Across all conditions, solutions that participants explicitly attributed to the graph inspirations were more often creative than those they considered their own ideas (Sweed et al., 5 Sep 2025).

A major contribution is the release of an FCG built from 500,000 patents. The paper presents the dataset as larger than earlier manually curated analogy datasets, explicitly hierarchical, and more connected because of the LLM- and verb-based virtual nodes. This supports future work on analogy mining, functional reasoning, design inspiration, creative AI, retrieval, and benchmark creation. A plausible implication is that the main novelty is not only scale, but the conversion of a large patent corpus into a graph where abstraction is directly queryable rather than inferred indirectly from lexical similarity.

5. FCG as function call graph in software and malware analysis

In the malware-analysis literature represented here, FCG means Function Call Graph rather than Functional Concept Graph. The nodes are functions or methods, and the directed edges are call relations. The Better Call Graphs dataset defines FCGs as Android-specific function call graphs extracted from APKs by static analysis with Androguard, where nodes are methods/functions and directed edges are call relations between methods. The dataset is built from over 125,000 APKs from AndroZoo and VirusShare, filtered by DEX year before 2017, APK size $u \to v \Longleftrightarrow f(u)=v$9 MB, and at least 100 nodes, and results in 10,057 FCGs spanning 2017–2025, including 5,986 benign graphs, 26 malware types, and 126 malware families. Reported average graph sizes are on the order of 27K nodes and 58K edges overall. On this dataset, the best reported accuracy is about 77.1%, and the best Macro-F1 is about 18.8%, which the paper uses to argue that realistic recent APKs make FCG-based malware detection much harder than older benchmarks suggest (Hossain et al., 24 Dec 2025).

HiGraph places function call graphs in a hierarchical graph-of-graphs architecture. Each application has one global FCG and many local CFGs, one per local function node in the FCG. Formally, the FCG is $\to$0, where $\to$1 is the set of functions and $\to$2 the set of call edges between functions, while each local function $\to$3 has CFG $\to$4. The dataset contains 595,211 applications, hence 595,211 global FCGs, together with 201,792,085 local CFGs. Table statistics report average FCG size of 266.48 nodes and 491.67 edges for malicious apps, versus 791.54 nodes and 1,414.51 edges for benign apps. In the benchmark, Hi-GNN achieves PR-AUC $\to$5 and Macro F1 $\to$6 for binary classification, and Macro F1 $\to$7 for multi-class malware family classification (Chen et al., 2 Sep 2025).

A separate empirical study examines FCG variance under compilation. There an FCG is a directed multigraph of binary functions and function calls, stored as a MultiDiGraph because multiple call edges can exist between the same pair of functions. The dataset comprises 51 GNU projects compiled under 17 compilers, 6 optimization levels, and 4 architectures, yielding 100,768 binaries with 43,312,875 binary functions and 187,959,002 function calls. The paper shows that node counts and edge counts vary substantially with optimization and inlining decisions, and it introduces identical, root-equivalent, and relevant mappings between binary functions. It reports anchor similarity $\to$8 to $\to$9 across many cross-optimization comparisons, but worst cross-compiler cases around $\to$0, with lowest neighbor similarity around $\to$1. Existing decomposition methods are then characterized as suffering either from low coverage or from unstable community similarities under FCG variance (Jia et al., 24 Jun 2025).

Taken together, these software papers use FCG to denote interprocedural program structure. This is a different ontology from the design-ideation FCG, even though both emphasize higher-level organization over raw surface form.

6. Mathematical functional graphs and neighboring concept-graph lineages

The arithmetic-dynamical literature studies functional graphs of maps on finite fields and residue rings. For a single polynomial $\to$2, the functional graph has vertex set $\to$3 and an edge $\to$4. A multi-function generalization defines $\to$5 with edge $\to$6 for some $\to$7. For quadratic families $\to$8, the paper studies leaves, meaning vertices of in-degree $\to$9, and denotes the number of leaves by $u \to f(u)$0. It proves the asymptotic estimate $u \to f(u)$1, with improvement to $u \to f(u)$2 when $u \to f(u)$3, so that $u \to f(u)$4. For three polynomials, the leaf count is tied explicitly to the Frobenius trace of the elliptic curve $u \to f(u)$5, and for prime $u \to f(u)$6 the normalized deviation obeys a Sato–Tate type distribution (Mans et al., 2022).

A related study of quadratic polynomials over prime fields focuses on connected functional graphs $u \to f(u)$7 for $u \to f(u)$8, where every connected component contains exactly one directed cycle and the remainder is a rooted tree feeding into that cycle. The paper develops algorithms based on dynatomic polynomials and gcd computations to compute statistics such as the number of connected graphs, the number of cycles of fixed size, and tree-shape parameters. It reports data consistent with the conjecture $u \to f(u)$9 for the count of connected quadratic functional graphs modulo $P_d=\{p_1,\dots,p_n\}$0, while also showing that some statistics resemble random mappings and others deviate because of arithmetic structure (Mans et al., 2017).

Cycle lifting over prime-power rings adds a further layer of structure. For polynomial maps on $P_d=\{p_1,\dots,p_n\}$1, the main invariant is the multiplier of a cycle $P_d=\{p_1,\dots,p_n\}$2, $P_d=\{p_1,\dots,p_n\}$3, together with the correction term $P_d=\{p_1,\dots,p_n\}$4. The paper proves that when a cycle is lifted from $P_d=\{p_1,\dots,p_n\}$5 to $P_d=\{p_1,\dots,p_n\}$6, its behavior is controlled by the reduction of $P_d=\{p_1,\dots,p_n\}$7 modulo $P_d=\{p_1,\dots,p_n\}$8: if $P_d=\{p_1,\dots,p_n\}$9, there is exactly one lifted cycle of the same size; if $M_d=\{m_1,\dots,m_\ell\}$0, one obtains either one cycle of size $M_d=\{m_1,\dots,m_\ell\}$1 or $M_d=\{m_1,\dots,m_\ell\}$2 cycles of size $M_d=\{m_1,\dots,m_\ell\}$3; if $M_d=\{m_1,\dots,m_\ell\}$4, the lifted graph contains one cycle of size $M_d=\{m_1,\dots,m_\ell\}$5 and $M_d=\{m_1,\dots,m_\ell\}$6 cycles of size $M_d=\{m_1,\dots,m_\ell\}$7, where $M_d=\{m_1,\dots,m_\ell\}$8 is the multiplicative order of $M_d=\{m_1,\dots,m_\ell\}$9 (Nara, 16 Sep 2025).

Generalized cyclotomic mappings provide a more algorithmic finite-field setting. An index-$0.88$0 generalized cyclotomic mapping $0.88$1 acts by monomial rules on cosets $0.88$2, and the paper reduces its dynamics to affine maps on $0.88$3. It introduces cycle representatives and lengths lists, arithmetic partitions that control rooted tree isomorphism types, necklace descriptions of connected components, and Las Vegas algorithms for component parametrization, component description, and special cases of functional-graph isomorphism. For fixed index $0.88$4 and most prime powers $0.88$5, the paper states that suitable implementations have expected runtime subexponential in $0.88$6 classically and polynomial in $0.88$7 quantumly (Bors et al., 2023).

Several neighboring graph formalisms clarify the boundaries of FCGs in the semantic sense. ConBias represents a visual dataset as a weighted concept graph $0.88$8 with $0.88$9, where nodes are class labels and concepts and edges encode co-occurrence counts; higher-order cliques then support diagnosis and balancing of concept co-occurrence bias. On Waterbirds, UrbanCars, and COCO-GB, the paper reports CB/OOD results including 77.9/69.3 for ConBias on Waterbirds and 78.3/52.9 on UrbanCars, emphasizing graph-based diagnosis of spurious correlations rather than abstraction-based ideation (Chakraborty et al., 2024). Fuzzy Conceptual Graphs extend classical Conceptual Graphs by inserting fuzziness at different loci—concept nodes, attribute values, relations, or the ontology itself—and the comparative study insists on separating factual from ontological fuzziness and on distinguishing interpretations such as vagueness, uncertainty, confidence, and preference (Faci et al., 2021). A generative line of work formulates conditional graph generation from functional requirements as learning $0.2$0 via serialized graph generation with message passing inserted into an autoregressive LLM, showing that function-driven graph generation can be treated as text-to-text generation with explicit structural inductive bias (Zachares et al., 2023). In a different domain again, dense functional brain graphs $0.2$1 are embedded into a unified latent geometry by a graph transformer autoencoder with latent diffusion, a framework described as highly relevant to FCG-style thinking even though it is not an FCG formalism in the strict symbolic sense (Abulikemu et al., 6 Nov 2025).

This broader landscape indicates that the phrase “Functional Concept Graph” sits at the intersection of several graph traditions: semantic problem–solution hierarchies, program call structure, and functional graphs of dynamical systems. The main conceptual boundary is whether “function” refers to purpose, to callable program units, or to a mathematical self-map.