private static UnorderedListAssertor <string, HiddenLayer> ListAssertorFor(
                Action <LayerAssertor <HiddenLayer> .Builder>[] synapseAssertors)
            {
                var listAssertor = new UnorderedListAssertor <string, HiddenLayer>(GetKeyForAssertor);

                PopulateListAssertor(synapseAssertors, listAssertor);
                return(listAssertor);
            }
            private UnorderedListAssertor <string, Synapse> ListAssertorFor(
                Action <SynapseAssertor.Builder>[] synapseAssertors)
            {
                var listAssertor = new UnorderedListAssertor <string, Synapse>(GetKeyForAssertor);

                PopulateListAssertor(synapseAssertors, listAssertor);
                return(listAssertor);
            }
            private UnorderedListAssertor <int, Neuron> ListAssertorFor(
                Action <NeuronAssertor.Builder>[] neuronAssertors)
            {
                var listAssertor = new UnorderedListAssertor <int, Neuron>(GetKeyForAssertor);

                PopulateListAssertor(neuronAssertors, listAssertor);
                return(listAssertor);
            }
            private void PopulateListAssertor(
                Action <NeuronAssertor.Builder>[] neuronAssertors,
                UnorderedListAssertor <int, Neuron> listAssertor)
            {
                foreach (var produceAssertor in neuronAssertors)
                {
                    var builder = new NeuronAssertor.Builder();
                    produceAssertor(builder);

                    var neuronAssertor = builder.Build() as NeuronAssertor;
                    assertor.NeuronIds.Add(neuronAssertor.NeuronId);

                    listAssertor.Assertors.Add(neuronAssertor.NeuronId, neuronAssertor);
                }
            }
            private static void PopulateListAssertor(
                Action <LayerAssertor <HiddenLayer> .Builder>[] synapseAssertors,
                UnorderedListAssertor <string, HiddenLayer> listAssertor)
            {
                foreach (var produceAssertor in synapseAssertors)
                {
                    var builder = new LayerAssertor <HiddenLayer> .Builder();

                    produceAssertor(builder);

                    var layerAssertor = builder.Build() as LayerAssertor <HiddenLayer>;

                    listAssertor.Assertors.Add(
                        CreateSynapseKey(layerAssertor.NeuronIds.ToArray()),
                        layerAssertor);
                }
            }
            private void PopulateListAssertor(
                Action <SynapseAssertor.Builder>[] synapseAssertors,
                UnorderedListAssertor <string, Synapse> listAssertor)
            {
                foreach (var produceAssertor in synapseAssertors)
                {
                    var builder = new SynapseAssertor.Builder();
                    produceAssertor(builder);

                    var synapseAssertor = builder.Build() as SynapseAssertor;

                    var inputNeuronId = synapseAssertor.InputNeuronId.HasValue ?
                                        synapseAssertor.InputNeuronId.Value : assertor.NeuronId;

                    var outputNeuronId = synapseAssertor.OutputNeuronId.HasValue ?
                                         synapseAssertor.OutputNeuronId.Value : assertor.NeuronId;

                    listAssertor.Assertors.Add(
                        CreateSynapseKey(inputNeuronId, outputNeuronId),
                        synapseAssertor);
                }
            }