Index: branches/DataAnalysis Refactoring/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/SymbolicExpressionGrammarBase.cs
===================================================================
--- branches/DataAnalysis Refactoring/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/SymbolicExpressionGrammarBase.cs	(revision 5699)
+++ branches/DataAnalysis Refactoring/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/SymbolicExpressionGrammarBase.cs	(revision 5712)
@@ -51,5 +51,5 @@
     [Storable(Name = "AllowedChildSymbols")]
     private IEnumerable<KeyValuePair<ISymbol, IEnumerable<ISymbol>>> StorableAllowedChildSymbols {
-      get { return allowedChildSymbols.Select(x => new KeyValuePair<ISymbol, IEnumerable<ISymbol>>(GetSymbol(x.Key), x.Value.Select(y => GetSymbol(y)))).ToArray(); ; }
+      get { return allowedChildSymbols.Select(x => new KeyValuePair<ISymbol, IEnumerable<ISymbol>>(GetSymbol(x.Key), x.Value.Select(y => GetSymbol(y)).ToArray())).ToArray(); }
       set { allowedChildSymbols = value.ToDictionary(x => x.Key.Name, x => x.Value.Select(y => y.Name).ToList()); }
     }
@@ -57,5 +57,5 @@
     [Storable(Name = "AllowedChildSymbolsPerIndex")]
     private IEnumerable<KeyValuePair<Tuple<ISymbol, int>, IEnumerable<ISymbol>>> StorableAllowedChildSymbolsPerIndex {
-      get { return allowedChildSymbolsPerIndex.Select(x => new KeyValuePair<Tuple<ISymbol, int>, IEnumerable<ISymbol>>(Tuple.Create(GetSymbol(x.Key.Item1), x.Key.Item2), x.Value.Select(y => GetSymbol(y)))).ToArray(); }
+      get { return allowedChildSymbolsPerIndex.Select(x => new KeyValuePair<Tuple<ISymbol, int>, IEnumerable<ISymbol>>(Tuple.Create<ISymbol, int>(GetSymbol(x.Key.Item1), x.Key.Item2), x.Value.Select(y => GetSymbol(y)).ToArray())).ToArray(); }
       set { allowedChildSymbolsPerIndex = value.ToDictionary(x => Tuple.Create(x.Key.Item1.Name, x.Key.Item2), x => x.Value.Select(y => y.Name).ToList()); }
     }
