Technical Logic and General Practices for Equity Penetration Analysis

1. Core Problems Solved by Equity Penetration

Equity penetration is not a single query action, but a typical graph analysis problem. Its goal is to trace layer-by-layer up or down along investment relationships between enterprises to answer several key questions:

1. Who is the ultimate controller of an enterprise?
2. How much equity does a natural person or organization control through multiple layers of intermediate entities?
3. Under a multi-tier shareholding structure, how are actual voting rights and beneficial rights calculated?
4. Does a specific shareholder or ultimate controller bypass disclosure or regulatory requirements through indirect shareholding?

In business practices, such analysis is widely applied in due diligence, risk compliance, investment decisions, supply chain finance, and corporate credit assessment. Technical teams usually need to integrate business registration data, shareholder contribution data, and outward investment data into a unified relationship graph, and then perform path calculations and ratio aggregation based on graph computing or relational databases.

2. Data Modeling for Equity Relationships

The foundation of equity penetration is building a computable equity relationship graph. There are two types of nodes in the graph: entity nodes (including corporate legal persons, natural persons, partnerships, funds, etc.) and relationship edges representing “contribution” or “investment” actions. Each edge needs to carry at least the following attributes:

• Shareholding ratio;
• Contribution amount;
• Contribution date;
• Contribution method;
• Whether it is direct or indirect shareholding;
• Whether there is an acting-in-concert relationship;
• Whether it belongs to shares held in trust, pledged, or restricted.

A common data table structure can be designed as follows:

CREATE TABLE equity_relation (
    id BIGINT PRIMARY KEY,
    src_node_id BIGINT NOT NULL,       -- Shareholder
    dst_node_id BIGINT NOT NULL,       -- Invested enterprise
    ratio DECIMAL(9,6) NOT NULL,       -- Shareholding ratio, e.g., 0.317500 means 31.75%
    amount DECIMAL(18,2),              -- Contribution amount
    relation_type VARCHAR(32),         -- direct, indirect, acting_in_concert
    start_date DATE,
    end_date DATE,
    valid_flag TINYINT DEFAULT 1
);

For multi-tier penetration, merely storing direct shareholding relationships is insufficient. It is also necessary to establish a path table from a source node to any reachable node, or introduce multi-hop traversal capabilities of graph databases. Graph databases are well-suited to express such deep reachable relationships, while relational databases are better for structured aggregation and report output. In actual engineering, a hybrid architecture is common: the graph database handles path discovery, and the relational database manages ratio calculation and result persistence.

3. Path Traversal and Ratio Calculation Implementation

The two core actions in equity penetration calculation are path enumeration and ratio multiplication.

Taking upward penetration as an example, suppose we want to start from a target enterprise and find all natural persons or ultimate controlling entities whose shareholding ratio exceeds a threshold. The calculation logic can be summarized as:

1. Start from the target node and find all direct shareholders.
2. For each direct shareholder, record their shareholding ratio.
3. Continue to find the shareholders of these shareholders, forming a multi-level path.
4. Multiply the shareholding ratios along each path to obtain the final equity ratio for that path.
5. Add up the equity ratios of the same ultimate beneficiary across different paths to get the total equity.

This can be represented by the following pseudocode:

function upward_penetration(target_node, depth):
    results = []
    stack = [(target_node, 1.0, 0)]
    while stack is not empty:
        node, cumulative_ratio, level = stack.pop()
        if level > depth:
            continue
        for relation in get_shareholders(node):
            new_ratio = cumulative_ratio * relation.ratio
            results.append((relation.src_node, new_ratio, level + 1))
            stack.append((relation.src_node, new_ratio, level + 1))
    return aggregate_by_node(results)

It is worth noting that cyclic structures may exist in real-world shareholding relationships. For example, A holds B, B holds C, and C inversely holds A. If path enumeration does not perform cycle detection, it will lead to an infinite loop. Therefore, the implementation must maintain a visited node set or limit the maximum penetration depth. Generally, regulatory penetration focuses on three to five layers, but the technical implementation should support more flexible depth configurations.

