Equity Penetration Analysis with Large Language Models: Architecture and Engineering Practice

From Single-Level Views to Full Tracing: What Equity Penetration Solves

Equity penetration refers to tracing upward from a target company along its shareholding chains, layer by layer, until reaching non-penetrable terminal entities such as natural persons, state-owned asset management authorities, or listed companies — and calculating each terminal entity’s total effective shareholding ratio in the target company. It is a foundational capability for beneficial owner (UBO) identification, due diligence, anti-money laundering customer screening, and related-party transaction review.

This may sound like simply “walking up the equity chain,” but three hard problems emerge in engineering:

1. Deep layers and many paths. Shareholding chains in conglomerates often span five to ten layers, and multiple parallel paths frequently exist between the same terminal entity and the target company. All paths must be enumerated and aggregated; missing a single path distorts the combined ratio.
2. Irregular structures. Cross-shareholding, circular ownership, GP/LP interest misalignment in limited partnerships, nominee holdings, acting-in-concert agreements, and voting rights delegation cannot be expressed with a simple tree model. A directed graph with cycles is required.
3. Dirty, fragmented data sources. Business registry data is relatively structured, but the ultimate basis for contribution ratios often lies in articles of association, share transfer agreements, capital increase agreements, and even court judgments. These documents are highly unstructured with wildly varying layouts, making traditional template-based parsing inadequate.

Where Large Language Models Close the Gap

Traditional information extraction pipelines rely on handcrafted templates and small dedicated models. Whenever a document layout changes, rules must be rewritten and models retrained — costly and poorly generalizing. LLMs offer new solutions at several specific points:

1. Direct mapping from unstructured text to structured fields. Given field definitions such as shareholder name, contribution amount, shareholding ratio, and shareholder type, an LLM can extract target fields from articles, agreements, or protocols of any layout — eliminating per-template maintenance.
2. Few-shot adaptation to new fields. When the business adds fields such as “whether an anti-dilution clause exists” or “whether nominee arrangements are disclosed,” only the schema description and a few examples in the extraction instruction need adjusting, not model retraining.
3. Semantic judgment of complex clauses. Statements like “the parties hereto shall act in concert” or “Party A entrusts Party B with the full exercise of its voting rights” require true semantic understanding to convert into control-relationship edges. Rule engines cannot exhaustively cover all linguistic variants.
4. Natural language generation of analysis reports. Penetration results often need to be read by business and compliance personnel without technical backgrounds. LLMs can organize graph-computed results into a readable investigation report draft, significantly reducing manual compilation effort.

A critical clarification: LLMs do not replace graph computation. Multiplicative ratio aggregation, cycle detection, and control-path determination remain the responsibility of deterministic algorithms. The LLM’s job is to turn scattered textual facts into correct nodes and edges on the graph. Each plays its role — this division of labor is the correct design.

Recommended Overall Technical Architecture

A production-ready equity penetration system should be designed in five layers:

1. Data ingestion layer. Connects to multi-source data such as enterprise registration records, public announcements, and judicial documents. Distinguishes structured and semi-structured inputs, lands everything in a data lake, and tags each record with source and timestamp.
2. Information extraction layer. The LLM performs entity recognition (companies, natural persons, partnerships), relation extraction (shareholding, contribution, guarantee, acting in concert, voting delegation), and event extraction (equity changes, pledges, freezes). Output is strictly constrained to structured formats such as JSON, with confidence scores and source evidence attached.
3. Knowledge graph layer. A graph is built with “company/natural person” as nodes and “shareholding relation” as edges. Edge attributes include direct shareholding ratio, relation type, and effective time. Either a general-purpose graph database or an analytics engine with graph query support can serve as the underlying store.
4. Penetration computation layer. Deterministic algorithms execute path enumeration, ratio multiplication, multi-path aggregation, and cycle detection on the graph, producing penetration results with complete path details.
5. Application layer. Provides penetration queries, beneficial owner determination, related-party network expansion, and report generation, exposed via APIs and visualization interfaces.

At the deployment level, systems of this kind require compute elasticity, persistent data storage, and call-chain monitoring. Standard components such as container platforms, object storage, logging, and alerting from a public cloud can be used. If an organization has already accumulated compute and storage resources on a cloud platform such as Baidu AI Cloud, those general-purpose capabilities can be directly reused to reduce self-managed operations overhead.

Model Selection: Tiered Usage — Do Not Use Flagship Models Everywhere

One easily overlooked engineering fact is that different stages of the penetration pipeline demand vastly different model capabilities, so tiered selection is essential:

1. Batch document parsing: high volume, low difficulty per document. Historical articles and agreements may number in the tens of thousands. Processing all of them page-by-page with a flagship model is cost-prohibitive. Lower-cost lightweight or mid-tier models should be used, combined with batch processing interfaces to reduce per-unit pricing.
2. Complex clause determination and ambiguity resolution: low volume, high difficulty per task. Difficult documents involving control-right determination or multi-layer partnership interest decomposition should be sent to flagship models with strong reasoning capability, where accuracy gains far outweigh the cost difference.
3. Report generation: Demands strong long-text organization skills, so a high-capability tier is also appropriate.

