I'm trying to learn NH (ver. 3.2) and am having problems understanding some of the mapping choices. Scott Findlater has posted his fully working skeleton for sexy Loquacious NH [here](http://nhforge.org/wikis/howtonh/a-fully-working-skeleton-for-sexy-loquacious-nh.aspx) and my questions about mapping(s) will be based in his sample.
Here is the domain model (pic not part of his sample but included here for clarity):

![enter image description here](https://i.stack.imgur.com/fDUqC.jpg)

His category class looks like this:

```
public class Category : Entity
    {
        public Category()
        {
            Products = new List<Product>();
            SubCategories = new List<Category>();
        }

        public virtual string Name { get; set; }
        public virtual string Description { get; set; }
        public virtual Category Parent { get; set; }
        public virtual IEnumerable<Category> SubCategories { get; set; }
        public virtual IList<Product> Products { get; set; }
    }

```

and his mapping class like this:

```
class CategoryMap : ClassMapping<Category>
    {
        public CategoryMap()
        {
            // **************************************************
            // Mapping of Id here will take precedence over the 
            // global conventions configured in the ModelMapper.
            // **************************************************
            //Id(x => x.Id, map =>
            //{
            //    map.Column("Id");
            //    map.Generator(Generators.GuidComb);
            //});

            Property(x => x.Name, m => m.Length(450));
            Property(x => x.Description, m => m.Length(2000));

            Set(x => x.SubCategories, set =>
                                          {
                                              set.Key(k => k.Column("ParentCategoryId"));
                                              set.Inverse(true);
                                          } ,
                                       ce => ce.OneToMany());

            ManyToOne(x => x.Parent, manyToOne =>
                                         {
                                             manyToOne.Column("ParentCategoryId");
                                             manyToOne.Lazy(LazyRelation.NoLazy);
                                             manyToOne.NotNullable(false);
                                         });

            Set(x => x.Products, set =>
                                    {
                                        set.Key(key =>
                                        {
                                            key.Column("ProductId");
                                            key.ForeignKey("FK_Product_Category_ProductId");
                                        });
                                        set.Table("Product_Category");
                                    },
                                    ce => ce.ManyToMany(m => m.Column("CategoryId")));
        }
    }

```

Now, for the questions:

1) Why did he chose to map/model Parent property as ManyToOne relationship? Doesn't this suggest that Category can belong to more than one parent category, i.e. any given category (other than the root I suppose) can be spread out among many other parent categories? If so then this is not very clear from the model itself because to me the Parent (as I see it in the class definition) looks like a property of type Category and I'd map it like that. When would you chose approach in this solution v.s. mapping it as a simple property?

2) When I map files, who's (or which) perspective I should be looking from? Seems to me like this is from the inside of the class you are trying to map. So, in this case, when I'm trying map the Category class, I'm only concerned with mapping the "arrows" going out, right?

3) Person creating mapping files must have knowledge outside of what's clear just by looking at a class. Look at how Products property is mapped (ManyToMany relationship). From the class itself it's only clear that Category may belong to many Products but Category doesn't know that it may be contained in many Products. That fact is obvious for the Product class. Now that I've said that seems to me that when I create mapping file(s) I should be looking from the point of view of a class AND then a model.

4) Generally speaking: when do you use .Inverse(), .Cascade() and .Lazy()? 

5) What are the differences between mapping using ModelMapper vs ConventionModelMapper? I haven't studied files included in the same project which use the latter method but I wanted to know if there is, other than a preference, an advantage in using one over another.