           ;; Arguments related to parent selection
           ;;----------------------------------------
 
-         :parent-selection :lexicase
+          :parent-selection :lexicase
           ;; The parent selection method. Options include :tournament, :lexicase, :epsilon-lexicase,
           ;; :elitegroup-lexicase, :uniform, :leaky-lexicase, :random-threshold-lexicase,
           ;; :random-toggle-lexicase, :randomly-truncated-lexicase, :novelty-search
 
-         :epsilon-lexicase-epsilon nil
+          :epsilon-lexicase-epsilon nil
           ;; When parent-selection is :epsilon-lexicase,
           ;; the value for epsilon. If nil, automatic epsilon lexicase selection will be used.
 
-         :epsilon-lexicase-probability 1
+          :epsilon-lexicase-probability 1
           ;; The probability that each filtering step in epsilon lexicase selection will allow
           ;; candidates with errors within epsilon of the best to survive, rather than just
           ;; the best.
 
-         :random-threshold-lexicase-probability 1
+          :random-threshold-lexicase-probability 1
           ;; The probability that each filtering step in random threshold lexicase selection will 
           ;; allow candidates with errors equal to or better than a randomly chosen threshold to 
           ;; survive, rather than just the best.
 
-         :random-toggle-lexicase-probability 1
+          :random-toggle-lexicase-probability 1
           ;; The probability that each filtering step in random toggle lexicase selection will 
           ;; allow just the best to survive, rather than all individuals in the pool.
 
-         :randomly-truncated-lexicase-probability 1
+          :randomly-truncated-lexicase-probability 1
           ;; The probability that an application of randomly-truncated-lexicase-selection
           ;; will consider only a random subset of the test cases, rather than all of them.
 
-         :lexicase-leakage 0.1
+          :lexicase-leakage 0.1
           ;; If using leaky lexicase selection, the probability that a selection event will return
           ;; a random (tourny 1) individual from the entire population.
 
-         :lexicase-slippage 0
+          :lexicase-slippage 0
           ;; If using lexicase, leaky lexicase, epsilon lexicase, or random threshold lexicase
           ;; selection, the probability that each step of the lexicase selection process will
           ;; "slip" and return a random candidate from the current pool, rather than continuing 
           ;; to filter the pool.
 
-         :sort-meta-errors-for-lexicase :random
+          :sort-meta-errors-for-lexicase :random
           ;; If using lexicase selection, determines how meta-errors will be sorted among
           ;; the actual errors. Options are :random (errors and meta-errors are shuffled 
           ;; together), :first (meta-errors come first), or :last (meta-errors come last).
 
-         :tournament-size 7
+          :tournament-size 7
           ;; If using tournament selection, the size of the tournaments.
 
-         :total-error-method :sum
+          :total-error-method :sum
           ;; The method used to compute total error. Options include :sum (standard), :hah
           ;; (historically-assessed hardness), :rmse (root mean squared error), and :ifs
           ;; (implicit fitness sharing).
 
-         :normalization :none
+          :normalization :none
           ;; The method used to normalize the errors to the range [0,1], with 0 being best. Options
           ;; include :none (no normalization), :divide-by-max-error (divides by value of argument
           ;; :max-error), :e-over-e-plus-1 (e/(e+1) = 1 - 1/(e+1))
 
-         :max-error 1000
+          :max-error 1000
           ;; If :normalization is set to :divide-by-max-error, will use this number for
           ;; normalization.
 
-         :meta-error-categories []
+          :meta-error-categories []
           ;; A vector containing meta-error categories that can be used for parent selection, 
           ;; but that do not affect total error or the determination of whether an individual 
           ;; is considered to be a solution. Each meta-error-category should either be a function 

          ;; Genetic operator probabilities
          ;;----------------------------------------

         :genetic-operator-probabilities {:reproduction 0.0
                                          :alternation 0.7
                                          :uniform-mutation 0.1
                                          :uniform-instruction-mutation 0.0
                                          :uniform-integer-mutation 0.0
                                          :uniform-float-mutation 0.0
                                          :uniform-tag-mutation 0.0
                                          :uniform-string-mutation 0.0
                                          :uniform-boolean-mutation 0.0
                                           ; Similar to the old ULTRA operator:
                                          [:alternation :uniform-mutation] 0.2
                                          :uniform-close-mutation 0.0
                                          :uniform-silence-mutation 0.0
                                          :uniform-crossover 0.0
                                          :two-point-crossover 0.0
                                           ; A hill-climbing version of uniform-silence-mutation:
                                          [:make-next-operator-revertable :uniform-silence-mutation] 0.0
                                          :autoconstruction 0.0
                                          :uniform-deletion 0.0
                                          :uniform-addition 0.0
                                          :uniform-addition-and-deletion 0.0
                                          :uniform-combination-and-deletion 0.0
                                          :genesis 0.0
                                          :gene-selection 0.0}
          ;; The map supplied to :genetic-operator-probabilities should contain genetic operators
          ;; that sum to 1.0. All available genetic operators are defined in clojush.pushgp.breed.
          ;; Along with single operators, pipelines (vectors) containing multiple operators are

          ;; Arguments related to printing JSON, EDN, CSV, and remote recording
          ;;----------------------------------------

          :print-csv-logs false
          ;; Prints a CSV log of the population each generation.

          :print-edn-logs false
          ;; Prints an EDN log of the run.

          :print-json-logs false
          ;; Prints a JSON log of the population each generation.

          :csv-log-filename "log.csv"
          ;; The file to print CSV log to.

          :edn-log-filename "log.edn"
          ;; The file to print EDN log to.

          :json-log-filename "log.json"
          ;; The file to print JSON log to.

          :csv-columns [:generation :location :total-error :push-program-size]
          ;; The columns to include in a printed CSV beyond the generation and individual. Options
          ;; include: [:generation :location :parent-uuids :genetic-operators :push-program-size
          ;; :plush-genome-size :push-program :plush-genome :genome-closes :push-paren-locations
          ;; :total-error :test-case-errors]

          :edn-keys [:uuid :parent-uuids :genetic-operators :program :genome :total-error :errors]
          ;; Keys from clojush.individual.individual that should be included.

          :edn-additional-keys [:generation :location]
          ;; Additional information to include in the edn-printout. Available options are
          ;; [:generation :location :push-program-size :plush-genome-size].

          :log-fitnesses-for-all-cases false
          ;; If true, the CSV and JSON logs will include the fitnesses of each individual on every
          ;; test case.

          :json-log-program-strings false
          ;; If true, JSON logs will include program strings for each individual.

          :record-host nil
          ;; Should be in the format "<hostname>:<port>"
          ;; If set, will send logs of each run to a server running on this
          ;; host
          :label nil
          ;; If set, will send this in the configuration of the run, to the
          ;; external record
          )))

(defn augment-for-autoconstruction
  []