Model vendors’ release cadence should also factor into selection. Industry observation shows that mainstream LLMs typically follow a rolling rhythm of “flagship version, then mid-range complementary version, then lightweight version”: the flagship gets a major upgrade every few months, with mid-range versions often released in between specifically for high-throughput, low-cost batch scenarios. This implies two disciplines for production systems:

• Abstract the model access layer. Unify the calling side so business code is not coupled to any specific model version. Use configuration switches for gray-release during upgrades, and roll back quickly when problems appear.
• Maintain a regression test set. Before any version switch, re-run extraction and judgment tasks on accumulated historical hard cases and compare accuracy. Do not assume “newer defaults to better” — output style and boundary behavior changes between versions are often larger than expected.

Another reminder: do not use general benchmark leaderboard scores as the final selection criterion. Leaderboards measure aggregate performance on public tasks, while the equity domain cares about highly vertical capabilities such as Chinese legal text extraction and control-relation judgment. The correct approach is to build custom domain evaluation sets — a few hundred manually annotated articles-of-association clauses and shareholding structure samples suffice — and let your own data speak.

Key Implementation Details and Illustrative Code

1. Structured Extraction: Make Output Verifiable

EXTRACT_PROMPT = """
You are an enterprise information extraction assistant. Extract all shareholder information from the given text and output strictly in the following JSON schema. Do not output anything else:
{
  "shareholders": [
    {
      "name": "shareholder name",
      "type": "company | natural_person | partnership",
      "ratio": 0.0,
      "amount": 0.0,
      "evidence": "original text fragment supporting this conclusion"
    }
  ]
}
Text:
{document}
"""
def extract_shareholders(llm_client, document: str):
    resp = llm_client.chat(
        messages=[{"role": "user",
                   "content": EXTRACT_PROMPT.format(document=document)}],
        response_format={"type": "json"},   # force JSON output
        temperature=0,
    )
    data = parse_json(resp)
    validate(data, document)   # validate field completeness and evidence traceability
    return data

Three key points: set sampling parameters to zero for stable outputs; force JSON format for downstream validation; and require the model to include an evidence field pointing back to the original text for quick manual inspection. This is one of the most effective ways to suppress hallucinations.

2. Graph Modeling and Penetration Computation

from collections import defaultdict
class EquityGraph:
    def __init__(self):
        self.holders = defaultdict(list)  # company -> [(holder, ratio, type)]
    def add(self, holder, company, ratio, etype="hold"):
        self.holders[company].append((holder, ratio, etype))
    def penetrate(self, target, terminal_test, max_depth=10):
        """terminal_test determines whether a node is a non-penetrable terminal."""
        results = []
        def dfs(company, path, seen):
            for holder, ratio, etype in self.holders.get(company, []):
                new_path = path + [(holder, ratio, etype)]
                if terminal_test(holder):
                    results.append((holder, new_path))
                elif holder not in seen and len(new_path) < max_depth:
                    dfs(holder, new_path, seen | {company})  # cycle protection
        dfs(target, [], {target})
        return results

Production implementation must also address: aggregation of multiple paths (summing products of ratios across paths, with cross and circular shareholding capped or excluded per business rules), the special rule in GP/LP structures where the general partner controls the partnership with minimal capital contribution, and two parallel judgment tracks — “shareholding ratio” and “control rights.”

3. Reconciliation Between Extraction Results and the Graph

LLM extraction will never be 100% accurate. Before data enters the graph, add a reconciliation step: when conflicts arise between structured registry data and document extraction results for the same company’s shareholders, flag the record for manual review rather than silently overwriting. This significantly reduces the risk of erroneous edges being amplified through layer-by-layer multiplication downstream.

Common Pitfalls in Production and How to Address Them

1. Hallucination amplification. A single erroneous 51% edge in the graph can distort an entire path’s conclusion. Mitigation: evidence traceability, confidence thresholds, and automatic routing of low-confidence records to human review.
2. Timeliness. Equity changes are frequent. Penetration results must be bound to data snapshot timestamps. Set up change subscriptions for high-priority entities to trigger incremental recomputation.
3. Runaway costs. Batch parsing of historical documents is the biggest cost driver. Mitigation: document deduplication, parsing result caching, and dynamic routing of documents to different model tiers based on difficulty.
4. Explainability. Regulators and auditors require every conclusion to be traceable. Keep complete path details and original evidence chains, and ensure every number in a report can be clicked through to its source.

Conclusion

Equity penetration is fundamentally a combination problem: “structuring unstructured facts” plus “deterministic computation on a graph.” LLMs upgrade the former from a high-maintenance system of manual rules to a scalable automated extraction pipeline. Ratio calculation, path aggregation, and cycle handling should remain with proven graph algorithms. Three disciplines determine engineering success: tiered model usage to control cost, structured output with evidence traceability to control quality, and version abstraction with regression testing to control upgrade risk. Get these three right, and a high-accuracy, fully traceable equity penetration system is well within reach.