One way to handle the complexity in a large system of any kind is by abstraction - the ability to suppress detail that is irrelevant at a particular level. This concept is discussed in the preceding two Views. The single managed object View describes the managed object as an abstract view of a resource or set of resources. A MIB is defined above as the set of managed objects made visible by a OS - thus, the MIB is an abstraction of the physical and logical resources that are accessible through that OS. This section discusses abstraction across multiple OSs and multiple MIBs. The abstraction provided by a managed object may consist of aggregating, summarizing, partitioning, or otherwise abstracting aspects of a set of resources. The resources that are being abstracted bay be distributed around the network, and they may themselves be represented by managed objects on the same or different OSs. This abstraction is invisible to the user of the managed object which provides the abstraction. Regardless of whether a managed object is an abstraction of other managed objects, it is fully defined at the interoperable interface by its class. One implementation of a particular class may call upon managed objects in other OSs, and another implementation of the same class may use other means to provide the required behaviour. (This mapping is a part of the management solution provided by the OS). It will often be the case that a managed object provides an abstraction of some other managed objects but appears as a single component to a manager of the object. For example, a ;SPM_quot;circuit;SPM_quot; managed object coordinates and abstracts the components that make up the circuit, but it appears to be a simple component to the manager of the circuit. As we have described, a managed system may provide a managed object in its MIB that provides an abstract view of one or more lower-level managed objects. The degenerate case of this technique is where a managed system provides an exactly identical view of a managed object on another OS (i.e. no abstraction is done). Requests relating to this managed object are simply passed on to the OS holding the other managed object. The ;SPM_quot;intermediate;SPM_quot; OS does not deal with the real resource, and does not hold attribute values. A OS may choose to allow this kind of ;SPM_quot;pass-through;SPM_quot; access to other managed objects for another entire OS. In this case, all the managed objects in the MIT of one OS will appear in the other OS's MIT. possibly as a subtree.