Built with Alectryon, running Coq+SerAPI v8.10.0+0.7.0. Coq sources are in this panel; goals and messages will appear in the other. Bubbles () indicate interactive fragments: hover for details, tap to reveal contents. Use Ctrl+↑ Ctrl+↓ to navigate, Ctrl+🖱️ to focus.

(************************************************************************)
(*         *   The Coq Proof Assistant / The Coq Development Team       *)
(*  v      *   INRIA, CNRS and contributors - Copyright 1999-2018       *)
(* <O___,, *       (see CREDITS file for the list of authors)           *)
(*   \VV/  **************************************************************)
(*    //   *    This file is distributed under the terms of the         *)
(*         *     GNU Lesser General Public License Version 2.1          *)
(*         *     (see LICENSE file for the text of the license)         *)
(************************************************************************)

Require Import NAxioms NSub NDiv NGcd.

Least Common Multiple

Unlike other functions around, we will define lcm below instead of axiomatizing it. Indeed, there is no "prior art" about lcm in the standard library to be compliant with, and the generic definition of lcm via gcd is quite reasonable.

By the way, we also state here some combined properties of div/mod and gcd.

Module Type NLcmProp
 (Import A : NAxiomsSig')
 (Import B : NSubProp A)
 (Import C : NDivProp A B)
 (Import D : NGcdProp A B).

Divibility and modulo

Lemma mod_divide : forall a b, b~=0 -> (a mod b == 0 <-> (b|a)).forall a b : t, b ~= 0 -> a mod b == 0 <-> (b | a)
Proof.forall a b : t, b ~= 0 -> a mod b == 0 <-> (b | a)
 intros a b Hb.a, b:t
Hb:b ~= 0
a mod b == 0 <-> (b | a) split.a, b:t
Hb:b ~= 0
a mod b == 0 -> (b | a)
a, b:t
Hb:b ~= 0
(b | a) -> a mod b == 0
 intros Hab.a, b:t
Hb:b ~= 0
Hab:a mod b == 0
(b | a)
a, b:t
Hb:b ~= 0
(b | a) -> a mod b == 0 exists (a/b).a, b:t
Hb:b ~= 0
Hab:a mod b == 0
a == a / b * b
a, b:t
Hb:b ~= 0
(b | a) -> a mod b == 0 rewrite mul_comm.a, b:t
Hb:b ~= 0
Hab:a mod b == 0
a == b * (a / b)
a, b:t
Hb:b ~= 0
(b | a) -> a mod b == 0
  rewrite (div_mod a b Hb) at 1.a, b:t
Hb:b ~= 0
Hab:a mod b == 0
b * (a / b) + a mod b == b * (a / b)
a, b:t
Hb:b ~= 0
(b | a) -> a mod b == 0 rewrite Hab; now nzsimpl.a, b:t
Hb:b ~= 0
(b | a) -> a mod b == 0
 intros (c,Hc).a, b:t
Hb:b ~= 0
c:t
Hc:a == c * b
a mod b == 0 rewrite Hc.a, b:t
Hb:b ~= 0
c:t
Hc:a == c * b
(c * b) mod b == 0 now apply mod_mul.
Qed.

Lemma divide_div_mul_exact : forall a b c, b~=0 -> (b|a) ->
 (c*a)/b == c*(a/b).forall a b c : t,
b ~= 0 -> (b | a) -> c * a / b == c * (a / b)
Proof.forall a b c : t,
b ~= 0 -> (b | a) -> c * a / b == c * (a / b)
 intros a b c Hb H.a, b, c:t
Hb:b ~= 0
H:(b | a)
c * a / b == c * (a / b)
 apply mul_cancel_l with b; trivial.a, b, c:t
Hb:b ~= 0
H:(b | a)
b * (c * a / b) == b * (c * (a / b))
 rewrite mul_assoc, mul_shuffle0.a, b, c:t
Hb:b ~= 0
H:(b | a)
b * (c * a / b) == b * (a / b) * c
 assert (H':=H).a, b, c:t
Hb:b ~= 0
H, H':(b | a)
b * (c * a / b) == b * (a / b) * c apply mod_divide, div_exact in H'; trivial.a, b, c:t
Hb:b ~= 0
H:(b | a)
H':a == b * (a / b)
b * (c * a / b) == b * (a / b) * c
 rewrite <- H', (mul_comm a c).a, b, c:t
Hb:b ~= 0
H:(b | a)
H':a == b * (a / b)
b * (c * a / b) == c * a
 symmetry.a, b, c:t
Hb:b ~= 0
H:(b | a)
H':a == b * (a / b)
c * a == b * (c * a / b) apply div_exact; trivial.a, b, c:t
Hb:b ~= 0
H:(b | a)
H':a == b * (a / b)
(c * a) mod b == 0
 apply mod_divide; trivial.a, b, c:t
Hb:b ~= 0
H:(b | a)
H':a == b * (a / b)
(b | c * a)
 now apply divide_mul_r.
Qed.

Gcd of divided elements, for exact divisions

Lemma gcd_div_factor : forall a b c, c~=0 -> (c|a) -> (c|b) ->
 gcd (a/c) (b/c) == (gcd a b)/c.forall a b c : t,
c ~= 0 ->
(c | a) ->
(c | b) -> gcd (a / c) (b / c) == gcd a b / c
Proof.forall a b c : t,
c ~= 0 ->
(c | a) ->
(c | b) -> gcd (a / c) (b / c) == gcd a b / c
 intros a b c Hc Ha Hb.a, b, c:t
Hc:c ~= 0
Ha:(c | a)
Hb:(c | b)
gcd (a / c) (b / c) == gcd a b / c
 apply mul_cancel_l with c; try order.a, b, c:t
Hc:c ~= 0
Ha:(c | a)
Hb:(c | b)
c * gcd (a / c) (b / c) == c * (gcd a b / c)
 assert (H:=gcd_greatest _ _ _ Ha Hb).a, b, c:t
Hc:c ~= 0
Ha:(c | a)
Hb:(c | b)
H:(c | gcd a b)
c * gcd (a / c) (b / c) == c * (gcd a b / c)
 apply mod_divide, div_exact in H; try order.a, b, c:t
Hc:c ~= 0
Ha:(c | a)
Hb:(c | b)
H:gcd a b == c * (gcd a b / c)
c * gcd (a / c) (b / c) == c * (gcd a b / c)
 rewrite <- H.a, b, c:t
Hc:c ~= 0
Ha:(c | a)
Hb:(c | b)
H:gcd a b == c * (gcd a b / c)
c * gcd (a / c) (b / c) == gcd a b
 rewrite <- gcd_mul_mono_l; try order.a, b, c:t
Hc:c ~= 0
Ha:(c | a)
Hb:(c | b)
H:gcd a b == c * (gcd a b / c)
gcd (c * (a / c)) (c * (b / c)) == gcd a b
 f_equiv; symmetry; apply div_exact; try order;
  apply mod_divide; trivial; try order.
Qed.

Lemma gcd_div_gcd : forall a b g, g~=0 -> g == gcd a b ->
 gcd (a/g) (b/g) == 1.forall a b g : t,
g ~= 0 -> g == gcd a b -> gcd (a / g) (b / g) == 1
Proof.forall a b g : t,
g ~= 0 -> g == gcd a b -> gcd (a / g) (b / g) == 1
 intros a b g NZ EQ.a, b, g:t
NZ:g ~= 0
EQ:g == gcd a b
gcd (a / g) (b / g) == 1 rewrite gcd_div_factor.a, b, g:t
NZ:g ~= 0
EQ:g == gcd a b
gcd a b / g == 1
a, b, g:t
NZ:g ~= 0
EQ:g == gcd a b
g ~= 0
a, b, g:t
NZ:g ~= 0
EQ:g == gcd a b
(g | a)
a, b, g:t
NZ:g ~= 0
EQ:g == gcd a b
(g | b)
 now rewrite <- EQ, div_same.a, b, g:t
NZ:g ~= 0
EQ:g == gcd a b
g ~= 0
a, b, g:t
NZ:g ~= 0
EQ:g == gcd a b
(g | a)
a, b, g:t
NZ:g ~= 0
EQ:g == gcd a b
(g | b)
 generalize (gcd_nonneg a b); order.a, b, g:t
NZ:g ~= 0
EQ:g == gcd a b
(g | a)
a, b, g:t
NZ:g ~= 0
EQ:g == gcd a b
(g | b)
 rewrite EQ; apply gcd_divide_l.a, b, g:t
NZ:g ~= 0
EQ:g == gcd a b
(g | b)
 rewrite EQ; apply gcd_divide_r.
Qed.

The following equality is crucial for Euclid algorithm

Lemma gcd_mod : forall a b, b~=0 -> gcd (a mod b) b == gcd b a.forall a b : t, b ~= 0 -> gcd (a mod b) b == gcd b a
Proof.forall a b : t, b ~= 0 -> gcd (a mod b) b == gcd b a
 intros a b Hb.a, b:t
Hb:b ~= 0
gcd (a mod b) b == gcd b a rewrite (gcd_comm _ b).a, b:t
Hb:b ~= 0
gcd b (a mod b) == gcd b a
 rewrite <- (gcd_add_mult_diag_r b (a mod b) (a/b)).a, b:t
Hb:b ~= 0
gcd b (a mod b + a / b * b) == gcd b a
 now rewrite add_comm, mul_comm, <- div_mod.
Qed.

We now define lcm thanks to gcd:

lcm a b = a * (b / gcd a b) = (a / gcd a b) * b = (a*b) / gcd a b

Nota: lcm 0 0 should be 0, which isn't guarantee with the third equation above.

Definition lcm a b := a*(b/gcd a b).

Instance lcm_wd : Proper (eq==>eq==>eq) lcm.Proper (eq ==> eq ==> eq) lcm
Proof.Proper (eq ==> eq ==> eq) lcm unfold lcm.Proper (eq ==> eq ==> eq)
  (fun a b : t => a * (b / gcd a b)) solve_proper. Qed.

Lemma lcm_equiv1 : forall a b, gcd a b ~= 0 ->
  a * (b / gcd a b) == (a*b)/gcd a b.forall a b : t,
gcd a b ~= 0 -> a * (b / gcd a b) == a * b / gcd a b
Proof.forall a b : t,
gcd a b ~= 0 -> a * (b / gcd a b) == a * b / gcd a b
 intros a b H.a, b:t
H:gcd a b ~= 0
a * (b / gcd a b) == a * b / gcd a b rewrite divide_div_mul_exact; try easy.a, b:t
H:gcd a b ~= 0
(gcd a b | b) apply gcd_divide_r.
Qed.

Lemma lcm_equiv2 : forall a b, gcd a b ~= 0 ->
  (a / gcd a b) * b == (a*b)/gcd a b.forall a b : t,
gcd a b ~= 0 -> a / gcd a b * b == a * b / gcd a b
Proof.forall a b : t,
gcd a b ~= 0 -> a / gcd a b * b == a * b / gcd a b
 intros a b H.a, b:t
H:gcd a b ~= 0
a / gcd a b * b == a * b / gcd a b rewrite 2 (mul_comm _ b).a, b:t
H:gcd a b ~= 0
b * (a / gcd a b) == b * a / gcd a b
 rewrite divide_div_mul_exact; try easy.a, b:t
H:gcd a b ~= 0
(gcd a b | a) apply gcd_divide_l.
Qed.

Lemma gcd_div_swap : forall a b,
 (a / gcd a b) * b == a * (b / gcd a b).forall a b : t, a / gcd a b * b == a * (b / gcd a b)
Proof.forall a b : t, a / gcd a b * b == a * (b / gcd a b)
 intros a b.a, b:t
a / gcd a b * b == a * (b / gcd a b) destruct (eq_decidable (gcd a b) 0) as [EQ|NEQ].a, b:t
EQ:gcd a b == 0
a / gcd a b * b == a * (b / gcd a b)
a, b:t
NEQ:gcd a b ~= 0
a / gcd a b * b == a * (b / gcd a b)
 apply gcd_eq_0 in EQ.a, b:t
EQ:a == 0 /\ b == 0
a / gcd a b * b == a * (b / gcd a b)
a, b:t
NEQ:gcd a b ~= 0
a / gcd a b * b == a * (b / gcd a b) destruct EQ as (EQ,EQ').a, b:t
EQ:a == 0
EQ':b == 0
a / gcd a b * b == a * (b / gcd a b)
a, b:t
NEQ:gcd a b ~= 0
a / gcd a b * b == a * (b / gcd a b) rewrite EQ, EQ'.a, b:t
EQ:a == 0
EQ':b == 0
0 / gcd 0 0 * 0 == 0 * (0 / gcd 0 0)
a, b:t
NEQ:gcd a b ~= 0
a / gcd a b * b == a * (b / gcd a b) now nzsimpl.a, b:t
NEQ:gcd a b ~= 0
a / gcd a b * b == a * (b / gcd a b)
 now rewrite lcm_equiv1, <-lcm_equiv2.
Qed.

Lemma divide_lcm_l : forall a b, (a | lcm a b).forall a b : t, (a | lcm a b)
Proof.forall a b : t, (a | lcm a b)
 unfold lcm.forall a b : t, (a | a * (b / gcd a b)) intros a b.a, b:t
(a | a * (b / gcd a b)) apply divide_factor_l.
Qed.

Lemma divide_lcm_r : forall a b, (b | lcm a b).forall a b : t, (b | lcm a b)
Proof.forall a b : t, (b | lcm a b)
 unfold lcm.forall a b : t, (b | a * (b / gcd a b)) intros a b.a, b:t
(b | a * (b / gcd a b)) rewrite <- gcd_div_swap.a, b:t
(b | a / gcd a b * b)
 apply divide_factor_r.
Qed.

Lemma divide_div : forall a b c, a~=0 -> (a|b) -> (b|c) -> (b/a|c/a).forall a b c : t,
a ~= 0 -> (a | b) -> (b | c) -> (b / a | c / a)
Proof.forall a b c : t,
a ~= 0 -> (a | b) -> (b | c) -> (b / a | c / a)
 intros a b c Ha Hb (c',Hc).a, b, c:t
Ha:a ~= 0
Hb:(a | b)
c':t
Hc:c == c' * b
(b / a | c / a) exists c'.a, b, c:t
Ha:a ~= 0
Hb:(a | b)
c':t
Hc:c == c' * b
c / a == c' * (b / a)
 now rewrite <- divide_div_mul_exact, Hc.
Qed.

Lemma lcm_least : forall a b c,
 (a | c) -> (b | c) -> (lcm a b | c).forall a b c : t, (a | c) -> (b | c) -> (lcm a b | c)
Proof.forall a b c : t, (a | c) -> (b | c) -> (lcm a b | c)
 intros a b c Ha Hb.a, b, c:t
Ha:(a | c)
Hb:(b | c)
(lcm a b | c) unfold lcm.a, b, c:t
Ha:(a | c)
Hb:(b | c)
(a * (b / gcd a b) | c)
 destruct (eq_decidable (gcd a b) 0) as [EQ|NEQ].a, b, c:t
Ha:(a | c)
Hb:(b | c)
EQ:gcd a b == 0
(a * (b / gcd a b) | c)
a, b, c:t
Ha:(a | c)
Hb:(b | c)
NEQ:gcd a b ~= 0
(a * (b / gcd a b) | c)
 apply gcd_eq_0 in EQ.a, b, c:t
Ha:(a | c)
Hb:(b | c)
EQ:a == 0 /\ b == 0
(a * (b / gcd a b) | c)
a, b, c:t
Ha:(a | c)
Hb:(b | c)
NEQ:gcd a b ~= 0
(a * (b / gcd a b) | c) destruct EQ as (EQ,EQ').a, b, c:t
Ha:(a | c)
Hb:(b | c)
EQ:a == 0
EQ':b == 0
(a * (b / gcd a b) | c)
a, b, c:t
Ha:(a | c)
Hb:(b | c)
NEQ:gcd a b ~= 0
(a * (b / gcd a b) | c) rewrite EQ in *.a, b, c:t
Ha:(0 | c)
Hb:(b | c)
EQ:a == 0
EQ':b == 0
(0 * (b / gcd 0 b) | c)
a, b, c:t
Ha:(a | c)
Hb:(b | c)
NEQ:gcd a b ~= 0
(a * (b / gcd a b) | c) now nzsimpl.a, b, c:t
Ha:(a | c)
Hb:(b | c)
NEQ:gcd a b ~= 0
(a * (b / gcd a b) | c)
 assert (Ga := gcd_divide_l a b).a, b, c:t
Ha:(a | c)
Hb:(b | c)
NEQ:gcd a b ~= 0
Ga:(gcd a b | a)
(a * (b / gcd a b) | c)
 assert (Gb := gcd_divide_r a b).a, b, c:t
Ha:(a | c)
Hb:(b | c)
NEQ:gcd a b ~= 0
Ga:(gcd a b | a)
Gb:(gcd a b | b)
(a * (b / gcd a b) | c)
 set (g:=gcd a b) in *.a, b, c:t
Ha:(a | c)
Hb:(b | c)
g:=gcd a b:t
NEQ:g ~= 0
Ga:(g | a)
Gb:(g | b)
(a * (b / g) | c)
 assert (Ha' := divide_div g a c NEQ Ga Ha).a, b, c:t
Ha:(a | c)
Hb:(b | c)
g:=gcd a b:t
NEQ:g ~= 0
Ga:(g | a)
Gb:(g | b)
Ha':(a / g | c / g)
(a * (b / g) | c)
 assert (Hb' := divide_div g b c NEQ Gb Hb).a, b, c:t
Ha:(a | c)
Hb:(b | c)
g:=gcd a b:t
NEQ:g ~= 0
Ga:(g | a)
Gb:(g | b)
Ha':(a / g | c / g)
Hb':(b / g | c / g)
(a * (b / g) | c)
 destruct Ha' as (a',Ha').a, b, c:t
Ha:(a | c)
Hb:(b | c)
g:=gcd a b:t
NEQ:g ~= 0
Ga:(g | a)
Gb:(g | b)
a':t
Ha':c / g == a' * (a / g)
Hb':(b / g | c / g)
(a * (b / g) | c) rewrite Ha', mul_comm in Hb'.a, b, c:t
Ha:(a | c)
Hb:(b | c)
g:=gcd a b:t
NEQ:g ~= 0
Ga:(g | a)
Gb:(g | b)
a':t
Ha':c / g == a' * (a / g)
Hb':(b / g | a / g * a')
(a * (b / g) | c)
 apply gauss in Hb'; [|apply gcd_div_gcd; unfold g; trivial using gcd_comm].a, b, c:t
Ha:(a | c)
Hb:(b | c)
g:=gcd a b:t
NEQ:g ~= 0
Ga:(g | a)
Gb:(g | b)
a':t
Ha':c / g == a' * (a / g)
Hb':(b / g | a')
(a * (b / g) | c)
 destruct Hb' as (b',Hb').a, b, c:t
Ha:(a | c)
Hb:(b | c)
g:=gcd a b:t
NEQ:g ~= 0
Ga:(g | a)
Gb:(g | b)
a':t
Ha':c / g == a' * (a / g)
b':t
Hb':a' == b' * (b / g)
(a * (b / g) | c)
 exists b'.a, b, c:t
Ha:(a | c)
Hb:(b | c)
g:=gcd a b:t
NEQ:g ~= 0
Ga:(g | a)
Gb:(g | b)
a':t
Ha':c / g == a' * (a / g)
b':t
Hb':a' == b' * (b / g)
c == b' * (a * (b / g))
 rewrite mul_shuffle3, <- Hb'.a, b, c:t
Ha:(a | c)
Hb:(b | c)
g:=gcd a b:t
NEQ:g ~= 0
Ga:(g | a)
Gb:(g | b)
a':t
Ha':c / g == a' * (a / g)
b':t
Hb':a' == b' * (b / g)
c == a * a'
 rewrite (proj2 (div_exact c g NEQ)).a, b, c:t
Ha:(a | c)
Hb:(b | c)
g:=gcd a b:t
NEQ:g ~= 0
Ga:(g | a)
Gb:(g | b)
a':t
Ha':c / g == a' * (a / g)
b':t
Hb':a' == b' * (b / g)
g * (c / g) == a * a'
a, b, c:t
Ha:(a | c)
Hb:(b | c)
g:=gcd a b:t
NEQ:g ~= 0
Ga:(g | a)
Gb:(g | b)
a':t
Ha':c / g == a' * (a / g)
b':t
Hb':a' == b' * (b / g)
c mod g == 0
 rewrite Ha', mul_shuffle3, (mul_comm a a').a, b, c:t
Ha:(a | c)
Hb:(b | c)
g:=gcd a b:t
NEQ:g ~= 0
Ga:(g | a)
Gb:(g | b)
a':t
Ha':c / g == a' * (a / g)
b':t
Hb':a' == b' * (b / g)
a' * (g * (a / g)) == a' * a
a, b, c:t
Ha:(a | c)
Hb:(b | c)
g:=gcd a b:t
NEQ:g ~= 0
Ga:(g | a)
Gb:(g | b)
a':t
Ha':c / g == a' * (a / g)
b':t
Hb':a' == b' * (b / g)
c mod g == 0 f_equiv.a, b, c:t
Ha:(a | c)
Hb:(b | c)
g:=gcd a b:t
NEQ:g ~= 0
Ga:(g | a)
Gb:(g | b)
a':t
Ha':c / g == a' * (a / g)
b':t
Hb':a' == b' * (b / g)
g * (a / g) == a
a, b, c:t
Ha:(a | c)
Hb:(b | c)
g:=gcd a b:t
NEQ:g ~= 0
Ga:(g | a)
Gb:(g | b)
a':t
Ha':c / g == a' * (a / g)
b':t
Hb':a' == b' * (b / g)
c mod g == 0
 symmetry.a, b, c:t
Ha:(a | c)
Hb:(b | c)
g:=gcd a b:t
NEQ:g ~= 0
Ga:(g | a)
Gb:(g | b)
a':t
Ha':c / g == a' * (a / g)
b':t
Hb':a' == b' * (b / g)
a == g * (a / g)
a, b, c:t
Ha:(a | c)
Hb:(b | c)
g:=gcd a b:t
NEQ:g ~= 0
Ga:(g | a)
Gb:(g | b)
a':t
Ha':c / g == a' * (a / g)
b':t
Hb':a' == b' * (b / g)
c mod g == 0 apply div_exact; trivial.a, b, c:t
Ha:(a | c)
Hb:(b | c)
g:=gcd a b:t
NEQ:g ~= 0
Ga:(g | a)
Gb:(g | b)
a':t
Ha':c / g == a' * (a / g)
b':t
Hb':a' == b' * (b / g)
a mod g == 0
a, b, c:t
Ha:(a | c)
Hb:(b | c)
g:=gcd a b:t
NEQ:g ~= 0
Ga:(g | a)
Gb:(g | b)
a':t
Ha':c / g == a' * (a / g)
b':t
Hb':a' == b' * (b / g)
c mod g == 0
 apply mod_divide; trivial.a, b, c:t
Ha:(a | c)
Hb:(b | c)
g:=gcd a b:t
NEQ:g ~= 0
Ga:(g | a)
Gb:(g | b)
a':t
Ha':c / g == a' * (a / g)
b':t
Hb':a' == b' * (b / g)
c mod g == 0
 apply mod_divide; trivial.a, b, c:t
Ha:(a | c)
Hb:(b | c)
g:=gcd a b:t
NEQ:g ~= 0
Ga:(g | a)
Gb:(g | b)
a':t
Ha':c / g == a' * (a / g)
b':t
Hb':a' == b' * (b / g)
(g | c) transitivity a; trivial.
Qed.

Lemma lcm_comm : forall a b, lcm a b == lcm b a.forall a b : t, lcm a b == lcm b a
Proof.forall a b : t, lcm a b == lcm b a
 intros a b.a, b:t
lcm a b == lcm b a unfold lcm.a, b:t
a * (b / gcd a b) == b * (a / gcd b a) rewrite (gcd_comm b), (mul_comm b).a, b:t
a * (b / gcd a b) == a / gcd a b * b
 now rewrite <- gcd_div_swap.
Qed.

Lemma lcm_divide_iff : forall n m p,
  (lcm n m | p) <-> (n | p) /\ (m | p).forall n m p : t, (lcm n m | p) <-> (n | p) /\ (m | p)
Proof.forall n m p : t, (lcm n m | p) <-> (n | p) /\ (m | p)
 intros.n, m, p:t
(lcm n m | p) <-> (n | p) /\ (m | p) split.n, m, p:t
(lcm n m | p) -> (n | p) /\ (m | p)
n, m, p:t
(n | p) /\ (m | p) -> (lcm n m | p) split.n, m, p:t
H:(lcm n m | p)
(n | p)
n, m, p:t
H:(lcm n m | p)
(m | p)
n, m, p:t
(n | p) /\ (m | p) -> (lcm n m | p)
 transitivity (lcm n m); trivial using divide_lcm_l.n, m, p:t
H:(lcm n m | p)
(m | p)
n, m, p:t
(n | p) /\ (m | p) -> (lcm n m | p)
 transitivity (lcm n m); trivial using divide_lcm_r.n, m, p:t
(n | p) /\ (m | p) -> (lcm n m | p)
 intros (H,H').n, m, p:t
H:(n | p)
H':(m | p)
(lcm n m | p) now apply lcm_least.
Qed.

Lemma lcm_unique : forall n m p,
 0<=p -> (n|p) -> (m|p) ->
 (forall q, (n|q) -> (m|q) -> (p|q)) ->
 lcm n m == p.forall n m p : t,
0 <= p ->
(n | p) ->
(m | p) ->
(forall q : t, (n | q) -> (m | q) -> (p | q)) ->
lcm n m == p
Proof.forall n m p : t,
0 <= p ->
(n | p) ->
(m | p) ->
(forall q : t, (n | q) -> (m | q) -> (p | q)) ->
lcm n m == p
 intros n m p Hp Hn Hm H.n, m, p:t
Hp:0 <= p
Hn:(n | p)
Hm:(m | p)
H:forall q : t, (n | q) -> (m | q) -> (p | q)
lcm n m == p
 apply divide_antisym; trivial.n, m, p:t
Hp:0 <= p
Hn:(n | p)
Hm:(m | p)
H:forall q : t, (n | q) -> (m | q) -> (p | q)
(lcm n m | p)
n, m, p:t
Hp:0 <= p
Hn:(n | p)
Hm:(m | p)
H:forall q : t, (n | q) -> (m | q) -> (p | q)
(p | lcm n m)
 now apply lcm_least.n, m, p:t
Hp:0 <= p
Hn:(n | p)
Hm:(m | p)
H:forall q : t, (n | q) -> (m | q) -> (p | q)
(p | lcm n m)
 apply H.n, m, p:t
Hp:0 <= p
Hn:(n | p)
Hm:(m | p)
H:forall q : t, (n | q) -> (m | q) -> (p | q)
(n | lcm n m)
n, m, p:t
Hp:0 <= p
Hn:(n | p)
Hm:(m | p)
H:forall q : t, (n | q) -> (m | q) -> (p | q)
(m | lcm n m) apply divide_lcm_l.n, m, p:t
Hp:0 <= p
Hn:(n | p)
Hm:(m | p)
H:forall q : t, (n | q) -> (m | q) -> (p | q)
(m | lcm n m) apply divide_lcm_r.
Qed.

Lemma lcm_unique_alt : forall n m p, 0<=p ->
 (forall q, (p|q) <-> (n|q) /\ (m|q)) ->
 lcm n m == p.forall n m p : t,
0 <= p ->
(forall q : t, (p | q) <-> (n | q) /\ (m | q)) ->
lcm n m == p
Proof.forall n m p : t,
0 <= p ->
(forall q : t, (p | q) <-> (n | q) /\ (m | q)) ->
lcm n m == p
 intros n m p Hp H.n, m, p:t
Hp:0 <= p
H:forall q : t, (p | q) <-> (n | q) /\ (m | q)
lcm n m == p
 apply lcm_unique; trivial.n, m, p:t
Hp:0 <= p
H:forall q : t, (p | q) <-> (n | q) /\ (m | q)
(n | p)
n, m, p:t
Hp:0 <= p
H:forall q : t, (p | q) <-> (n | q) /\ (m | q)
(m | p)
n, m, p:t
Hp:0 <= p
H:forall q : t, (p | q) <-> (n | q) /\ (m | q)
forall q : t, (n | q) -> (m | q) -> (p | q)
 apply H, divide_refl.n, m, p:t
Hp:0 <= p
H:forall q : t, (p | q) <-> (n | q) /\ (m | q)
(m | p)
n, m, p:t
Hp:0 <= p
H:forall q : t, (p | q) <-> (n | q) /\ (m | q)
forall q : t, (n | q) -> (m | q) -> (p | q)
 apply H, divide_refl.n, m, p:t
Hp:0 <= p
H:forall q : t, (p | q) <-> (n | q) /\ (m | q)
forall q : t, (n | q) -> (m | q) -> (p | q)
 intros.n, m, p:t
Hp:0 <= p
H:forall q0 : t, (p | q0) <-> (n | q0) /\ (m | q0)
q:t
H0:(n | q)
H1:(m | q)
(p | q) apply H.n, m, p:t
Hp:0 <= p
H:forall q0 : t, (p | q0) <-> (n | q0) /\ (m | q0)
q:t
H0:(n | q)
H1:(m | q)
(n | q) /\ (m | q) now split.
Qed.

Lemma lcm_assoc : forall n m p, lcm n (lcm m p) == lcm (lcm n m) p.forall n m p : t, lcm n (lcm m p) == lcm (lcm n m) p
Proof.forall n m p : t, lcm n (lcm m p) == lcm (lcm n m) p
 intros.n, m, p:t
lcm n (lcm m p) == lcm (lcm n m) p apply lcm_unique_alt.n, m, p:t
0 <= lcm (lcm n m) p
n, m, p:t
forall q : t,
(lcm (lcm n m) p | q) <-> (n | q) /\ (lcm m p | q) apply le_0_l.n, m, p:t
forall q : t,
(lcm (lcm n m) p | q) <-> (n | q) /\ (lcm m p | q)
 intros.n, m, p, q:t
(lcm (lcm n m) p | q) <-> (n | q) /\ (lcm m p | q) now rewrite !lcm_divide_iff, and_assoc.
Qed.

Lemma lcm_0_l : forall n, lcm 0 n == 0.forall n : t, lcm 0 n == 0
Proof.forall n : t, lcm 0 n == 0
 intros.n:t
lcm 0 n == 0 apply lcm_unique; trivial.n:t
0 <= 0
n:t
(0 | 0)
n:t
(n | 0) order.n:t
(0 | 0)
n:t
(n | 0)
 apply divide_refl.n:t
(n | 0)
 apply divide_0_r.
Qed.

Lemma lcm_0_r : forall n, lcm n 0 == 0.forall n : t, lcm n 0 == 0
Proof.forall n : t, lcm n 0 == 0
 intros.n:t
lcm n 0 == 0 now rewrite lcm_comm, lcm_0_l.
Qed.

Lemma lcm_1_l : forall n, lcm 1 n == n.forall n : t, lcm 1 n == n
Proof.forall n : t, lcm 1 n == n
 intros.n:t
lcm 1 n == n apply lcm_unique; trivial using divide_1_l, le_0_l, divide_refl.
Qed.

Lemma lcm_1_r : forall n, lcm n 1 == n.forall n : t, lcm n 1 == n
Proof.forall n : t, lcm n 1 == n
 intros.n:t
lcm n 1 == n now rewrite lcm_comm, lcm_1_l.
Qed.

Lemma lcm_diag : forall n, lcm n n == n.forall n : t, lcm n n == n
Proof.forall n : t, lcm n n == n
 intros.n:t
lcm n n == n apply lcm_unique; trivial using divide_refl, le_0_l.
Qed.

Lemma lcm_eq_0 : forall n m, lcm n m == 0 <-> n == 0 \/ m == 0.forall n m : t, lcm n m == 0 <-> n == 0 \/ m == 0
Proof.forall n m : t, lcm n m == 0 <-> n == 0 \/ m == 0
 intros.n, m:t
lcm n m == 0 <-> n == 0 \/ m == 0 split.n, m:t
lcm n m == 0 -> n == 0 \/ m == 0
n, m:t
n == 0 \/ m == 0 -> lcm n m == 0
 intros EQ.n, m:t
EQ:lcm n m == 0
n == 0 \/ m == 0
n, m:t
n == 0 \/ m == 0 -> lcm n m == 0
 apply eq_mul_0.n, m:t
EQ:lcm n m == 0
n * m == 0
n, m:t
n == 0 \/ m == 0 -> lcm n m == 0
 apply divide_0_l.n, m:t
EQ:lcm n m == 0
(0 | n * m)
n, m:t
n == 0 \/ m == 0 -> lcm n m == 0 rewrite <- EQ.n, m:t
EQ:lcm n m == 0
(lcm n m | n * m)
n, m:t
n == 0 \/ m == 0 -> lcm n m == 0 apply lcm_least.n, m:t
EQ:lcm n m == 0
(n | n * m)
n, m:t
EQ:lcm n m == 0
(m | n * m)
n, m:t
n == 0 \/ m == 0 -> lcm n m == 0
  apply divide_factor_l.n, m:t
EQ:lcm n m == 0
(m | n * m)
n, m:t
n == 0 \/ m == 0 -> lcm n m == 0 apply divide_factor_r.n, m:t
n == 0 \/ m == 0 -> lcm n m == 0
 destruct 1 as [EQ|EQ]; rewrite EQ.n, m:t
EQ:n == 0
lcm 0 m == 0
n, m:t
EQ:m == 0
lcm n 0 == 0 apply lcm_0_l.n, m:t
EQ:m == 0
lcm n 0 == 0 apply lcm_0_r.
Qed.

Lemma divide_lcm_eq_r : forall n m, (n|m) -> lcm n m == m.forall n m : t, (n | m) -> lcm n m == m
Proof.forall n m : t, (n | m) -> lcm n m == m
 intros n m H.n, m:t
H:(n | m)
lcm n m == m apply lcm_unique_alt; trivial using le_0_l.n, m:t
H:(n | m)
forall q : t, (m | q) <-> (n | q) /\ (m | q)
 intros q.n, m:t
H:(n | m)
q:t
(m | q) <-> (n | q) /\ (m | q) split.n, m:t
H:(n | m)
q:t
(m | q) -> (n | q) /\ (m | q)
n, m:t
H:(n | m)
q:t
(n | q) /\ (m | q) -> (m | q) split; trivial.n, m:t
H:(n | m)
q:t
H0:(m | q)
(n | q)
n, m:t
H:(n | m)
q:t
(n | q) /\ (m | q) -> (m | q) now transitivity m.n, m:t
H:(n | m)
q:t
(n | q) /\ (m | q) -> (m | q)
 now destruct 1.
Qed.

Lemma divide_lcm_iff : forall n m, (n|m) <-> lcm n m == m.forall n m : t, (n | m) <-> lcm n m == m
Proof.forall n m : t, (n | m) <-> lcm n m == m
 intros n m.n, m:t
(n | m) <-> lcm n m == m split.n, m:t
(n | m) -> lcm n m == m
n, m:t
lcm n m == m -> (n | m) now apply divide_lcm_eq_r.n, m:t
lcm n m == m -> (n | m)
 intros EQ.n, m:t
EQ:lcm n m == m
(n | m) rewrite <- EQ.n, m:t
EQ:lcm n m == m
(n | lcm n m) apply divide_lcm_l.
Qed.

Lemma lcm_mul_mono_l :
  forall n m p, lcm (p * n) (p * m) == p * lcm n m.forall n m p : t, lcm (p * n) (p * m) == p * lcm n m
Proof.forall n m p : t, lcm (p * n) (p * m) == p * lcm n m
 intros n m p.n, m, p:t
lcm (p * n) (p * m) == p * lcm n m
 destruct (eq_decidable p 0) as [Hp|Hp].n, m, p:t
Hp:p == 0
lcm (p * n) (p * m) == p * lcm n m
n, m, p:t
Hp:p ~= 0
lcm (p * n) (p * m) == p * lcm n m
  rewrite Hp.n, m, p:t
Hp:p == 0
lcm (0 * n) (0 * m) == 0 * lcm n m
n, m, p:t
Hp:p ~= 0
lcm (p * n) (p * m) == p * lcm n m nzsimpl.n, m, p:t
Hp:p == 0
lcm 0 0 == 0
n, m, p:t
Hp:p ~= 0
lcm (p * n) (p * m) == p * lcm n m rewrite lcm_0_l.n, m, p:t
Hp:p == 0
0 == 0
n, m, p:t
Hp:p ~= 0
lcm (p * n) (p * m) == p * lcm n m now nzsimpl.n, m, p:t
Hp:p ~= 0
lcm (p * n) (p * m) == p * lcm n m
 destruct (eq_decidable (gcd n m) 0) as [Hg|Hg].n, m, p:t
Hp:p ~= 0
Hg:gcd n m == 0
lcm (p * n) (p * m) == p * lcm n m
n, m, p:t
Hp:p ~= 0
Hg:gcd n m ~= 0
lcm (p * n) (p * m) == p * lcm n m
  apply gcd_eq_0 in Hg.n, m, p:t
Hp:p ~= 0
Hg:n == 0 /\ m == 0
lcm (p * n) (p * m) == p * lcm n m
n, m, p:t
Hp:p ~= 0
Hg:gcd n m ~= 0
lcm (p * n) (p * m) == p * lcm n m destruct Hg as (Hn,Hm); rewrite Hn, Hm.n, m, p:t
Hp:p ~= 0
Hn:n == 0
Hm:m == 0
lcm (p * 0) (p * 0) == p * lcm 0 0
n, m, p:t
Hp:p ~= 0
Hg:gcd n m ~= 0
lcm (p * n) (p * m) == p * lcm n m
  nzsimpl.n, m, p:t
Hp:p ~= 0
Hn:n == 0
Hm:m == 0
lcm 0 0 == p * lcm 0 0
n, m, p:t
Hp:p ~= 0
Hg:gcd n m ~= 0
lcm (p * n) (p * m) == p * lcm n m rewrite lcm_0_l.n, m, p:t
Hp:p ~= 0
Hn:n == 0
Hm:m == 0
0 == p * 0
n, m, p:t
Hp:p ~= 0
Hg:gcd n m ~= 0
lcm (p * n) (p * m) == p * lcm n m now nzsimpl.n, m, p:t
Hp:p ~= 0
Hg:gcd n m ~= 0
lcm (p * n) (p * m) == p * lcm n m
 unfold lcm.n, m, p:t
Hp:p ~= 0
Hg:gcd n m ~= 0
p * n * (p * m / gcd (p * n) (p * m)) ==
p * (n * (m / gcd n m))
 rewrite gcd_mul_mono_l.n, m, p:t
Hp:p ~= 0
Hg:gcd n m ~= 0
p * n * (p * m / (p * gcd n m)) ==
p * (n * (m / gcd n m))
 rewrite mul_assoc.n, m, p:t
Hp:p ~= 0
Hg:gcd n m ~= 0
p * n * (p * m / (p * gcd n m)) ==
p * n * (m / gcd n m) f_equiv.n, m, p:t
Hp:p ~= 0
Hg:gcd n m ~= 0
p * m / (p * gcd n m) == m / gcd n m
 now rewrite div_mul_cancel_l.
Qed.

Lemma lcm_mul_mono_r :
 forall n m p, lcm (n * p) (m * p) == lcm n m * p.forall n m p : t, lcm (n * p) (m * p) == lcm n m * p
Proof.forall n m p : t, lcm (n * p) (m * p) == lcm n m * p
 intros n m p.n, m, p:t
lcm (n * p) (m * p) == lcm n m * p now rewrite !(mul_comm _ p), lcm_mul_mono_l, mul_comm.
Qed.

Lemma gcd_1_lcm_mul : forall n m, n~=0 -> m~=0 ->
 (gcd n m == 1 <-> lcm n m == n*m).forall n m : t,
n ~= 0 -> m ~= 0 -> gcd n m == 1 <-> lcm n m == n * m
Proof.forall n m : t,
n ~= 0 -> m ~= 0 -> gcd n m == 1 <-> lcm n m == n * m
 intros n m Hn Hm.n, m:t
Hn:n ~= 0
Hm:m ~= 0
gcd n m == 1 <-> lcm n m == n * m split; intros H.n, m:t
Hn:n ~= 0
Hm:m ~= 0
H:gcd n m == 1
lcm n m == n * m
n, m:t
Hn:n ~= 0
Hm:m ~= 0
H:lcm n m == n * m
gcd n m == 1
 unfold lcm.n, m:t
Hn:n ~= 0
Hm:m ~= 0
H:gcd n m == 1
n * (m / gcd n m) == n * m
n, m:t
Hn:n ~= 0
Hm:m ~= 0
H:lcm n m == n * m
gcd n m == 1 rewrite H.n, m:t
Hn:n ~= 0
Hm:m ~= 0
H:gcd n m == 1
n * (m / 1) == n * m
n, m:t
Hn:n ~= 0
Hm:m ~= 0
H:lcm n m == n * m
gcd n m == 1 now rewrite div_1_r.n, m:t
Hn:n ~= 0
Hm:m ~= 0
H:lcm n m == n * m
gcd n m == 1
 unfold lcm in *.n, m:t
Hn:n ~= 0
Hm:m ~= 0
H:n * (m / gcd n m) == n * m
gcd n m == 1
 apply mul_cancel_l in H; trivial.n, m:t
Hn:n ~= 0
Hm:m ~= 0
H:m / gcd n m == m
gcd n m == 1
 assert (Hg : gcd n m ~= 0) by (red; rewrite gcd_eq_0; destruct 1; order).n, m:t
Hn:n ~= 0
Hm:m ~= 0
H:m / gcd n m == m
Hg:gcd n m ~= 0
gcd n m == 1
 assert (H' := gcd_divide_r n m).n, m:t
Hn:n ~= 0
Hm:m ~= 0
H:m / gcd n m == m
Hg:gcd n m ~= 0
H':(gcd n m | m)
gcd n m == 1
 apply mod_divide in H'; trivial.n, m:t
Hn:n ~= 0
Hm:m ~= 0
H:m / gcd n m == m
Hg:gcd n m ~= 0
H':m mod gcd n m == 0
gcd n m == 1 apply div_exact in H'; trivial.n, m:t
Hn:n ~= 0
Hm:m ~= 0
H:m / gcd n m == m
Hg:gcd n m ~= 0
H':m == gcd n m * (m / gcd n m)
gcd n m == 1
 rewrite H in H'.n, m:t
Hn:n ~= 0
Hm:m ~= 0
H:m / gcd n m == m
Hg:gcd n m ~= 0
H':m == gcd n m * m
gcd n m == 1
 rewrite <- (mul_1_l m) in H' at 1.n, m:t
Hn:n ~= 0
Hm:m ~= 0
H:m / gcd n m == m
Hg:gcd n m ~= 0
H':1 * m == gcd n m * m
gcd n m == 1
 now apply mul_cancel_r in H'.
Qed.

End NLcmProp.