我一直堅持使用 MApp 來抽取引理

Question

我一直在嘗試解決 Coq 中的 Pumping lemma。

我在第三個子目標Mapp上。

Lemma pumping : forall T (re : reg_exp T) s,
  s =~ re ->
  pumping_constant re <= length s ->
  exists s1 s2 s3,
    s = s1 ++ s2 ++ s3 /\
    s2 <> [] /\
    length s1 + length s2 <= pumping_constant re /\
    forall m, s1 ++ napp m s2 ++ s3 =~ re.

我在MApp上的證明如下。

Proof.
  intros T re s Hmatch.
  induction Hmatch
    as [ | x | s1 re1 s2 re2 Hmatch1 IH1 Hmatch2 IH2
       | s1 re1 re2 Hmatch IH | re1 s2 re2 Hmatch IH
       | re | s1 s2 re Hmatch1 IH1 Hmatch2 IH2 ].
  - (* MEmpty -- omitted *)
  - (* MChar -- omitted *)
  - (* MApp *)
    intros T re s Hmatch.
  induction Hmatch
    as [ | x | s1 re1 s2 re2 Hmatch1 IH1 Hmatch2 IH2
       | s1 re1 re2 Hmatch IH | re1 s2 re2 Hmatch IH
       | re | s1 s2 re Hmatch1 IH1 Hmatch2 IH2 ].
  - (* MEmpty *)
    simpl. intros contra. inversion contra.
  - (* MChar *)
    simpl. intros. inversion H. inversion H1.
  - (* MApp *)
    simpl. rewrite app_length. intros.
    apply add_le_cases in H.
    destruct H as [H|H].
    + (*case pumping_constant re1 <= length s1 ommitted*)
    + apply IH2 in H. destruct H as [ss1 [ss2 [ss3 [H1 [H2 [H3 H4]]]]]].
      exists (s1++ss1), ss2, ss3. split.
      * rewrite H1. rewrite <- app_assoc. reflexivity.
      * split. apply H2.
        split. rewrite app_length.
        assert (Hc: length s1<pumping_constant re1 \/ length s1>=pumping_constant re1).
        apply lt_ge_cases.
        destruct Hc as [Hc|Hc].
        apply le_S in Hc.
        apply Sn_le_Sm__n_le_m in Hc.
        rewrite <- add_assoc.
        apply (Plus.plus_le_compat _ _ _ _ Hc).
        apply H3.
        (* stuck *)

我現在被困在案例Hc: length s1>=pumping_constant re1

Goal:
2 goals
T : Type
s1 : list T
re1 : reg_exp T
s2 : list T
re2 : reg_exp T
Hmatch1 : s1 =~ re1
Hmatch2 : s2 =~ re2
IH1 : pumping_constant re1 <= length s1 ->
      exists s2 s3 s4 : list T,
        s1 = s2 ++ s3 ++ s4 /\
        s3 <> [ ] /\
        length s2 + length s3 <= pumping_constant re1 /\
        (forall m : nat, s2 ++ napp m s3 ++ s4 =~ re1)
IH2 : pumping_constant re2 <= length s2 ->
      exists s1 s3 s4 : list T,
        s2 = s1 ++ s3 ++ s4 /\
        s3 <> [ ] /\
        length s1 + length s3 <= pumping_constant re2 /\
        (forall m : nat, s1 ++ napp m s3 ++ s4 =~ re2)
ss1, ss2, ss3 : list T
H1 : s2 = ss1 ++ ss2 ++ ss3
H2 : ss2 <> [ ]
H3 : length ss1 + length ss2 <= pumping_constant re2
H4 : forall m : nat, ss1 ++ napp m ss2 ++ ss3 =~ re2
Hc : length s1 >= pumping_constant re1
______________________________________(1/2)
length s1 + length ss1 + length ss2 <=
pumping_constant re1 + pumping_constant re2

我嘗試用案例H: length s1>=pumping_constant -> re1 length s1=pumping_constant re1 \/ length s1>pumping_constatn re1解決它。

它把我帶到了某個地方，但正確的案例很難破解。 我應該如何進行？

Answer 1

直觀地說（我沒有安裝特定的庫），我將從length s1 >= pumping_constant re1的案例分析開始

• 如果成立，則可以應用 IH1，然后將 append s2應用於s1分解的第三個元素的右側。
• 如果length s1 < pumping_constant re1並且s1 ++ s2足夠長，那么length s2 >= pumping_constant re2 ，並且可以應用IH2 ，然后 append s1到s2分解的第一個元素的左側。

（待驗證）