Arka fon

Kendi kendime yardım öğreniyorum, Coq. Şimdiye kadar Yves BERTOT en okuyarak tamamlayan Aceleniz Coq . Şimdi, amacım bölme algoritması ile sonuçlanan doğal sayılarla ilgili bazı temel sonuçları kanıtlamak. Ancak, bu hedefe doğru ilerlerken bazı aksiliklerle karşılaştım. Özellikle, aşağıdaki iki sonuç Coq'ta kanıtlamanın başlangıçta hayal ettiğimden daha zor olduğunu kanıtladı (pun amaçlı). Aslında, birçok meyvesiz denemeden sonra, bunları elle kanıtlamak için başvurdum (aşağıda gösterildiği gibi). Bu açıkça Coq ile başa çıkmada daha yetkin olmamı sağlıyor; bu yüzden bu foruma dönüyorum. Ümit ediyorum ki, bu sitede birileri yetenekli ve istekliaşağıdaki kanıtlarımı Coq'un kabul ettiği bir kanıt haline getirmeme yardımcı olmak için. Tüm yardım içtenlikle takdir edilmektedir!

Teorem A

Hepsi için $x,y \in N$

$$\begin{equation} x < S(y) \subset x < y \lor \text{I}(N,x,y) \end{equation}$$ Kanıt:

varsaymak $x < S(y)$. Dolayısıyla bir$z \in N$ ile

$$\begin{equation} \text{I}(N,x+S(z),S(y)) \tag{*}\end{equation}$$ Bu nedenle (Peano 1b ve 3) $$\begin{equation} \text{I}(N,x+z,y) \end{equation}$$

Bir yüklem tanımlayın

