Equity Look-Through Analysis: How to Calculate Multi-Layer Ownership and Engineering Practice

    Equity look-through answers two questions that first-layer shareholder records cannot: how much of a target company a party ultimately owns, and who actually controls it. This article shows how to model an ownership structure as a directed weighted graph, compute aggregate ownership by multiplying ratios along each path and summing across all paths, and treat control-chain determination as a separate per-hop threshold problem. It covers cycle and circular-investment handling, entity resolution, the engineering architecture from unstructured text to explainable conclusions, and the role of LLMs as extraction helpers rather than calculation engines. Runnable Python examples and a fully reproducible worked example are included, along with a three-layer evaluation framework and a list of common pitfalls.

    1. Equity Look-Through: From “Who Is a Shareholder” to “Who Is in Control”

    In due diligence, credit review, related-party identification, and bid qualification checks, looking only at first-layer shareholders is often not enough. A company’s shareholders may themselves be companies, and behind them there may be groups, partnerships, employee stock ownership plans, trusts, or asset management products. When equity is nested layer upon layer, reading only the first-layer registry information is easy to misjudge: you may mistake the largest shareholder for the actual controller, or mistake a nominee holder for the ultimate beneficial owner.

    The core questions that equity look-through analysis must answer can be summarized as two:

    1. How much does the party own through the chain: what is a given party’s aggregate ownership ratio in the target company;
    2. Who ultimately controls it: is there a control chain in which every layer meets a control standard.

    These two questions look related but are modeled differently. Aggregate ownership is a ratio-calculation problem, emphasizing multiplying and summing ratios along paths. A control chain is a control-determination problem, emphasizing whether control is established at each hop. The two must be handled separately and cannot be mixed.

    From a technical standpoint, equity look-through has at least three layers:

    • Data layer: equity information comes from unstructured text such as corporate registries, announcements, periodic reports, bond prospectuses, and company websites, with inconsistent standards and uneven quality;
    • Computation layer: run path calculations on the unified equity graph, handling cycles, cross-level holdings, and point-in-time changes;
    • Application layer: organize the results into explainable reports, risk indicators, and continuous monitoring.

    2. Modeling Equity Structure as a Directed Weighted Graph

    An equity structure can be abstracted as a directed weighted graph G = (V, E):

    • Nodes V: legal entities, natural persons, and indirect holding vehicles such as trusts, asset management products, and employee stock ownership plans;
    • Directed edge e = (u, v): u holds equity in v, with direction pointing from the shareholder to the invested company;
    • Edge weight w(e): the ownership ratio, usually expressed as a decimal, e.g., 0.30 for 30%;
    • Edge attributes: at minimum a point in time T(e) and a source S(e), used to answer “computed as of what date and based on what material”.

    For example, the edge “A → T, ratio 0.30” means A holds 30% of target company T. If the same pair of parties has different dates or multiple sources, they should be recorded separately and not stitched together arbitrarily at calculation time.

    Before implementing the engineering, you must first fix the business definitions:

    • Maximum penetration depth: whether only within N layers is computed, and whether to truncate or flag anything beyond N layers;
    • Node merging rules: whether multiple identities of the same natural person, or former and alias names of the same enterprise, are merged;
    • Quantification standard: enterprises by shareholding ratio; partnerships and asset management products converted by share/interest ratio;
    • Point-in-time snapshot: usually compute one consistent result for the same date; data from different dates cannot be mixed directly.

    3. Aggregate Ownership: Multiplying Along Paths and Summing Across Paths

    For a path from shareholder s to target company t:

    p = s = v0 → v1 → … → vk = t

    The contribution of this path to the look-through result is the product of the ratios at each layer:

    contribution(p) = w(v0, v1) × w(v1, v2) × … × w(v{k-1}, v_k)

    If the same shareholder reaches the same target through multiple paths, the aggregate ownership ratio is the sum of all path contributions:

    share(s → t) = Σ contribution(p)

    On an acyclic graph or DAG, this problem can be solved with depth-first search or by repeated multiplication of the adjacency matrix. Let A be the weighted adjacency matrix and d the penetration depth. Then:

    S_d = A + A² + … + A^d

    The entry in row s, column t of S_d gives shareholder s’s aggregate ownership in target t through paths of no more than d layers. On sparse graphs, traversal-based depth-first search usually uses fewer resources, but its preconditions must be clear: the graph is acyclic or cycles have been handled, and depth pruning is applied.

    Example code:

    1. def share(graph, s, t, max_depth=10):
    2. """Compute shareholder s's aggregate ownership ratio in target t on an acyclic graph"""
    3. total, stack = 0.0, [(t, 1.0, 0)] # (current node, accumulated ratio, depth)
    4. while stack:
    5. node, ratio, depth = stack.pop()
    6. if node == s:
    7. total += ratio
    8. elif depth < max_depth:
    9. for holder, weight in graph.in_edges(node):
    10. stack.append((holder, ratio * weight, depth + 1))
    11. return round(total, 6)

    This implementation assumes a node is not re-entered during traversal. If the graph has cycles, additional handling is required.

    4. Cycles and Circular Investment: Not Negligible, but Not Infinitely Traversable

    Real equity structures may contain cross-shareholding or circular investment, for example A holds B and B holds A. If depth-first traversal allows unlimited looping, it will enumerate paths infinitely, never terminate, and may even cause recursion-depth errors or memory overflow.

    A common mistake is to assume “the ratio keeps shrinking as you multiply, so it can be ignored.” This judgment does not fully hold. For example, if u and v hold each other in proportions a and b, with a = b = 0.4, then one round-trip product is 0.16. Although 0.16 < 1 and the series converges mathematically, the theoretical cumulative effect of unlimited looping is roughly:

    0.16 / (1 - 0.16) ≈ 19.05%

    This shows that cycle effects cannot simply be treated as zero. Note that legal ownership ratios are generally between 0 and 1, so the product of edge weights usually does not diverge; the real problem is not numerical divergence but combinatorial explosion of paths and infinite traversal.

    Engineering practice typically uses the following strategies:

    1. Cap the maximum penetration depth;
    2. Truncate paths whose accumulated ratio falls below a threshold;
    3. Apply a shrinkage factor to loop edges;
    4. Explicitly state the cycle handling standard in the report.

    Example code for graphs with cycles:

    1. def share_with_cycles(graph, s, t, max_depth=10, shrink=0.9):
    2. """Approximate algorithm for graphs with cycles: shrink cycle edges by a factor and cap penetration depth"""
    3. total, stack = 0.0, [(t, 1.0, [t])]
    4. while stack:
    5. node, ratio, visited = stack.pop()
    6. if node == s:
    7. total += ratio
    8. elif len(visited) <= max_depth:
    9. for holder, weight in graph.in_edges(node):
    10. factor = shrink if holder in visited else 1.0
    11. stack.append((holder, ratio * weight * factor, visited + [holder]))
    12. return round(total, 6)

    The point is not to “compute it prettily” but to make results reproducible under the same standard and comparable across different standards. As long as the cycle standard is stated clearly, the results can be audited and re-checked.

    5. A Reproducible Equity Look-Through Example

    The following is a self-consistent example. All parties are illustrative data.

    The equity structure of target company T is:

    • A holds 30% of T;
    • B holds 20% of T;
    • natural person Jiǎ directly holds 10% of T;
    • natural person Yǐ directly holds 40% of T.

    A’s shareholder structure:

    • Jiǎ holds 60% of A;
    • B holds 5% of A;
    • Wù holds 35% of A.

    B’s shareholder structure:

    • A holds 80% of B;
    • Yǐ holds 15% of B;
    • Jiǎ holds 5% of B.

    This structure satisfies:

    • T’s shareholders total: 30% + 20% + 10% + 40% = 100%;
    • A’s shareholders total: 60% + 5% + 35% = 100%;
    • B’s shareholders total: 80% + 15% + 5% = 100%;
    • A and B form a weak cycle: A holds 80% of B, and B holds 5% of A.

    To make the first re-check easier, this section uses the basic standard of “paths without repeated nodes”: if a node has already been visited along a path, the traversal does not loop back through it. If the business requires the cycle-shrinkage standard, you can recompute on the same graph and flag the cycle standard in the results.

    Under this standard, the main paths and results are:

    Shareholder / Node Main penetration path Direct holding Aggregate holding
    A Directly holds 30% of T; A → B → T = 80% × 20% = 16% 30% 46%
    B Directly holds 20% of T; B → A → T = 5% × 30% = 1.5% 20% 21.5%
    Jiǎ Direct 10%; Jiǎ→A→T 18%; Jiǎ→B→T 1%; Jiǎ→A→B→T 9.6%; Jiǎ→B→A→T 0.075% 10% 38.675%
    Yǐ Direct 40%; Yǐ→B→T 3%; Yǐ→B→A→T 0.225% 40% 43.225%
    Wù Wù→A→T: 35% × 30% = 10.5% 0% 10.5%

    Here, A’s aggregate holding is not 30% but 30% + 80% × 20% = 46%. This shows that look-through cannot stop at the first layer, nor can it miss indirect holdings formed through subsidiaries.

    It must be stressed: when there are multiple paths and cycles, the sum of shareholders’ aggregate holdings generally does not equal the total direct ownership of the target, so you cannot cross-add or cross-subtract them directly. In the table above, A and B are both direct shareholders of target T and intermediate holding parties; Jiǎ, Yǐ, and Wù are pierced through as ultimate or upper-level parties. The numbers for different nodes serve different audit purposes and cannot simply be combined into one reconciliation equation.

    6. Ownership vs. Control: How Control Chains Differ

    High aggregate ownership does not mean a control relationship exists. A control chain focuses on “whether every step meets the control threshold.” Typically you can define it as: starting from ultimate controlling parties such as natural persons or state-owned entities, along the path to the target company, every hop’s ownership ratio meets a control threshold, for example 50%, or another standard set by laws and regulations, the articles of association, or internal rules.

    Continuing with the example above, assume the control threshold is 50%.

    For Jiǎ:

    • Jiǎ → A: 60% ≥ 50%;
    • A → T: 30% < 50%, the control chain breaks.

    Look further up the chain:

    • Jiǎ → A → B → T: Jiǎ holds 60% of A (≥ 50%), A holds 80% of B (≥ 50%), but B holds 20% of T (< 50%), the control chain breaks.

    Then Jiǎ’s direct holding in B:

    • Jiǎ → B: 5% < 50%, not enough to form control on its own;
    • even continuing to T, B → T is 20% < 50%.

    Therefore, although Jiǎ’s aggregate holding in T is about 38.675%, Jiǎ cannot control T through equity alone. T has no single control chain and is closer to a company with dispersed ownership.

    Example code for control-chain determination:

    1. def control_paths(graph, target, threshold=0.5, max_depth=10):
    2. """Find control chains from ultimate controlling parties where every hop meets the control threshold"""
    3. result, stack = [], [(target, [])]
    4. while stack:
    5. node, path = stack.pop()
    6. if len(path) >= max_depth:
    7. continue
    8. for holder, weight in graph.in_edges(node):
    9. if holder in path: # control chains do not cross cycles
    10. continue
    11. if weight < threshold: # if any hop is not controlling, the chain breaks
    12. continue
    13. chain = path + [holder]
    14. if is_control_subject(holder):
    15. result.append(chain)
    16. else:
    17. stack.append((holder, chain))
    18. return result

    The core principle here: aggregate ownership uses summing path ratios, while control chains use per-hop threshold checks.

    7. Engineering Architecture: From Unstructured Text to Explainable Conclusions

    A practical equity look-through service usually consists of the following layers:

    1. Ingress layer: receive parameters such as party name, unique identifier, look-through date, and depth limit;
    2. Document layer: connect to text sources such as corporate registries, announcements, periodic reports, and prospectuses;
    3. Extraction layer: extract “shareholder—invested company—ratio—date” relations from the text;
    4. Normalization layer: unify names, merge parties, handle aliases and former names, and unify ratio standards;
    5. Graph storage layer: save equity graphs as point-in-time snapshots, supporting time-slice queries;
    6. Computation layer: run aggregate ownership, direct ownership, and control-chain calculations;
    7. Presentation and audit layer: output the equity structure graph, path lists, evidence chains, and standard notes.

    Among these, entity resolution is the step that decides success or failure. Same name different companies, one company many names, names before and after a rename, and mixed use of abbreviations and full names all turn one party into multiple nodes in the graph, breaking real ownership paths. Common practices include:

    • use the business registration identifier (such as a unified social credit code) as the enterprise primary key, with the name as auxiliary;
    • uniquely identify natural persons by name and ID information, marking them as pending confirmation when ID information is missing;
    • standardize names by removing spaces, unifying full- and half-width characters, and stripping organizational-form suffixes;
    • keep a manual confirmation queue for nodes that cannot be uniquely matched.

    8. Where LLMs Fit: An Extraction Assistant, Not a Compute Engine

    LLMs are well suited to processing unstructured text and turning natural language or semi-structured tables into structured fields. For example:

    • identifying shareholder name, ownership ratio, and holding method from an announcement paragraph;
    • splitting “directly holds 10% and indirectly holds 8% through a subsidiary” into multiple edges;
    • identifying information such as “former name” or “renamed to” from text, for use by the normalization layer.

    But LLMs should not take on the final calculation responsibility:

    • ratio calculation must be done by deterministic algorithms: multiplying and summing along paths should be reproducible;
    • control determination should be done by a rules engine: whether control exists and whether parties act in concert should be judged by explicit thresholds.

    It is recommended to have the model output constrained structured results, for example:

    1. {
    2. "relations": [
    3. {
    4. "from": "Some Holdings Group Co., Ltd.",
    5. "to": "Target Technology Co., Ltd.",
    6. "ratio": 0.30,
    7. "as_of": "2024-12-31",
    8. "source": {
    9. "document": "2024 Annual Report",
    10. "page": 87,
    11. "quote": "...holds 30% of the company's shares..."
    12. }
    13. }
    14. ],
    15. "confidence": "high"
    16. }

    Engineering should also require:

    • confidence labels: high, medium, low; low confidence goes to manual review;
    • reproducible design: record sampling, temperature, and other parameters so the same input can be replayed;
    • rule-based fallback: ratios must fall within a reasonable range, and the same pair of nodes at the same date must not show conflicting ratios.

    LLMs can improve extraction efficiency, but the actual improvement should be measured on a real evaluation set and not assumed in advance.

    9. Measuring Quality: Three Layers of Metrics

    9.1 Extraction layer: did the model read correctly

    • field-level precision, recall, and F1;
    • overall accuracy: a case counts as correct only if shareholder, investee, ratio, and date all match;
    • error attribution: missed extraction, wrong extraction, ratio errors, date errors, reference errors.

    9.2 Computation layer: did the algorithm compute correctly

    • cover acyclic, weakly cyclic, strongly cyclic, and multi-layer cross scenarios;
    • results for the same data stay stable and reproducible across different depths and shrinkage factors;
    • cycles must have an explicitly stated standard, rather than “compute as far as it goes”.

    9.3 Business layer: are the conclusions usable

    • whether the actual controller or ultimate beneficial owner is correctly identified;
    • mean absolute error between aggregate ownership and manual calculations;
    • whether every conclusion can provide paths and source-text evidence;
    • coverage and end-to-end processing time.

    A more robust approach is not to look only at general leaderboards, but to extract real samples from historical projects and build an evaluation set covering the following forms:

    • simple structures with a single natural person holding directly;
    • multi-layer holding groups;
    • cross-shareholding and circular investment;
    • partnerships, trusts, and asset management products;
    • similar, easily confused party names;
    • historical renames and equity changes.

    After a model version upgrade, regression tests should run automatically to confirm that key metrics have not degraded.

    10. Common Pitfalls and Practical Recommendations

    1. Equating the largest shareholder with the actual controller: you must compute aggregate ownership and control chains separately;
    2. Mixing ratio standards: decimals and percentages, subscribed and paid-in capital cannot be mixed;
    3. Ignoring the date: stitching equity data from different dates creates paths that do not exist;
    4. Handing calculation to an LLM: a model is suited to extraction, not to replacing deterministic calculation;
    5. Lacking entity resolution: splitting one party into multiple nodes is one of the most common sources of wrong results;
    6. Outputting only a single number: a look-through conclusion without paths, sources, and standards cannot be audited;
    7. Ignoring or endlessly traversing cycles: explicitly state the depth limit, shrinkage factor, or truncation rule.

    11. Conclusion

    The essence of equity look-through analysis is to answer two questions on a directed weighted graph: how much is the aggregate ownership, and who is in control. The engineering implementation should hold to two main lines:

    • Data line: accurately and traceably turn unstructured text into structured equity data;
    • Computation line: use deterministic algorithms to complete path-product summation and control-chain determination.

    LLMs can improve extraction efficiency, but they cannot replace deterministic calculation and rigorous governance. Write the standards clearly, handle cycles properly, and make entity resolution solid, then combine layered evaluation with manual review, and you can deliver a truly explainable, reproducible, and auditable equity look-through service.