Issues with speed/output of goal display (1s in CoqIDE, 3min in VSCoq)

Running over the following Coq snippet:

Require Import ZArith.

Open Scope Z.

Goal forall x, x>=15000.
intros x.
cbv.

takes about 1s in CoqIDE (until the result is displayed - CoqIDE does not block) and about 3 minutes in VsCoq (it blocks for this time).

Also the output is not the same - although I tried to ensure all display settings are the same (e.g. by restarting CoqIDE and VSCoq). For 10 instead of 15000 I get in CoqIDE:

1 goal
x : Z
______________________________________(1/1)
match x with
| 10 => Eq
| 0 | 7 | 9 | 5 | 3 | 6 | 8 | 4 | 2 | 1 | Z.neg _ => Lt
| _ => Gt
end = Lt -> False

and in VsCoq

x: Z
1/1
match x with
| Z.pos x' =>
    match x' with
    | (p~1)%positive =>
        match p with
        | (p0~1)%positive =>
            match p0 with
            | (p1~1)%positive | (p1~0)%positive => match p1 with
                                                   | (_~1)%positive | _ => Gt
                                                   end
            | 1%positive => Lt
            end
        | (p0~0)%positive =>
            match p0 with
            | (p1~1)%positive => match p1 with
                                 | (_~1)%positive | _ => Gt
                                 end
            | (p1~0)%positive => match p1 with
                                 | 1%positive => Lt
                                 | _ => Gt
                                 end
            | 1%positive => Lt
            end
        | 1%positive => Lt
        end
    | (p~0)%positive =>
        match p with
        | (p0~1)%positive =>
            match p0 with
            | (p1~1)%positive => match p1 with
                                 | (_~1)%positive | _ => Gt
                                 end
            | (p1~0)%positive => match p1 with
                                 | 1%positive => Eq
                                 | _ => Gt
                                 end
            | 1%positive => Lt
            end
        | (p0~0)%positive =>
            match p0 with
            | (p1~1)%positive => match p1 with
                                 | (_~1)%positive | _ => Gt
                                 end
            | (p1~0)%positive => match p1 with
                                 | 1%positive => Lt
                                 | _ => Gt
                                 end
            | 1%positive => Lt
            end
        | 1%positive => Lt
        end
    | 1%positive => Lt
    end
| _ => Lt
end = Lt -> False

I am not sure if the slowness is caused by the larger terms or is a general issue.

The example is nice to test this, because it produces terms which don’t (easily) run into the nesting limit (producing ...) and can produce terms of arbitrary size.

[Blaisorblade]

Submitted. I don’t consider this high quality, but perfect is the enemy of the good. @4ever2 since you did the lion’s share of the work and understand the code in question better than me, would you be willing to take a look, or submit a better patch?

[4ever2]

The difference in the output is because of the Printing Matching setting. However, switching the setting does not solve the performance issue.

I also noticed that VsCoq sometimes is very slow at showing goals even though coqtop responds quickly (if you do Time cbv in the above example it says that the command finished in a few milliseconds).

I looked into this a while ago and the reason for this slowdown is due to proof diffs. For some reason, VsCoq doesn’t use the proof diff option built into Coq. Instead, the diff is computed by the extension using some very slow code. Sadly VsCoq doesn’t provide an option to disable proof diffs, so the only workaround right now is to remove the following line: https://github.com/coq-community/vscoq/blob/b5da0a8422d9027b9064956be787200d2f762d52/server/src/stm/State.ts#L200