babylon.engine.dialectics.volume_3

Capital Volume III dialectics — backward-compatibility re-export shim.

Deprecated since version Import: directly from the individual modules instead: babylon.engine.dialectics.surplus_distribution, babylon.engine.dialectics.trpf, etc.

class babylon.engine.dialectics.volume_3.CoreEconomy(**data)[source]

Bases: BaseModel

Pole A for the Imperial dialectic — core / imperialist side.

Parameters:
core_wages

Wages paid to core workers (Wc).

value_produced

Value produced by core workers (Vc).

profit_rate

Core industrial profit rate.

model_config: ClassVar[ConfigDict] = {'frozen': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

core_wages: float
value_produced: float
profit_rate: float
class babylon.engine.dialectics.volume_3.CreditDialectic(**data)[source]

Bases: Dialectic[CreditPole, FictitiousCapitalStock]

Real Capital ↔ Fictitious Capital.

Pole A holds the real capital stock and industrial profit rate. Pole B holds the accumulated fictitious capital claims via the FictitiousCapitalStock from economics.credit.types.

Weight semantics:

< 0: Real capital dominates (healthy production). > 0: Fictitious capital dominates (financialization).

Motion law:

Reads upstream credit growth and default rates. Weight tracks the financialization index mapped to [-1, 1].

Sublation:

When financialization index exceeds FINANCIALIZATION_BUBBLE (3.5), sublates to FinancialCrisisDialectic.

Parameters:
model_config: ClassVar[ConfigDict] = {'frozen': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

observe()[source]

Project credit system state.

Return type:

dict[str, Any]

Returns:

Observation dict with financialization index, total claims, profit rate.

step(inputs, world)[source]

Motion law T for credit dynamics.

Parameters:

  • inputs (TickInputs) – Upstream outputs. Looks for credit_growth, default_rate.

  • world (WorldView) – Read-only world context.

Return type:

CreditDialectic

Returns:

New CreditDialectic with updated fictitious capital and weight.

sublate()[source]

Sublate to financial crisis when overaccumulation exceeds threshold.

Return type:

Dialectic[Any, Any] | None

Returns:

FinancialCrisisDialectic if financialization > BUBBLE threshold.

type_tag: str
id: UUID
pole_a: A
pole_b: B
weight: float
parent_id: UUID | None
tick_created: int
tick_updated: int
class babylon.engine.dialectics.volume_3.CreditPole(**data)[source]

Bases: BaseModel

Pole A for the Credit dialectic — real capital side.

Parameters:
total_real_capital

Accumulated real capital stock K.

profit_rate

Industrial profit rate.

gdp

Real GDP for financialization ratio computation.

model_config: ClassVar[ConfigDict] = {'frozen': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

total_real_capital: float
profit_rate: float
gdp: float
class babylon.engine.dialectics.volume_3.DebtSpiralCrisisDialectic(**data)[source]

Bases: Dialectic[EmptyPole, EmptyPole]

Crisis dialectic produced when financial claims exceed surplus.

Produced by SurplusDistributionDialectic.sublate() when interest + rent + taxes > total surplus (FR-016).

The debt spiral is self-reinforcing: unpaid interest accrues as new debt, which increases interest obligations, which further exceeds surplus. Resolution requires either devaluation of claims (crisis/default) or dramatic increase in surplus (impossible under TRPF conditions).

Parameters:
model_config: ClassVar[ConfigDict] = {'frozen': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

step(_inputs, world)[source]

Crisis persistence — debt spiral deepens or resolves.

Parameters:

  • _inputs (TickInputs) – Upstream outputs (currently unused).

  • world (WorldView) – Read-only world context.

Return type:

DebtSpiralCrisisDialectic

Returns:

Updated crisis dialectic with new tick.

type_tag: str
id: UUID
pole_a: A
pole_b: B
weight: float
parent_id: UUID | None
tick_created: int
tick_updated: int
class babylon.engine.dialectics.volume_3.FinancialCrisisDialectic(**data)[source]

Bases: Dialectic[EmptyPole, EmptyPole]

Crisis dialectic produced when fictitious capital overaccumulates.

Produced by CreditDialectic.sublate() when the financialization index exceeds FINANCIALIZATION_BUBBLE (3.5).

Marx’s insight: crisis appears as a money/credit crisis but the underlying cause is overproduction relative to profitable realization. The credit system delays but ultimately amplifies crisis.

Parameters:
model_config: ClassVar[ConfigDict] = {'frozen': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

step(_inputs, world)[source]

Crisis persistence — financial crisis deepens or resolves.

Parameters:

  • _inputs (TickInputs) – Upstream outputs (currently unused).

  • world (WorldView) – Read-only world context.

Return type:

FinancialCrisisDialectic

Returns:

Updated crisis dialectic with new tick.

type_tag: str
id: UUID
pole_a: A
pole_b: B
weight: float
parent_id: UUID | None
tick_created: int
tick_updated: int
class babylon.engine.dialectics.volume_3.ImperialDialectic(**data)[source]

Bases: Dialectic[CoreEconomy, PeripheryEconomy]

Core ↔ Periphery — the Fundamental Theorem of MLM-TW.

Pole A is the imperialist core. Pole B is the exploited periphery. Imperial Rent Phi is now computed structurally from the production chain.

Weight semantics:

< 0: Core extracts freely (labor aristocracy bribed, periphery suppressed). > 0: Periphery resists (decolonization, rising consciousness).

Motion law:

Reads upstream matrix updates (DecomposedFlow) and computes rent structurally via ProductionChainRentCalculator, or falls back to scalar defaults. Weight derived from deviation of LAR from unity.

Invariant:

Imperial rent Phi >= 0 (core always extracts from periphery).

Parameters:
invariants()[source]

Verify invariants.

Return type:

list[str]

Returns:

List of violation descriptions.

model_config: ClassVar[ConfigDict] = {'frozen': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

observe()[source]

Project imperial rent state.

Return type:

dict[str, Any]

Returns:

Observation dict with Phi, LAR, extraction parameters.

step(inputs, world)[source]

Motion law T for imperial dynamics.

Parameters:

  • inputs (TickInputs) – Upstream outputs. Looks for extraction_boost.

  • world (WorldView) – Read-only world context.

Return type:

ImperialDialectic

Returns:

New ImperialDialectic with updated poles and weight.

type_tag: str
id: UUID
pole_a: A
pole_b: B
weight: float
parent_id: UUID | None
tick_created: int
tick_updated: int
class babylon.engine.dialectics.volume_3.PeripheryEconomy(**data)[source]

Bases: BaseModel

Pole B for the Imperial dialectic — periphery / exploited side.

Parameters:
periphery_wages_ratio

w_core / w_periphery ratio.

extraction_rate

Imperial extraction efficiency alpha [0, 1].

consciousness

Periphery resistance level Psi_p [0, 1].

model_config: ClassVar[ConfigDict] = {'frozen': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

periphery_wages_ratio: float
extraction_rate: float
consciousness: float
class babylon.engine.dialectics.volume_3.ProfitRateState(**data)[source]

Bases: BaseModel

Pole A for the TRPF dialectic.

Parameters:
profit_rate

Current average rate of profit.

profit_rate_trend

Year-over-year change in profit rate.

organic_composition

c/v ratio (OCC).

model_config: ClassVar[ConfigDict] = {'frozen': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

profit_rate: float
profit_rate_trend: float
organic_composition: float
class babylon.engine.dialectics.volume_3.RentDialectic(**data)[source]

Bases: Dialectic[RentPole, EmptyPole]

Ground Rent extraction — Absolute ↔ Differential.

Pole A holds the three-category rent decomposition (agricultural, resource, urban) from economics.rent.types.

Weight semantics:

< 0: Rent is a minor claims category (small rentier share). > 0: Rent dominates surplus distribution (rentier economy).

Motion law:

Reads upstream total_surplus to compute rentier share. Weight = 2 * (rent_share) - 1, clamped to [-1, 1].

Parameters:
invariants()[source]

Verify rent components are non-negative.

Return type:

list[str]

Returns:

List of violation descriptions.

model_config: ClassVar[ConfigDict] = {'frozen': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

observe()[source]

Project rent extraction state.

Return type:

dict[str, Any]

Returns:

Observation dict with rent categories and total.

step(inputs, world)[source]

Motion law T for rent dynamics.

Parameters:

  • inputs (TickInputs) – Upstream outputs. Looks for total_surplus.

  • world (WorldView) – Read-only world context.

Return type:

RentDialectic

Returns:

New RentDialectic with updated weight.

type_tag: str
id: UUID
pole_a: A
pole_b: B
weight: float
parent_id: UUID | None
tick_created: int
tick_updated: int
class babylon.engine.dialectics.volume_3.RentPole(**data)[source]

Bases: BaseModel

Pole A for the Rent dialectic — three-category decomposition.

Reimplements the three-category rent aggregation from economics.rent.types.RentExtraction. The formula total_rent = agri + resource + urban is identical. This is intentional: the dialectic receives pre-aggregated county-level data and does not perform data-source lookups.

See also

babylon.economics.rent.types.RentExtraction

Parameters:
agricultural_rent

Rent from farming / rural land.

resource_rent

Rent from extractive industries.

urban_rent

Rent from urban / building-site monopoly.

model_config: ClassVar[ConfigDict] = {'frozen': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

property total_rent: float

Total ground rent across all categories.

agricultural_rent: float
resource_rent: float
urban_rent: float
class babylon.engine.dialectics.volume_3.SurplusDistributionDialectic(**data)[source]

Bases: Dialectic[SurplusDistributionPole, EmptyPole]

Surplus Value Distribution — s = p + i + r + t.

Named “Distribution” rather than “Transformation” to distinguish this from the value → price transformation problem (V3 Ch9-10), which is out of scope (spec 024, Assumptions). This dialectic models how total surplus decomposes into competing revenue claims.

Pole A stores the s = p + i + r + t decomposition. Weight tracks the share of surplus retained by industrial capital (enterprise profit) versus claims by money-capital (interest), landed capital (rent), and the state (taxes).

Weight semantics:

< 0: Enterprise profit dominates (healthy accumulation). > 0: Claimants dominate (profit squeeze / debt spiral).

Motion law:

Reads upstream interest rate changes and recomputes the distribution. Weight shifts toward +1 as claims crowd out enterprise profit.

Sublation:

When claims_exceed_surplus is True, sublates to DebtSpiralCrisisDialectic.

Parameters:
invariants()[source]

Verify accounting identity: s = p + i + r + t.

Return type:

list[str]

Returns:

List of violation descriptions.

model_config: ClassVar[ConfigDict] = {'frozen': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

observe()[source]

Project surplus distribution state.

Return type:

dict[str, Any]

Returns:

Observation dict with s, p, i, r, t components.

step(inputs, world)[source]

Motion law T for surplus value distribution.

Parameters:

  • inputs (TickInputs) – Upstream outputs. Looks for own id’s entry with interest_rate_increase (float).

  • world (WorldView) – Read-only world context.

Return type:

SurplusDistributionDialectic

Returns:

New SurplusDistributionDialectic with updated weight and poles.

sublate()[source]

Sublate to debt spiral when claims exceed surplus (FR-016).

Return type:

Dialectic[Any, Any] | None

Returns:

DebtSpiralCrisisDialectic if claims exceed surplus, else None.

type_tag: str
id: UUID
pole_a: A
pole_b: B
weight: float
parent_id: UUID | None
tick_created: int
tick_updated: int
class babylon.engine.dialectics.volume_3.SurplusDistributionPole(**data)[source]

Bases: BaseModel

Pole A for the Distribution dialectic.

Reimplements the surplus value distribution identity from economics.distribution.SurplusValueDistribution for the dialectic layer. The formula p = s - i - r - t is identical to SurplusValueDistribution.profit_of_enterprise. This is intentional: the dialectic receives pre-computed distribution inputs and does not perform data-source lookups.

See also

babylon.economics.distribution.types.SurplusValueDistribution

Parameters:
total_surplus

Total surplus value produced (s).

interest_payments

Interest claim on surplus (i).

ground_rent

Ground rent claim on surplus (r).

taxes

Tax claim on surplus (t).

property claims_exceed_surplus: bool

Whether claims exceed total surplus (FR-016).

model_config: ClassVar[ConfigDict] = {'frozen': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

property profit_of_enterprise: float

p = s - i - r - t.

Type:

Residual

total_surplus: float
interest_payments: float
ground_rent: float
taxes: float
class babylon.engine.dialectics.volume_3.TRPFDialectic(**data)[source]

Bases: Dialectic[ProfitRateState, CounterTendencyStrength]

Tendency of the Rate of Profit to Fall ↔ Counteracting Tendencies.

Pole A holds the tendency (profit rate trajectory). Pole B holds the counter-tendency vector from economics.counter_tendencies.

Weight semantics:

< 0: TRPF dominating (profit rate falling, counter-tendencies weak). > 0: Counter-tendencies dominating (profit rate sustained).

Motion law:

Reads upstream OCC and exploitation rate changes, delegates to CounterTendencyStrength.net_counter_tendency for weight.

No sublation: TRPF is a structural tendency, not an event.

Parameters:
model_config: ClassVar[ConfigDict] = {'frozen': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

observe()[source]

Project TRPF state for downstream consumers.

Return type:

dict[str, Any]

Returns:

Observation dict with profit rate, OCC, net counter-tendency.

step(inputs, world)[source]

Motion law T for TRPF dynamics.

Parameters:

  • inputs (TickInputs) – Upstream outputs. Looks for occ, exploitation_rate.

  • world (WorldView) – Read-only world context.

Return type:

TRPFDialectic

Returns:

New TRPFDialectic with updated weight and poles.

type_tag: str
id: UUID
pole_a: A
pole_b: B
weight: float
parent_id: UUID | None
tick_created: int
tick_updated: int