$$\begin{equation} Q(u):=(\text{I}(N,x+u,y) \subset x<y \lor \text{I}(N,x,y) \end{equation}$$

Göstermek yeterlidir $Q(z)$. Bunu indüksiyonla kanıtlıyoruz$z$. Görmek$Q(0)$, ethat değilse $\text{I}(N,x+0,y)$ o zaman tutar $\text{I}(N,x,y)$Peano la için geçerlidir. Böylece,$x<y \lor \text{I}(n,x,y)$. Şimdi kanıtlıyoruz$Q(S(v))$: Varsayalım $\text{I}(N,x+S(v),y)$. Bu tanımdan$x<y$ ve böylece $x<y \lor \text{I}(N,x,y)$bu durumda da. Son olarak, Peano'nun beşinci aksiyomu$Q(z)$ ve tarafından $(*)$ aldık $x < y \lor \text{I}(N,x,y)$.

$$\begin{equation} \tag{$\square$} \end{equation}$$

Teorem B

Hepsi için $x,y \in N$

$$\begin{equation} x <y \lor \text{I}(N,x,y) \lor y<x \end{equation}$$ Kanıt:

Eğer $x<y$ sonra $\neg \text{I}(N,x,y)$ tanımı gereği ve eğer $x>y$ sonra $\neg \text{I}(N,x,y)$ayrıca tanım gereği. Eğer$x>y$ ve $y>x$ sonra geçiş ve yansıma ile, $\text{I}(N,x,y)$bu bir çelişki. Sonuç olarak, ifadelerin birden fazlası doğru değildir.

Biz tutarız $y$ sabit ve uyarılmış $x$. Ne zaman$\text{I}(N,0,y)$ sahibiz $0 < y \lor \text{I}(N,0,y)$ hepsi için $y$, temel durumu kanıtlar. Daha sonra, teoremin$x$; şimdi teoremini kanıtlamak istiyoruz$S(x)$. İçin trichotomy'den$x$, üç durum vardır: $x<y,\text{I}(N,x,y)$, ve $x>y$. Eğer$x>y$, sonra açıkça $S(x) >y$. Eğer$\text{I}(N,x,y)$, sonra $S(x) >y$ (gibi $S(x) >x$ hepsi için $x\in \mathbb{N}$). Son olarak, varsayalım$x <y$ Sonra A teoremine göre $S(x) < y$ veya $\text{I}(N,S(x),y)$ve her iki durumda da işimiz bitti.

$$\begin{equation} \tag{$\square$} \end{equation}$$

Kanıtlamak istediğim teoremler Coq.

Lemma less_lem (xy: N): daha az x (succ y) -> veya (daha az xy) (IN xy).

Teorem Ntrikotomi: (tüm xy: N veya (daha az xy) (veya (IN xy) (daha az yx))).

Yararlı sonuçlar

Burada, tanımladığım bazı sonuçları topladım ve bu noktaya kadar ispatladım. Bunlar yukarıda bahsettiğim şeyler. * Bu, şimdiye kadar yazmayı başardığım kod, çoğu tanımdan oluşuyor. *

(* Sigma types *)


Inductive Sigma (A:Set)(B:A -> Set) :Set :=
  Spair: forall a:A, forall b : B a,Sigma A B.

Definition E (A:Set)(B:A -> Set)
  (C: Sigma A B -> Set)
  (c: Sigma A B)
  (d: (forall x:A, forall y:B x, 
      C (Spair A B x y))): C c :=

match c as c0 return (C c0) with
| Spair a b => d a b
end. 


(* Binary sum type *)

Inductive sum' (A B:Set):Set := 
inl': A -> sum' A B | inr': B -> sum' A B.

Print sum'_rect.

Definition D (A B : Set)(C: sum' A B -> Set)
(c: sum' A B)
(d: (forall x:A, C (inl' A B x)))
(e: (forall y:B, C (inr' A B y))): C c :=

match c as c0 return C c0 with
| inl' x => d x
| inr' y => e y
end.

(* Three useful finite sets *)

Inductive N_0: Set :=.

Definition R_0
  (C:N_0 -> Set)
  (c: N_0): C c :=
match c as c0 return (C c0) with
end.

Inductive N_1: Set := zero_1:N_1.

Definition R_1 
  (C:N_1 -> Set)
  (c: N_1)
  (d_zero: C zero_1): C c :=
match c as c0 return (C c0) with
  | zero_1 => d_zero
end.

Inductive N_2: Set := zero_2:N_2 | one_2:N_2.

Definition R_2 
  (C:N_2 -> Set)
  (c: N_2)
  (d_zero: C zero_2)
  (d_one: C one_2): C c :=
match c as c0 return (C c0) with
  | zero_2 => d_zero
  | one_2  => d_one
end.


(* Natural numbers *)

Inductive N:Set :=
zero: N | succ : N -> N.

Print N. 

Print N_rect.

Definition R 
  (C:N -> Set)
  (d: C zero)
  (e: (forall x:N, C x -> C (succ x))):
  (forall n:N, C n) :=
fix F (n: N): C n :=
  match n as n0 return (C n0) with
  | zero => d
  | succ n0 => e n0 (F n0)
  end.

(* Boolean to truth-value converter *)

Definition Tr (c:N_2) : Set :=
match c as c0 with
  | zero_2 => N_0
  | one_2 => N_1
end.

(* Identity type *)

Inductive I (A: Set)(x: A) : A -> Set :=
r :  I A x x.

Print I_rect.

Theorem J 
  (A:Set)
  (C: (forall x y:A, 
              forall z: I A x y, Set))
  (d: (forall x:A, C x x (r A x)))
  (a:A)(b:A)(c:I A a b): C a b c.
induction c.
apply d.
Defined.

(* functions are extensional wrt
  identity types *)

Theorem I_I_extensionality (A B: Set)(f: A -> B):
(forall x y:A, I A x y -> I B (f x) (f y)).
Proof.
intros x y P.
induction P.
apply r.
Defined.


(* addition *)

Definition add (m n:N) : N 
 := R (fun z=> N) m (fun x y => succ y) n.

(* multiplication *)

Definition mul (m n:N) : N 
 := R (fun z=> N) zero (fun x y => add y m) n.


(* Axioms of Peano verified *)

Theorem P1a: (forall x: N, I N (add x zero) x).
intro x.
(* force use of definitional equality
  by applying reflexivity *)
apply r.
Defined.


Theorem P1b: (forall x y: N, 
I N (add x (succ y)) (succ (add x y))).
intros.
apply r.
Defined.


Theorem P2a: (forall x: N, I N (mul x zero) zero).
intros.
apply r.
Defined.


Theorem P2b: (forall x y: N, 
I N (mul x (succ y)) (add (mul x y) x)).
intros.
apply r.
Defined.

Definition pd (n: N): N :=
R (fun _=> N) zero (fun x y=> x) n.

(* alternatively
Definition pd (x: N): N :=
match x as x0 with
  | zero => zero
  | succ n0 => n0
end.
*)

Theorem P3: (forall x y:N, 
I N (succ x) (succ y) -> I N x y).
intros x y p.
apply (I_I_extensionality N N pd (succ x) (succ y)).
apply p.
Defined.

Definition not (A:Set): Set:= (A -> N_0).

Definition isnonzero (n: N): N_2:=
R (fun _ => N_2) zero_2 (fun x y => one_2) n.


Theorem P4 : (forall x:N, 
not (I N (succ x) zero)).
intro x.
intro p.

apply (J N (fun x y z => 
    Tr (isnonzero x) -> Tr (isnonzero y))
    (fun x => (fun t => t)) (succ x) zero)
.
apply p.
simpl.
apply zero_1.
Defined.

Theorem P5 (P:N -> Set):
P zero -> (forall x:N, P x -> P (succ x))
   -> (forall x:N, P x).
intros base step n.
apply R.
apply base.
apply step.
Defined.

(* I(A,-,-) is an equivalence relation *)

Lemma Ireflexive (A:Set): (forall x:A, I A x x).
intro x.
apply r.
Defined.

Lemma Isymmetric (A:Set): (forall x y:A, I A x y -> I A y x).
intros x y P.
induction P.
apply r.
Defined.

Lemma Itransitive (A:Set): 
(forall x y z:A, I A x y -> I A y z -> I A x z).
intros x y z P Q.
induction P.
assumption.
Defined.


Lemma succ_cong : (forall m n:N, I N m n -> I N (succ m) (succ n)).
intros m n H.
induction H.
apply r.
Defined.

Lemma zeroadd: (forall n:N, I N (add zero n) n).
intro n.
induction n.
simpl.
apply r.
apply succ_cong.
auto.

Defined.

Lemma succadd: (forall m n:N, I N (add (succ m) n) (succ (add m n))).
intros.
induction n.
simpl.
apply r.
simpl.
apply succ_cong.
auto.

Defined.

Lemma commutative_add: (forall m n:N, I N (add m n) (add n m)).
intros n m; elim n.
apply zeroadd.
intros y H; elim (succadd m y).
simpl.
rewrite succadd.
apply succ_cong.
assumption.


Defined.

Lemma associative_add: (forall m n k:N, 
I N (add (add m n) k) (add m (add n k))).
intros m n k.
induction k.
simpl.
apply Ireflexive.
simpl.
apply succ_cong.
assumption.
Defined.

Definition or (A B : Set):= sum' A B.


Definition less (m n: N) :=
 Sigma N (fun z => I N (add m (succ z)) n).



Lemma less_lem (x y:N) : 
less x (succ y) -> or (less x y) (I N x y).
intro.
destruct H.
right.

(* Here is where I'm working right now *)

Defined.


Theorem Ntrichotomy: (forall x y:N, 
or (less x y) (or (I N x y) (less y x))).

Coq kağıt ispatlarından biraz daha acımasızdır: bir kağıt ispatında "veya" açıkça "yazdığımızda, Coq'u ikna etmek için daha yapılacak çok şey vardır.

Şimdi aynı ruh halinde kalmaya çalışırken kodunuzu biraz temizledim. Burada bulabilirsiniz .

Birkaç açıklama:

1. Amacınıza zarar vermeyeceğini düşündüğüm dahili veri türlerini ve tanımları kullandım. Yerleşik eşitlik yerine identityve "daha az" ilişkisini kullansaydım , kanıtların çok daha kolay olacağını unutmayın, çünkü birçok lemma, her çağrıda kontrol edilen bilinen teoremlerin veritabanındadır.

   auto with arith.
   

2. Muhtemelen farkında olmadığınız bazı taktikler kullandım, ancak "gerçek" bir Coq süper kullanıcısı elinizde çok daha güçlü taktiklere sahip olacak ve işi basitleştirmek için kendi taktiklerini yazacaktı. Taktikleri güçlü bir şekilde kullanmayı öğrenmek için her zaman CPDT'yi öneriyorum .

3. Okunabilirliği artırmak için gösterimler ve sekmeler kullandım ve inductionişleri kanıtlamak ve yeniden faktörleştirmek için eşleştirme ve taktik gibi yerleşik yapılar kullandım . Özellikle, tanımınızla lessçalışmak zordu, onu nasıl biraz değiştirdiğimi görebilirsiniz.

   $$\exists x,\ m + (x+1) = n$$ eşdeğerine (ancak kullanımı daha kolay) $$\exists x,\ (x + m)+1 = n$$ bu tür bir "tanım ince ayarı" resmi kanıtlarda çok fazla olur .

4. Burada bu tür soruların cevaplarını alabilmenize rağmen, çalışmanızı bu tür soruları yanıtlamak amacıyla özel olarak yaratılan Coq-Club'a göndermenizi önemle tavsiye ederim .

Cody'nin cevabı mükemmel ve kanıtınızı Coq'a çevirme ile ilgili sorunuzu yerine getiriyor. Bunun bir tamamlayıcısı olarak, aynı sonuçları eklemek istedim, ancak farklı Coq parçalarının bir örneği olarak farklı bir rota kullanarak kanıtlandım ve çok az ek çalışma ile sözdizimsel olarak kanıtlayabileceğinizi kanıtladım. Ancak bu, en kısa yolun sadece farklı bir yol olduğu iddiası değildir. Kanıtlar sadece bir ek yardımcı lemma içerir ve sadece temel tanımlara dayanır, toplama, çarpma veya özelliklerinden herhangi birini veya fonksiyonel genişlemeyi sunmuyorum ve sadece Peano aksiyomları basit bir <= b -> yardımcı lemmada a + c <= b + c (sadece c = 1 için) ve yine de ücretsiz olarak endüktif tiplerle gelen yapısal indüksiyon.

Farketmediğini düşündüğüm Cody gibi, önceden tanımlanmış tipler vb. Kullandım, bu yüzden kanıttan önce bunları açıklayacağım:

• Sizinkiyle aynı tanıma sahip (kesin isimlendirmeye kadar) doğal sayılar için yerleşik nat türünü kullandım:

Endüktif nat: Set: = O: nat | S: nat -> nat

• Yerleşik le ve lt'yi sırasıyla daha az veya eşit ve daha az olarak kullandım, bunlar okunabilirlik için "<=" ve "<" notasyonu kısayollarına sahipti. Bunlar tanımlanmıştır:

Endüktif le: nat -> nat -> Prop: =
| le_n: forall n, le nn
| le_S: forall nm, (le nm) -> (le n (Sm)).

ve

Tanım lt (nm: nat): = le (Sn) m.

• Yerleşik eq (shorthand "=") sözdizimsel eşitliktir ve "I" ile aynı şekilde çalışır, sadece bir şeyin kendisine eşit olduğunu söyleyen bir kurucu ile. Simetrik ve geçişli özellikler oradan kolay kanıtlardır, ancak bu durumda onlara ihtiyacımız olmayacaktır. Aşağıdaki eq için tanım, içine yerleştirilmiş gösterime sahiptir.

Endüktif denklem (A: Tip) (x: A): A -> Prop: = eq_refl: x = x

• Son olarak, temel olarak sol argüman için kanıtınız veya doğru argümanınız olan iki kurucuya sahip öneri veya (stenografi "\ /" kısayolunu kullandım). Coq ayrıca, sadece "Apply or_introl" ve "Apply or_intror" anlamına gelen sol ve sağ kısayol taktiklerine de sahiptir.

Endüktif veya (AB: Prop): Prop: =
veya_kontrol: A -> A / B | or_intror: B -> A / B

Şimdi izlediğim kanıtlar, prensip olarak, eğer işaretleme yoluna girmezse, bunu sadece bir Coq .v dosyasına kesip geçebilmelisiniz ve işe yarayacaktır. İlginç bitleri not etmek için yorumlar ekledim, ancak (* *) sınırlayıcılarındalar, bu yüzden bunları kaldırmak zorunda kalmamalısınız.

Theorem lt_or_eq: forall (n m : nat),
  n < S m -> n < m \/ n = m.
Proof.
(*
  This proof is just a case analysis on n and m, whether they're zero or
  a successor of something.
*)
destruct n as [|n']; destruct m as [|m']. 

(*n = 0, m = 0*)
intros.
  right. reflexivity.

(*n = 0, m = S m'*)
intros H.
  inversion H.
  inversion H1.
  left. unfold lt. constructor.
  (*The constructor tactic tries to match the goal to a constructor
    that's in the environment.*) 
  left. unfold lt. constructor. assumption.
  (*Assumption tries to match the goal to something that's in the
    current context*)

(*n = S n', m = 0
  This case is false, so we can invert our way out of it.*)
intros.
  inversion H. inversion H1.

(*n = S n', m = S m'*)
intros.
  inversion H.
    right. reflexivity.
    left. unfold lt. assumption.
Qed.


(*
  The following lemma with be useful in the proof of the trichotomy theorem,
  it's pretty obviously true, and easy to prove. The interesting part for
  anyone relatively new to Coq is that the induction is done on the
  hypothesis "a <= b", rather than on either a or b.
*)
Lemma a_le_b_implies_Sa_le_Sb: forall a b, a <= b -> S a <= S b.
Proof.
  intros a b Hyp.
  induction Hyp.
  constructor.
  constructor.
  apply IHHyp.
Qed.

(*
  The proof of the trichotomy theorem is a little more involved than the
  last one but again we don't use anything particularly tricky. 
  Other than the helper lemma above, we don't use anything other than the
  definitions.

  The proof proceeds by induction on n, then induction on m.  My personal
  feeling is that this can probably be shortened.  
*)
Theorem trich: forall (n m : nat),
  n < m \/ n = m \/ m < n.
Proof.
  induction n.
    induction m.
      right. left. reflexivity.
        inversion IHm.
          left. unfold lt. constructor. unfold lt in H. assumption.
          inversion H.
          left. unfold lt. subst. constructor.
          inversion H0.     
    induction m.
      assert (n < 0 \/ n = 0 \/ 0 < n).
      apply IHn.
      inversion H.
      inversion H0.
      inversion H0.
      right. right. subst. unfold lt. constructor.
      right. right. unfold lt. constructor. assumption.
      inversion IHm. unfold lt in H.
      left. unfold lt. constructor. assumption.
      inversion H; subst.
      left. unfold lt. constructor.
      inversion H0.
      right. left. reflexivity.
      right. right. apply lt_or_eq in H0.

      inversion H0.
      apply a_le_b_implies_Sa_le_Sb. assumption.
      subst. unfold lt. apply a_le_b_implies_Sa_le_Sb. assumption.
Qed.

(*
  The following is just to show what can be done with some of the tactics
  The omega tactic implements a Pressburger arithmetic solver, so anything
  with natural numbers, plus, multiplication by constants, and basic logic
  can just be solved. Not very interesting for practicing Coq, but cool to
  know.
*)

Require Import Omega.

Example trich' : forall (n m : nat),
  n < m \/ n = m \/ m < n.
Proof.
  intros.
  omega.
Qed.