Index: branches/DataAnalysis Refactoring/HeuristicLab.Persistence/3.3/Default/CompositeSerializers/TupleSerializer.cs
===================================================================
--- branches/DataAnalysis Refactoring/HeuristicLab.Persistence/3.3/Default/CompositeSerializers/TupleSerializer.cs	(revision 5712)
+++ branches/DataAnalysis Refactoring/HeuristicLab.Persistence/3.3/Default/CompositeSerializers/TupleSerializer.cs	(revision 5712)
@@ -0,0 +1,97 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2011 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Reflection;
+using HeuristicLab.Persistence.Core;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Persistence.Interfaces;
+
+namespace HeuristicLab.Persistence.Default.CompositeSerializers {
+
+  [StorableClass]
+  internal sealed class TupleSerializer : ICompositeSerializer {
+
+    [StorableConstructor]
+    private TupleSerializer(bool deserializing) { }
+    public TupleSerializer() { }
+
+    public int Priority {
+      get { return 50; }
+    }
+
+    public bool CanSerialize(Type type) {
+      if (!type.IsGenericType)
+        return false;
+      Type t = type.GetGenericTypeDefinition();
+      return t == typeof(Tuple<>) ||
+        t == typeof(Tuple<,>) ||
+        t == typeof(Tuple<,,>) ||
+        t == typeof(Tuple<,,,>) ||
+        t == typeof(Tuple<,,,,>) ||
+        t == typeof(Tuple<,,,,,>) ||
+        t == typeof(Tuple<,,,,,,>) ||
+        t == typeof(Tuple<,,,,,,,>);
+    }
+
+    public string JustifyRejection(Type type) {
+      if (!type.IsGenericType)
+        return "not a generic type";
+      return "type is not a tuple type";
+    }
+
+    public IEnumerable<Tag> CreateMetaInfo(object obj) {
+      Type t = obj.GetType();
+      for (int i = 1; i <= t.GetGenericArguments().Length; i++) {
+        string name = string.Format("Item{0}", i);
+        yield return new Tag(name, t.GetProperty(name).GetValue(obj, null));
+      }
+    }
+
+    public IEnumerable<Tag> Decompose(object obj) {
+      return null;
+    }
+
+    private static BindingFlags public_static = BindingFlags.Public | BindingFlags.Static;
+
+    private static MethodInfo[] CreateMethods = new MethodInfo[8];
+
+    static TupleSerializer() {
+      foreach (MethodInfo mi in typeof(Tuple).GetMethods(public_static).Where(mi => mi.Name == "Create")) {
+        CreateMethods[mi.GetGenericArguments().Length - 1] = mi;
+      }
+    }
+
+    public object CreateInstance(Type type, IEnumerable<Tag> metaInfo) {
+      var values = metaInfo.Select(t => t.Value).ToArray();
+
+      MethodInfo createMethod = CreateMethods[values.Length - 1].MakeGenericMethod(type.GetGenericArguments());
+      return createMethod.Invoke(null, values.ToArray());
+    }
+
+    public void Populate(object instance, IEnumerable<Tag> tags, Type type) {
+      // nothing to do
+    }
+
+  }
+}
Index: branches/DataAnalysis Refactoring/HeuristicLab.Persistence/3.3/HeuristicLab.Persistence-3.3.csproj
===================================================================
--- branches/DataAnalysis Refactoring/HeuristicLab.Persistence/3.3/HeuristicLab.Persistence-3.3.csproj	(revision 5699)
+++ branches/DataAnalysis Refactoring/HeuristicLab.Persistence/3.3/HeuristicLab.Persistence-3.3.csproj	(revision 5712)
@@ -142,4 +142,5 @@
     <Compile Include="Default\CompositeSerializers\CompactNumberArray2StringSerializer.cs" />
     <Compile Include="Default\CompositeSerializers\ConcreteDictionarySerializer.cs" />
+    <Compile Include="Default\CompositeSerializers\TupleSerializer.cs" />
     <Compile Include="Default\CompositeSerializers\HashSetSerializer.cs" />
     <Compile Include="Default\CompositeSerializers\DictionarySerializer.cs" />
Index: branches/DataAnalysis Refactoring/HeuristicLab.Persistence/3.3/Tests/UseCases.cs
===================================================================
--- branches/DataAnalysis Refactoring/HeuristicLab.Persistence/3.3/Tests/UseCases.cs	(revision 5699)
+++ branches/DataAnalysis Refactoring/HeuristicLab.Persistence/3.3/Tests/UseCases.cs	(revision 5712)
@@ -1243,4 +1243,16 @@
     }
 
