CompositeNDP                                                                                               
│    provides   f   SB(≥0) │ requires   r   SB(≥0)                                                         
│  3 nodes, 3 edges                                                                                        
│   connected rec: ✓                                                                                       
│  provided f       ≤ f1 provided by a   equiv id                                                          
│  r1 required by a ≤ required r         equiv id                                                          
│  r2 required by a ≤ f2 provided by a   diff  AmbientConversion SB(≥3)  ⇸  SB(≥0)  > D                    
│                                               𝒇 ≤ 𝒓                                                      
└ CompositeNDP                                                                                             
  │    provides   f1   SB(≥0) │ requires   r1   SB(≥0)                                                     
  │    provides   f2   SB(≥0) │ requires   r2   SB(≥3)                                                     
  │  7 nodes, 6 edges                                                                                      
  │   connected rec: ✓                                                                                     
  │  provided f1              ≤ f1 provided by _sum     equiv id                                           
  │  provided f2              ≤ _op provided by _mult   equiv id                                           
  │  provided f2              ≤ required r1             equiv id                                           
  │  _res required by _mult   ≤ _res provided by _sum   equiv id                                           
  │  _res2 required by _plus  ≤ required r2             equiv id                                           
  │  _result required by _sum ≤ _op provided by _plus   equiv id                                           
  ├ _mult: SimpleWrap                                                                                      
  │        │  provides   _op   SB(≥0) │ requires   _res   SB(≥0)                                           
  │        └ DP_L_UME SB(≥0)  ⇸  SB(≥0)                                                                    
  │           𝒇 ⋅ 0.7 ≤ 𝒓                                                                                  
  │          M_C_WrapUnits   dimensionless → dimensionless > M_A_Mult1_Upper   SB(≥0)  →   same x ⟼ x ⋅ 0.7
  ├ _plus: SimpleWrap                                                                                      
  │        │  provides   _op   SB(≥0) │ requires   _res2   SB(≥3)                                          
  │        └ DP_L_UME SB(≥0)  ⇸  SB(≥3)                                                                    
  │           𝒇 + 3 ≤ 𝒓                                                                                    
  │          M_C_WrapUnits   dimensionless → dimensionless > M_A_Add1_Upper   SB(≥0)  →  SB(≥3) x ⟼ x + 3  
  └  _sum: SimpleWrap                                                                                      
           │  provides   _res   SB(≥0) │ requires   _result   SB(≥0)                                       
           │  provides   f1     SB(≥0) │                                                                   
           └ M_Res_AddMany_DP WU ⟨dimensionless,dimensionless⟩  ⇸  SB(≥0)                                  
                              (SB(≥0)×SB(≥0))                                                              
              𝒇₁ + 𝒇₂ ≤ 𝒓                                                                                  
             ├      Fs: ├ SB(≥0)                                                                           
             │          └ SB(≥0)                                                                           
             ├ opspace: SB(≥0)                                                                             
             └    algo: ApproximationAlgorithms - ApproximationAlgorithms.VAN_DER_CORPUT