let positiveCallOrRet clause =
  try
    (* Step 1: find a positive information TCall or TReturn. *)
    let positive, computePositive=
      List.fold_left
        (fun (positive,treated as res) term ->
          match term with
            | TCall (kf1,None-> 
              begin match positive with
                | None -> (Some term, term::treated)
                | Some (TCall (kf2,None)) ->
                    if Kernel_function.equal kf1 kf2 then res else raise Exit
                | Some (TReturn _) -> raise Exit
                | Some(TCall (kf2,Some _) as term2) ->
                  if Kernel_function.equal kf1 kf2 then
                    Some term, term :: removeTerm term2 treated
                  else raise Exit
                | _ -> 
                  Aorai_option.fatal
                    "inconsistent environment in positiveCallOrRet"
              end
            | TCall (kf1, Some b1) ->
              begin match positive with
                | None -> (Some term, term::treated)
                | Some (TCall (kf2,None)) ->
                    if Kernel_function.equal kf1 kf2 then res else raise Exit
                | Some (TReturn _) -> raise Exit
                | Some(TCall (kf2,Some b2)) ->
                  if Kernel_function.equal kf1 kf2 then
                    if Datatype.String.equal b1.b_name b2.b_name then
                      res
                    else
                      positive, term :: treated
                  else raise Exit
                | _ -> 
                  Aorai_option.fatal
                    "inconsistent environment in positiveCallOrRet"
              end
            | TReturn kf1 -> 
              begin match positive with
                | None -> (Some term, term::treated)
                | Some (TReturn kf2) ->
                  if Kernel_function.equal kf1 kf2 then res else raise Exit
                | Some (TCall _) -> raise Exit
                | _ ->
                  Aorai_option.fatal
                    "inconsistent environment in positiveCallOrRet"
              end
            | _  -> positive, term::treated
        )
        (None, [])
        clause
    in
    (* Step 2 : Remove negatives not enough expressive *)
    match positive with 
      | None -> computePositive
      | Some (TCall (kf1,None)) ->
        List.fold_left
          (fun treated term -> 
            match term with 
              | TNot(TCall (kf2,_)) ->
                if Kernel_function.equal kf1 kf2 then raise Exit
                (* Positive information more specific than negative *)
                else treated
              | TNot(TReturn _) -> treated
              | _  -> term::treated
          )
          [] computePositive
      | Some (TCall (kf1, Some b1)) ->
        List.fold_left
          (fun treated term -> 
            match term with 
              | TNot(TCall (kf2,None)) ->
                if Kernel_function.equal kf1 kf2 then raise Exit
                (* Positive information more specific than negative *)
                else treated
              | TNot(TCall(kf2, Some b2)) ->
                if Kernel_function.equal kf1 kf2 then
                  if Datatype.String.equal b1.b_name b2.b_name then raise Exit
                  else term :: treated
                else treated
              | TNot(TReturn _) -> treated
              | _  -> term::treated
          )
          [] computePositive
        
      | Some (TReturn kf1) ->
        List.fold_left
          (fun treated term -> 
            match term with 
              | TNot(TCall _) -> treated
              | TNot(TReturn kf2) -> 
                (* Two opposite information *) 
                if Kernel_function.equal kf1 kf2 then raise Exit else treated
              | _ -> term::treated
          )
          [] computePositive
      | _ -> 
        Aorai_option.fatal "inconsistent environment in positiveCallOrRet"
  with Exit -> [TFalse]