+    [TestMethod]
+    public void TupleTest() {
+      var t1 = Tuple.Create(1);
+      var t2 = Tuple.Create('1', "2");
+      var t3 = Tuple.Create(3.0, 3f, 5);
+      var t4 = Tuple.Create(Tuple.Create(1, 2, 3), Tuple.Create(4, 5, 6), Tuple.Create(8, 9, 10));
+      var tuple = Tuple.Create(t1, t2, t3, t4);
+      XmlGenerator.Serialize(tuple, tempFile);
+      var newTuple = XmlParser.Deserialize<Tuple<Tuple<int>, Tuple<char, string>, Tuple<double, float, int>, Tuple<Tuple<int, int, int>, Tuple<int, int, int>, Tuple<int, int, int>>>>(tempFile);
+      Assert.AreEqual(tuple, newTuple);
+    }
+
 
 
Index: branches/DataAnalysis Refactoring/HeuristicLab.Problems.ArtificialAnt/3.4/ArtificialAntProblem.cs
===================================================================
--- branches/DataAnalysis Refactoring/HeuristicLab.Problems.ArtificialAnt/3.4/ArtificialAntProblem.cs	(revision 5699)
+++ branches/DataAnalysis Refactoring/HeuristicLab.Problems.ArtificialAnt/3.4/ArtificialAntProblem.cs	(revision 5712)
@@ -105,14 +105,14 @@
     }
     public IValueParameter<IntValue> MaxExpressionLengthParameter {
-      get { return (IValueParameter<IntValue>)Parameters["MaxExpressionLength"]; }
+      get { return (IValueParameter<IntValue>)Parameters["MaximumExpressionLength"]; }
     }
     public IValueParameter<IntValue> MaxExpressionDepthParameter {
-      get { return (IValueParameter<IntValue>)Parameters["MaxExpressionDepth"]; }
+      get { return (IValueParameter<IntValue>)Parameters["MaximumExpressionDepth"]; }
     }
     public IValueParameter<IntValue> MaxFunctionDefinitionsParameter {
-      get { return (IValueParameter<IntValue>)Parameters["MaxFunctionDefinitions"]; }
+      get { return (IValueParameter<IntValue>)Parameters["MaximumFunctionDefinitions"]; }
     }
     public IValueParameter<IntValue> MaxFunctionArgumentsParameter {
-      get { return (ValueParameter<IntValue>)Parameters["MaxFunctionArguments"]; }
+      get { return (ValueParameter<IntValue>)Parameters["MaximumFunctionArguments"]; }
     }
     public IValueParameter<BoolMatrix> WorldParameter {
@@ -120,5 +120,5 @@
     }
     public IValueParameter<IntValue> MaxTimeStepsParameter {
-      get { return (IValueParameter<IntValue>)Parameters["MaxTimeSteps"]; }
+      get { return (IValueParameter<IntValue>)Parameters["MaximumTimeSteps"]; }
     }
 
@@ -215,11 +215,11 @@
       Parameters.Add(new ValueParameter<Evaluator>("Evaluator", "The operator which should be used to evaluate artificial ant solutions.", evaluator));
       Parameters.Add(new ValueParameter<DoubleValue>("BestKnownQuality", "The quality of the best known solution of this artificial ant instance.", new DoubleValue(89)));
-      Parameters.Add(new ValueParameter<IntValue>("MaxExpressionLength", "Maximal length of the expression to control the artificial ant.", new IntValue(100)));
-      Parameters.Add(new ValueParameter<IntValue>("MaxExpressionDepth", "Maximal depth of the expression to control the artificial ant.", new IntValue(10)));
-      Parameters.Add(new ValueParameter<IntValue>("MaxFunctionDefinitions", "Maximal number of automatically defined functions in the expression to control the artificial ant.", new IntValue(3)));
-      Parameters.Add(new ValueParameter<IntValue>("MaxFunctionArguments", "Maximal number of arguments of automatically defined functions in the expression to control the artificial ant.", new IntValue(3)));
+      Parameters.Add(new ValueParameter<IntValue>("MaximumExpressionLength", "Maximal length of the expression to control the artificial ant.", new IntValue(100)));
+      Parameters.Add(new ValueParameter<IntValue>("MaximumExpressionDepth", "Maximal depth of the expression to control the artificial ant.", new IntValue(10)));
+      Parameters.Add(new ValueParameter<IntValue>("MaximumFunctionDefinitions", "Maximal number of automatically defined functions in the expression to control the artificial ant.", new IntValue(3)));
+      Parameters.Add(new ValueParameter<IntValue>("MaximumFunctionArguments", "Maximal number of arguments of automatically defined functions in the expression to control the artificial ant.", new IntValue(3)));
       Parameters.Add(new ValueParameter<ISymbolicExpressionGrammar>("ArtificialAntExpressionGrammar", "The grammar that should be used for artificial ant expressions.", new ArtificialAntExpressionGrammar()));
       Parameters.Add(new ValueParameter<BoolMatrix>("World", "The world for the artificial ant with scattered food items.", world));
-      Parameters.Add(new ValueParameter<IntValue>("MaxTimeSteps", "The number of time steps the artificial ant has available to collect all food items.", new IntValue(600)));
+      Parameters.Add(new ValueParameter<IntValue>("MaximumTimeSteps", "The number of time steps the artificial ant has available to collect all food items.", new IntValue(600)));
 
       creator.SymbolicExpressionTreeParameter.ActualName = "AntTrailSolution";
