Index: FluentNHibernate.Testing/AutoMap/AutoMapTests.cs
===================================================================
--- FluentNHibernate.Testing/AutoMap/AutoMapTests.cs	(revision 144)
+++ FluentNHibernate.Testing/AutoMap/AutoMapTests.cs	(working copy)
@@ -102,6 +102,39 @@
         }
 
         [Test]
+        public void AutoMapManyToMany_WillMapBothSidesToSameTable()
+        {
+            var autoMapper = new AutoMapper(new Conventions());
+            var map1 = autoMapper.Map<ManyToMany1>();
+            var map2 = autoMapper.Map<ManyToMany2>();
+
+            var document1 = map1.CreateMapping(new MappingVisitor());
+            var document2 = map2.CreateMapping(new MappingVisitor());
+
+            var keyElement1 = (XmlElement)document1.DocumentElement.SelectSingleNode("//set");
+            keyElement1.AttributeShouldEqual("table", "ManyToMany2ToManyToMany1");
+            var keyElement2 = (XmlElement)document2.DocumentElement.SelectSingleNode("//set");
+            keyElement2.AttributeShouldEqual("table", "ManyToMany2ToManyToMany1");
+        }
+
+        [Test]
+        public void AutoMapManyToMany_WillSetChildSideToBeInverse()
+        {
+            var autoMapper = new AutoMapper(new Conventions());
+            var map1 = autoMapper.Map<ManyToMany1>();
+            var map2 = autoMapper.Map<ManyToMany2>();
+
+            var document1 = map1.CreateMapping(new MappingVisitor());
+            var document2 = map2.CreateMapping(new MappingVisitor());
+
+            var keyElement1 = (XmlElement)document1.DocumentElement.SelectSingleNode("//set");
+            keyElement1.AttributeShouldEqual("inverse", "");
+            var keyElement2 = (XmlElement)document2.DocumentElement.SelectSingleNode("//set");
+            keyElement2.AttributeShouldEqual("inverse", "true");
+        }
+
+
+        [Test]
         public void AutoMapManyToMany_ShouldRecognizeSet_BaseOnType()
         {
             var autoMapper = new AutoMapper(new Conventions());
Index: FluentNHibernate/AutoMap/AutoMapper.cs
===================================================================
--- FluentNHibernate/AutoMap/AutoMapper.cs	(revision 144)
+++ FluentNHibernate/AutoMap/AutoMapper.cs	(working copy)
@@ -17,7 +17,7 @@
                                     new AutoMapIdentity(conventions), 
                                     new AutoMapVersion(conventions), 
                                     new AutoMapColumn(conventions),
-                                    new ManyToManyAutoMapper(),
+                                    new ManyToManyAutoMapper(conventions),
                                     new AutoMapManyToOne(),
                                     new AutoMapOneToMany(),
                                 };
Index: FluentNHibernate/AutoMap/ManyToManyAutoMapper.cs
===================================================================
--- FluentNHibernate/AutoMap/ManyToManyAutoMapper.cs	(revision 144)
+++ FluentNHibernate/AutoMap/ManyToManyAutoMapper.cs	(working copy)
@@ -7,6 +7,13 @@
 {
     public class ManyToManyAutoMapper : IAutoMapper
     {
+        private readonly Conventions conventions;
+
+        public ManyToManyAutoMapper(Conventions conventions)
+        {
+            this.conventions = conventions;
+        }
+
         public bool MapsProperty(PropertyInfo property)
         {
             var type = property.PropertyType;
@@ -14,23 +21,41 @@
                 type.Namespace != "System.Collections.Generic")
                 return false;
 
+            var hasInverse = GetInverseProperty(property) != null;
+            return hasInverse;
+        }
+
+        private PropertyInfo GetInverseProperty(PropertyInfo property)
+        {
+            Type type = property.PropertyType;
             var inverseSide = type.GetGenericTypeDefinition()
                 .MakeGenericType(property.DeclaringType);
 
             var argument = type.GetGenericArguments()[0];
-            var hasInverse = argument.GetProperties()
-                                 .Where(x => x.PropertyType == inverseSide)
-                                 .Count() > 0;
-            return hasInverse;
+            return argument.GetProperties()
+                .Where(x => x.PropertyType == inverseSide)
+                .FirstOrDefault();
         }
 
         public void Map<T>(AutoMap<T> classMap, PropertyInfo property)
         {
+            PropertyInfo inverseProperty = GetInverseProperty(property);
+
+            Type parentSide = conventions.GetParentSideForManyToMany(property.DeclaringType, inverseProperty.DeclaringType);
+
             var classMapType = typeof(ClassMap<T>);
             var hasManyMethod = classMapType.GetMethod("HasManyToMany");
             var listType = property.PropertyType.GetGenericArguments()[0];
             var genericHasManyMethod = hasManyMethod.MakeGenericMethod(listType);
-            genericHasManyMethod.Invoke(classMap, new object[] { ExpressionBuilder.Create<T>(property) });
+            object manyToManyPart = genericHasManyMethod.Invoke(classMap, new object[] { ExpressionBuilder.Create<T>(property) });
+
+            if (parentSide != property.DeclaringType)//inverse
+            {
+                string manyTableName = conventions.GetManyToManyTableName(property.DeclaringType, parentSide);
+                Type type = manyToManyPart.GetType();
+                type.GetMethod("IsInverse").Invoke(manyToManyPart, new object[0]);
+                type.GetMethod("WithTableName").Invoke(manyToManyPart, new object[] { manyTableName, });
+            }
         }
     }
 }
Index: FluentNHibernate/Conventions.cs
===================================================================
--- FluentNHibernate/Conventions.cs	(revision 144)
+++ FluentNHibernate/Conventions.cs	(working copy)
@@ -44,6 +44,9 @@
             AddTypeConvention(new EnumerationTypeConvention());
         }
 
+        public Func<Type, Type, Type> GetParentSideForManyToMany = (one, two) =>
+            one.FullName.CompareTo(two.FullName) < 0 ? one : two;
+
         public Func<Type, string> GetTableName = prop => String.Format("[{0}]", prop.Name);
         public Func<PropertyInfo, string> GetPrimaryKeyName = prop => prop.Name;
         public Func<PropertyInfo, string> GetForeignKeyName = prop => prop.Name + "_id";