Another easily overlooked issue is ratio zeroing and threshold filtering. Certain indirect shareholding ratios may be extremely low, such as falling below one ten-thousandth after five layers of multiplication. Although mathematically existent, these results are typically not considered in business judgments. It is recommended to set a minimum cumulative ratio threshold during calculation to prune paths below the threshold early, reducing computation load and improving result interpretability.

4. From Single-Node Penetration to Batch Computing

In enterprise scenarios, it is often necessary to perform equity penetration analysis on thousands of enterprises simultaneously. The efficiency of single-node computation cannot meet the demand, requiring the introduction of graph computing frameworks or distributed computing capabilities.

Batch penetration can be split into two stages. The first stage is the preprocessing of the relationship graph, including data cleaning, deduplication, missing ratio completion, and invalid edge removal. The second stage is batch path calculation, which can adopt the following approaches:

• Convert the equity relationship graph into an adjacency list and split tasks by connected components;
• Execute multi-source traversal for each connected component separately to avoid redundant calculations;
• Use iterative graph algorithms, such as multi-round aggregation and message passing, to gradually calculate the final beneficiary set for each node;
• Write intermediate results to columnar storage or wide tables for subsequent querying and display.

A common engineering optimization is to pre-calculate direct shareholders and total shareholding ratios, and persist the results. This allows intermediate results to be reused across multiple penetration requests, avoiding traversing from raw data every time. For example:

precompute_summary(node):
    direct_shareholders = group_relations(node)
    indirect_shareholders = iterative_traverse(node)
    return merge(direct_shareholders, indirect_shareholders)

5. Common Engineering Challenges in Equity Penetration

Beyond path calculation itself, equity penetration projects face several engineering-level challenges.

First is data quality. Business registration data often suffers from inconsistent shareholder names, indistinguishable natural persons with the same name, missing historical evolution data, and empty or non-standardized ratio fields. Data cleaning needs to combine unique entity identifiers, historical change records, and external validation rules to minimize mismatch rates. For natural person shareholders, a name alone is insufficient to confirm a unique identity; more auxiliary information must be introduced for entity alignment.

Second is the temporal issue of dynamic equity. Corporate equity structures change over time, and penetration results at different time nodes may be completely different. Therefore, the system must support historical traceback based on registration or change dates, rather than only storing currently valid relationships. An incremental update mechanism must also be designed to ensure that affected subgraphs can be quickly recalculated when new data arrives.

Third is result interpretability. If a penetration result only provides a string of numbers and paths, it is difficult for business users to judge its reliability. An excellent implementation should attach path details, ratio calculation processes, data sources, and update times to the results, allowing users to verify layer by layer.

6. Integration with Cloud Data Capabilities

In a cloud environment, building an equity penetration system can leverage a variety of general data services. The storage and querying of relationship graphs can utilize graph databases or distributed relational databases; batch path calculation can be combined with batch computing engines and containerized task scheduling; data ingestion and cleaning can rely on data integration, data development, and data quality platforms; final results can be presented as tree diagrams, Sankey diagrams, or hierarchical lists via visualization components.

Such systems emphasize the synergy of three phases: data integration, graph computing, and visualization. Data integration solves multi-source heterogeneous problems; graph computing solves path and ratio problems; visualization solves business understanding problems. Together, they form a complete equity penetration analysis capability, rather than just a single database or algorithm.

In summary, equity penetration is fundamentally a combined problem of data modeling, graph traversal, and ratio aggregation. For developers, mastering its modeling approach and calculation methods is more important than relying on a specific product. By rationally designing relationship structures, controlling traversal depth, optimizing batch computing, and fully considering data quality and historical temporal factors, it is possible to build a stable, interpretable, and scalable corporate equity analysis solution.