anchor.diff:                                              firstSubLayer 
                                               toMult
                                               
  -            // todo: do firstMultTasks  
  -            firstMultTasks |> Array.iter printTask
  -            printfn ""
  +            firstMultTasks |> Array.iter performMultiplication
               completeSubLayer firstSubLayer halfMatricesSize
                         
               let secondSubLayer = 
  
positive.code:                             (
                                  complexRules.Keys
                                  |> Seq.map (fun x -> x, emptyMatrixOfSize (stringSize + 1))
                              ) 
  
  
          let addProbToMatrix (matrix: Map<_, double [,]>) row column nontermProb = 
              let key, prob = nontermProb
  
negative.code:     //    B -> 'b', 0.4
      //    B -> 'b', 0.4
  
          let printMatrix (matrix: double [,]) strLen searchLen =
              let rowLength = matrix.GetLength(0)
              let colLength = matrix.GetLength(1)
  
              for i in [0..rowLength-1] do
                  for j in [0..colLength-1] do
                      if i <= strLen && j <= strLen && j > i && j-i <= searchLen then
                          printf "%.8f  " matrix.[i, j]
                      else
                          assert (matrix.[i, j] = 0.)
                          printf "----------  "
                  printfn ""
              printfn ""
  
          let isAnswerValid (matrix: double [,]) strLen searchLen = 
              let rowLength = matrix.GetLength(0)
              let colLength = matrix.GetLength(1)
              if rowLength <> colLength || rowLength <> strLen + 1 then
                  false
              else
                  let notRealCell (i, j) =
                          i > strLen 
                          || j > strLen 
                          || j <= i 
                          || j-i > searchLen 
  
                  [1..rowLength-1]
                  |> List.map (fun i -> [1..colLength-1] |> List.map (fun j -> (i,j))) 
                  |> List.concat
                  |> List.filter notRealCell
                  |> List.forall (fun (i, j) -> matrix.[i,j] = 0.)
  
          let check str = 
              let searchLen = String.length str
              let toCheck = recognize str crl srl erl nonterminals S searchLen
              assert (isAnswerValid toCheck (String.length str) searchLen)
              printMatrix toCheck (String.length str) searchLen
              
          check "abb"      
          check "aaabbcc"
  
          System.Console.ReadLine() |> ignore
          0