anchor.diff:  open Yard.Core.IL
   open Yard.Core.IL.Production
   open System.Collections.Generic
  +open Yard.Core.IL.Rule
   
   //--Тестовые функции-------------------------------------------------------------------------------
   
  
positive.code: 
  //--Функция для удаления цепных правил-------------------------------------------------------------
                  
  let deleteChainRule (ruleList: Rule.t<_, _> list) = ruleList
  
  //--Преобразование в КНФ---------------------------------------------------------------------------
  
  
negative.code: 
  //--Функция которая удаляет правила в правиле------------------------------------------------------
  
  let private reductionRule (ruleList: Rule.t<_, _> list) = 
  
      let reduction = ref []
      
      let rec addRule (rule: Rule.t<_, _>) (elements: elem<_, _> list) = 
          [{
              name = rule.name
              args=rule.args
              _public=rule._public
              metaArgs=rule.metaArgs
              body=PSeq(elements 
                  |> List.collect
                              (fun elem -> 
                                  match elem.rule with
                                  |PSeq(e, a, l) -> 
                                      incr index
                                      let i = !index
                                      reduction := addRule {                         
                                              name = "newRuleInRule" + (!index).ToString()
                                              args=[]
                                              _public=false
                                              metaArgs=[]
                                              body=elem.rule
                                          } e @ !reduction
                                      [{
                                          omit = false
                                          binding = None
                                          checker = None
                                          rule = PRef(("newRuleInRule" + (i).ToString(), (0, 0)), None)
                                      }]
                                  |x -> [elem]
                              ), 
                              (match rule.body with PSeq(e, a, l) -> a | x -> None), 
                              (match rule.body with PSeq(e, a, l) -> l | x -> None) )
          }]
  
      let newRule = 
  