<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
 def reduce(self, mapped_props, aggregated, value_type, visitor):
 """This reduction is called to combine the mapped slot and collection item values into a single value for return. The default implementation tries to behave naturally; you'll almost always get a dict back when mapping over a record, and list or some other collection when mapping over collections. If the collection has additional properties which are not ignored (eg, not extraneous, not filtered), then the result will be a dictionary with the results of mapping the properties, and a 'values' key will be added with the result of mapping the items in the collection. args: ``mapped_props=``\ *generator* Iterating over this generator will yield K, V pairs, where K is **the Property object** and V is the mapped value. ``aggregated=``\ *object* This contains whatever ``aggregate`` returned, normally a list. ``value_type=``\ *RecordType* This is the type which is currently being reduced. A :py:class:`normalize.record.Record` subclass ``visitor=``\ *Visitor* Contenxt/options object. """

        reduced = None
        if mapped_props:
            reduced = dict((k.name, v) for k, v in mapped_props)

        if issubclass(value_type, Collection) and aggregated is not None:
            if all(visitor.is_filtered(prop) for prop in
                   value_type.properties.values()):
                reduced = aggregated
            else:
                if reduced.get("values", False):
                    raise exc.VisitorTooSimple(
                        fs=visitor.field_selector,
                        value_type_name=value_type.__name__,
                        visitor=type(self).__name__,
                    )
                else:
                    reduced['values'] = aggregated

        return reduced