CompositeNDP                                                                                                                                                    
│    provides   out   WU ⟨-,-,A⟩                          │ requires   in       WU ⟨-,-,-,W⟩ > (socket:{TypeA}×voltage:{v110}×frequency:{f50}×watts:SB([0,12])) 
│                     └ Π<3>                              │ requires   budget   {10.99 USD}                                                                     
│                       ├ connector: ∑                    │                                                                                                     
│                       │            ├ ∅                  │                                                                                                     
│                       │            └ {USB_Micro_A_male} │                                                                                                     
│                       ├   voltage: {v5}                 │                                                                                                     
│                       └      amps: SB([0,2.4])          │                                                                                                     
│  14 nodes, 12 edges                                                                                                                                           
│   connected rec: ✓                                                                                                                                            
│  _c required by _c           ≤ required budget                     equiv (always satisfied)                                                                   
│  _c2 required by _c2         ≤ socket provided by _if              equiv (always satisfied)                                                                   
│  _c3 required by _c3         ≤ voltage provided by _if             equiv (always satisfied)                                                                   
│  _c4 required by _c4         ≤ frequency provided by _if           equiv (always satisfied)                                                                   
│  _l1 required by _conversion ≤ _l1 provided by _lim1               equiv (always satisfied)                                                                   
│  provided out                ≤ _muxed provided by _ir              equiv id                                                                                   
│  _muxed required by _if      ≤ required in                         equiv id                                                                                   
│  amps required by _ir        ≤ _l2 provided by _lim2               diff  (always satisfied)                                                                   
│  amps required by _ir        ≤ _op provided by _mult               equiv id                                                                                   
│  connector required by _ir   ≤ connector provided by _conversion   equiv (always satisfied)                                                                   
│  voltage required by _ir     ≤ _l provided by _lim                 equiv (always satisfied)                                                                   
│  _res required by _mult      ≤ watts provided by _if               equiv id                                                                                   
├          _c: SimpleWrap                                                                                                                                       
│              │  - │ requires   _c   {10.99 USD}                                                                                                               
│              └ DP_Constant 𝟙  ⇸  {10.99 USD}                                                                                                                  
│                 10.99 USD ≤ 𝒓                                                                                                                                 
├         _c2: SimpleWrap                                                                                                                                       
│              │  - │ requires   _c2   {TypeA}                                                                                                                  
│              └ DP_Constant 𝟙  ⇸  {TypeA}                                                                                                                      
│                 TypeA ≤ 𝒓                                                                                                                                     
├         _c3: SimpleWrap                                                                                                                                       
│              │  - │ requires   _c3   {v110}                                                                                                                   
│              └ DP_Constant 𝟙  ⇸  {v110}                                                                                                                       
│                 v110 ≤ 𝒓                                                                                                                                      
├         _c4: SimpleWrap                                                                                                                                       
│              │  - │ requires   _c4   {f50}                                                                                                                    
│              └ DP_Constant 𝟙  ⇸  {f50}                                                                                                                        
│                 f50 ≤ 𝒓                                                                                                                                       
├ _conversion: SimpleWrap                                                                                                                                       
│              │  provides   connector   ∑                    │ requires   _l1   {USB_Micro_A_male}                                                             
│              │                         ├ ∅                  │                                                                                                 
│              │                         └ {USB_Micro_A_male} │                                                                                                 
│              └ DP_True ∑                     ⇸  {USB_Micro_A_male} val = * > ()                                                                               
│                        ├ ∅                                                                                                                                    
│                        └ {USB_Micro_A_male}                                                                                                                   
│                 true                                                                                                                                          
├         _if: SimpleWrap                                                                                                                                       
│              │  provides   socket      {TypeA}      │ requires   _muxed   WU ⟨-,-,-,W⟩ > (socket:{TypeA}×voltage:{v110}×frequency:{f50}×watts:SB([0,12]))     
│              │  provides   voltage     {v110}       │                                                                                                         
│              │  provides   frequency   {f50}        │                                                                                                         
│              │  provides   watts       SB([0,12]) W │                                                                                                         
│              └ DP_Id WU ⟨-,-,-,W⟩                ⇸  WU ⟨-,-,-,W⟩                                                                                              
│                      └ Π<4>                         └ Π<4>                                                                                                    
│                        ├    socket: {TypeA}           ├    socket: {TypeA}                                                                                    
│                        ├   voltage: {v110}            ├   voltage: {v110}                                                                                     
│                        ├ frequency: {f50}             ├ frequency: {f50}                                                                                      
│                        └     watts: SB([0,12])        └     watts: SB([0,12])                                                                                 
│                 𝒇 ≤ 𝒓                                                                                                                                         
├         _ir: SimpleWrap                                                                                                                                       
│              │  provides   _muxed   WU ⟨-,-,A⟩                          │ requires   connector   ∑                                                            
│              │                      └ Π<3>                              │                        ├ ∅                                                          
│              │                        ├ connector: ∑                    │                        └ {USB_Micro_A_male}                                         
│              │                        │            ├ ∅                  │ requires   voltage     {v5}                                                         
│              │                        │            └ {USB_Micro_A_male} │ requires   amps        SB([0,2.4]) A                                                
│              │                        ├   voltage: {v5}                 │                                                                                     
│              │                        └      amps: SB([0,2.4])          │                                                                                     
│              └ DP_Id WU ⟨-,-,A⟩                           ⇸  WU ⟨-,-,A⟩                                                                                       
│                      └ Π<3>                                  └ Π<3>                                                                                           
│                        ├ connector: ∑                          ├ connector: ∑                                                                                 
│                        │            ├ ∅                        │            ├ ∅                                                                               
│                        │            └ {USB_Micro_A_male}       │            └ {USB_Micro_A_male}                                                              
│                        ├   voltage: {v5}                       ├   voltage: {v5}                                                                              
│                        └      amps: SB([0,2.4])                └      amps: SB([0,2.4])                                                                       
│                 𝒇 ≤ 𝒓                                                                                                                                         
├        _lim: SimpleWrap                                                                                                                                       
│              │  provides   _l   {v5} │ -                                                                                                                      
│              └ DP_Limit {v5}  ⇸  𝟙  > VU:v5                                                                                                                   
│                 𝒇 ≤ v5                                                                                                                                        
├       _lim1: SimpleWrap                                                                                                                                       
│              │  provides   _l1   {USB_Micro_A_male} │ -                                                                                                       
│              └ DP_Limit {USB_Micro_A_male}  ⇸  𝟙  > VU:USB_Micro_A_male                                                                                       
│                 𝒇 ≤ USB_Micro_A_male                                                                                                                          
├       _lim2: SimpleWrap                                                                                                                                       
│              │  provides   _l2   {2.4 A} │ -                                                                                                                  
│              └ DP_Limit {2.4 A}  ⇸  𝟙  > NVU:2.4 A                                                                                                            
│                 𝒇 ≤ 2.4 A                                                                                                                                     
└       _mult: SimpleWrap                                                                                                                                       
               │  provides   _op   SB([0,2.4]) A │ requires   _res   SB([0,12]) W                                                                               
               └ DP_L_UME SB([0,2.4]) A  ⇸  SB([0,12]) W                                                                                                        
                  𝒇 ⋅ 5 ≤ 𝒓                                                                                                                                     
                 M_C_WrapUnits   A → W > M_A_Mult1_Upper   SB([0,2.4])  →  SB([0,12]) x ⟼ x ⋅ 5