HighSchoolGeometry/0000755000076500007650000000000012540673470014231 5ustar coqcoq00000000000000HighSchoolGeometry/Droite_espace.v0000644000076500007650000001225012073525612017161 0ustar coqcoq00000000000000(* This program is free software; you can redistribute it and/or *) (* modify it under the terms of the GNU Lesser General Public License *) (* as published by the Free Software Foundation; either version 2.1 *) (* of the License, or (at your option) any later version. *) (* *) (* This program is distributed in the hope that it will be useful, *) (* but WITHOUT ANY WARRANTY; without even the implied warranty of *) (* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *) (* GNU General Public License for more details. *) (* *) (* You should have received a copy of the GNU Lesser General Public *) (* License along with this program; if not, write to the Free *) (* Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA *) (* 02110-1301 USA *) Require Export parallelisme_concours. Require Export coplanarite. Set Implicit Arguments. Unset Strict Implicit. Lemma paralleles_coplanaires : forall A B C D : PO, A <> B -> C <> D -> paralleles (droite A B) (droite C D) -> coplanaires A B C D. unfold coplanaires in |- *; intros A B C D H H10 H0. elim def_paralleles2 with (3 := H0); auto. intros k H1. elim (classic (k = 0)); intros. rewrite H2 in H1. absurd (A = B); auto. apply conversion_PP with (a := 1) (b := 1); auto with *. RingPP1 H1. RingPP. right; try assumption. exists (- / k). exists (/ k). apply mult_PP_regulier with k; auto. replace (mult_PP k (add_PP (cons (- / k) A) (add_PP (cons (/ k) B) (cons (1 + - (- / k + / k)) C)))) with (add_PP (cons (-1) A) (add_PP (cons 1 B) (cons k C))). RingPP1 H1. RingPP. FieldPP k. Qed. Lemma concours_coplanaires : forall A B C D : PO, A <> B :>PO -> C <> D :>PO -> concours (droite A B) (droite C D) -> coplanaires A B D C. unfold coplanaires in |- *; intros A B C D H20 H21 H11. elim def_concours2 with (A := A) (B := B) (C := C) (D := D); [ intros I H0; elim H0; intros H1 H2; try clear H0; try exact H2 | auto | auto | auto ]. hPPalignes H2 ipattern:k. hPPalignes H1 ipattern:k0. cut (add_PP (cons k C) (cons (1 + - k) D) = add_PP (cons k0 A) (cons (1 + - k0) B)); intros. elim (classic (k = 0)); intros. left; try assumption. unfold alignes, alignes1 in |- *. right; try assumption. rewrite H0 in H. exists k0. VReplace (cons 1 D) (cons (1 + -0) D). RingPP2 H; RingPP. right; try assumption. exists (/ k * k0). exists (/ k * (1 + - k0)). apply mult_PP_regulier with k; auto. VReplace (mult_PP k (cons 1 C)) (cons k C). RingPP1 H. FieldPP k. rewrite <- H2; trivial. Qed. Lemma droites_non_paralleles : forall A B C D : PO, A <> B :>PO -> C <> D :>PO -> ~ paralleles (droite C D) (droite A B) -> concours (droite C D) (droite A B) \/ ~ coplanaires A B C D. intros A B C D H20 H21 H; try assumption. elim (classic (coplanaires A B C D)); intros. left; try assumption. hPPcoplanaires H0 ipattern:a ipattern:b. apply def_concours with C; auto with geo. cut (a + b <> 0); intros. apply def_concours with (barycentre (cons a A) (cons b B)); auto. replace (barycentre (cons a A) (cons b B)) with (barycentre (cons (- (1 + - (a + b))) C) (cons 1 D)). apply barycentre_alignes. replace (- (1 + - (a + b)) + 1) with (a + b); auto. ring. apply conversion_PP with (a := - (1 + - (a + b)) + 1) (b := a + b). rewrite <- add_PP_barycentre; auto. rewrite <- add_PP_barycentre; auto. rewrite H0. RingPP. replace (- (1 + - (a + b)) + 1) with (a + b); auto. ring. replace (- (1 + - (a + b)) + 1) with (a + b); auto. ring. ring. apply barycentre_alignes; auto. unfold not in |- *; intros; apply H. apply def_paralleles with (- a); auto. rewrite H0. rewrite H1. replace b with (- a + (a + b)); auto. rewrite H1. RingPP. ring. right; try assumption. Qed. Lemma concours_sym : forall A B C D : PO, A <> B :>PO -> C <> D :>PO -> concours (droite A B) (droite C D) -> concours (droite C D) (droite A B). intros A B C D H10 H11 H; try assumption. elim def_concours2 with (3 := H); auto; intros. apply def_concours with x; auto. elim H0; intros H1 H2; try clear H0; try exact H2. elim H0; intros H1 H2; try clear H0; try exact H1. Qed. Hint Resolve concours_sym paralleles_sym paralleles_trans: geo. Theorem position_relative_droites_espace : forall A B C D : PO, A <> B :>PO -> C <> D :>PO -> ~ coplanaires A B C D \/ concours (droite A B) (droite C D) \/ paralleles (droite A B) (droite C D). intros A B C D H10 H; try assumption. elim (classic (paralleles (droite A B) (droite C D))); intros. right; right; try assumption. elim droites_non_paralleles with (A := A) (B := B) (C := C) (D := D); auto with geo; intros. Qed. Theorem position_relative_droites_coplanaires : forall A B C D : PO, A <> B :>PO -> C <> D :>PO -> coplanaires A B C D -> concours (droite A B) (droite C D) \/ paralleles (droite A B) (droite C D). intros A B C D H10 H H0; try assumption. elim position_relative_droites_espace with (A := A) (B := B) (C := C) (D := D); [ intros H1; try clear position_relative_droites_espace | intros H1; try clear position_relative_droites_espace; auto | auto | auto ]. absurd (coplanaires A B C D); auto. Qed.HighSchoolGeometry/Droite_plan_espace.v0000644000076500007650000003052312117747636020211 0ustar coqcoq00000000000000(* This program is free software; you can redistribute it and/or *) (* modify it under the terms of the GNU Lesser General Public License *) (* as published by the Free Software Foundation; either version 2.1 *) (* of the License, or (at your option) any later version. *) (* *) (* This program is distributed in the hope that it will be useful, *) (* but WITHOUT ANY WARRANTY; without even the implied warranty of *) (* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *) (* GNU General Public License for more details. *) (* *) (* You should have received a copy of the GNU Lesser General Public *) (* License along with this program; if not, write to the Free *) (* Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA *) (* 02110-1301 USA *) Require Export Droite_espace. Set Implicit Arguments. Unset Strict Implicit. Parameter PL : Type. Parameter incluse : DR -> PL -> Prop. Parameter plan : PO -> PO -> PO -> PL. Parameter para_plan_dr : PL -> DR -> Prop. Axiom droite_incluse_plan : forall A B C D E : PO, D <> E -> ~ alignes A B C -> incluse (droite D E) (plan A B C) -> coplanaires A B C D /\ coplanaires A B C E. Axiom droite_incluse_plan2 : forall A B C D E : PO, D <> E -> ~ alignes A B C -> coplanaires A B C D -> coplanaires A B C E -> incluse (droite D E) (plan A B C). Axiom coplanaire_trans3 : forall A B C D E F G : PO, ~ alignes A B C -> coplanaires A B C D -> coplanaires A B C E -> coplanaires A B C F -> coplanaires A B C G -> coplanaires D E F G. Lemma droites_coplanaires : forall A B C D E F G : PO, D <> E -> F <> G -> ~ alignes A B C -> incluse (droite D E) (plan A B C) -> incluse (droite F G) (plan A B C) -> concours (droite D E) (droite F G) \/ paralleles (droite D E) (droite F G). intros A B C D E F G H10 H11 H H0 H1; try assumption. intros. elim (classic (paralleles (droite D E) (droite F G))); intros; auto. left; try assumption. elim droites_non_paralleles with (3 := H2); intros; auto. absurd (coplanaires F G D E); auto. elim droite_incluse_plan with (3 := H1); intros; auto. elim droite_incluse_plan with (3 := H0); intros; auto. apply coplanaire_trans3 with (A := A) (B := B) (C := C); auto. Qed. Axiom def_para_plan_dr : forall A B C D E F G : PO, ~ alignes A B C -> D <> E -> F <> G -> coplanaires A B C D -> coplanaires A B C E -> paralleles (droite D E) (droite F G) -> para_plan_dr (plan A B C) (droite F G). Axiom def_para_plan_dr2 : forall A B C F G : PO, ~ alignes A B C -> F <> G -> para_plan_dr (plan A B C) (droite F G) -> exists D : PO, (exists E : PO, (coplanaires A B C D /\ coplanaires A B C E) /\ D <> E /\ paralleles (droite D E) (droite F G)). Lemma paralleles_droites_plan : forall A B C D E : PO, ~ alignes A B C -> A <> B -> D <> E -> paralleles (droite A B) (droite D E) -> para_plan_dr (plan A B C) (droite D E). intros. apply def_para_plan_dr with (D := A) (E := B); auto with geo. Qed. Lemma paralleles_droite_incluse : forall A B C D E : PO, ~ alignes A B C -> D <> E -> incluse (droite D E) (plan A B C) -> para_plan_dr (plan A B C) (droite D E). intros. elim droite_incluse_plan with (A := A) (B := B) (C := C) (D := D) (E := E); intros; auto. apply def_para_plan_dr with (D := D) (E := E); auto with geo. Qed. Lemma paralleles_droite_plan_coplanaires_incluse : forall A B C D E : PO, D <> E :>PO -> ~ alignes A B C -> para_plan_dr (plan A B C) (droite D E) -> coplanaires A B C D -> coplanaires A B C E. intros A B C D E H20 H H0 H1. unfold coplanaires in |- *. hPPcoplanaires H1 ipattern:a1 ipattern:b1. elim def_para_plan_dr2 with (3 := H0); auto. intros F H2; elim H2; intros G H3; elim H3; intros H4 H5; elim H5; intros H6 H7; try clear H5 H3 H2; try exact H7. elim H4; [ intros H2 H3; try clear H4; try exact H3 ]. hPPcoplanaires H2 ipattern:a ipattern:b. hPPcoplanaires H3 ipattern:a0 ipattern:b0. cut (paralleles (droite D E) (droite F G)); intros; auto with geo. elim def_paralleles2 with (3 := H4); auto; intros. right; try assumption. exists (x * a0 + (- x * a + a1)). exists (x * b0 + (- x * b + b1)). RingPP1 H5. VReplace (cons x G) (mult_PP x (cons 1 G)). VReplace (cons (- x) F) (mult_PP (- x) (cons 1 F)). VReplace (mult_PP (-1) (cons (-1) D)) (cons 1 D). rewrite H1; rewrite H3; rewrite H2. RingPP. Qed. Lemma paralleles_plan_droite_non_secants : forall A B C D E : PO, D <> E -> ~ alignes A B C -> para_plan_dr (plan A B C) (droite D E) -> ~ coplanaires A B C D -> ~ (exists I : PO, alignes D E I /\ coplanaires A B C I). intros. unfold not in |- *; intros. elim H3; intros I H4; elim H4; intros H5 H6; try clear H4 H3; try exact H6. elim def_para_plan_dr2 with (3 := H1); auto. intros F H3; elim H3; intros G H4; elim H4; intros H7 H8; elim H8; intros H9 H10; try clear H8 H4 H3; try exact H10. apply H2. cut (I <> D); intros. cut (para_plan_dr (plan A B C) (droite I D)); intros. apply paralleles_droite_plan_coplanaires_incluse with (3 := H4); auto. apply def_para_plan_dr with (D := F) (E := G); auto. elim H7; intros H13 H4; try clear H7; try exact H13. elim H7; intros H13 H4; try clear H7; try exact H4. apply paralleles_trans with D E; auto. generalize (alignes_paralleles (A:=D) (B:=E) (C:=I)); intros. apply paralleles_trans with D I; auto with geo. unfold not in |- *; intros; apply H2. rewrite <- H3; auto. Qed. Parameter contact : DR -> PL -> Prop. Axiom def_contact : forall A B C D E I : PO, D <> E -> ~ alignes A B C -> alignes D E I -> coplanaires A B C I -> contact (droite D E) (plan A B C). Axiom def_contact2 : forall A B C D E : PO, D <> E -> ~ alignes A B C -> contact (droite D E) (plan A B C) -> exists I : PO, alignes D E I /\ coplanaires A B C I. Definition perce (d : DR) (P : PL) := ~ incluse d P /\ contact d P. Lemma position_relative_plan_droite_paralleles : forall A B C D E : PO, D <> E -> ~ alignes A B C -> para_plan_dr (plan A B C) (droite D E) -> incluse (droite D E) (plan A B C) \/ ~ contact (droite D E) (plan A B C). intros. elim (classic (coplanaires A B C D)); intros. left; try assumption. apply droite_incluse_plan2; auto. apply paralleles_droite_plan_coplanaires_incluse with D; auto. right; try assumption. generalize (paralleles_plan_droite_non_secants (A:=A) (B:=B) (C:=C) (D:=D) (E:=E)); intros H7. unfold not in |- *; intros. elim H7; try assumption. apply def_contact2; auto. Qed. Lemma para_plan_dr_vecteur : forall A B C D E : PO, D <> E :>PO -> ~ alignes A B C -> para_plan_dr (plan A B C) (droite D E) -> exists k : R, (exists k' : R, vec D E = add_PP (mult_PP k (vec A B)) (mult_PP k' (vec A C))). intros A B C D E H30 H H0; unfold vec in |- *. elim def_para_plan_dr2 with (A := A) (B := B) (C := C) (F := D) (G := E); [ intros F H2; elim H2; intros G H3; try clear H2; try exact H3 | auto | auto | auto ]. elim H3; intros H2 H4; elim H4; intros H5 H6; try clear H4 H3; try exact H6. elim H2; [ intros H1 H3; try clear H2; try exact H3 ]. hPPcoplanaires H1 ipattern:a0 ipattern:b0. hPPcoplanaires H3 ipattern:a1 ipattern:b1. generalize (def_paralleles2 (A:=D) (B:=E) (C:=F) (D:=G)); intros H9. elim H9; [ intros k H2; try clear H9; try exact H1 | auto with geo | auto with geo | auto with geo ]. replace (add_PP (cons (-1) D) (cons 1 E)) with (add_PP (cons 1 E) (cons (-1) D)). rewrite H2. replace (cons k G) with (mult_PP k (cons 1 G)). replace (cons (- k) F) with (mult_PP (- k) (cons 1 F)). rewrite H3. rewrite H1. exists (k * (b1 + - b0)); exists (k * (a0 + b0 + - (a1 + b1))). RingPP. RingPP. RingPP. RingPP. Qed. Lemma vecteurs_para_plan_dr : forall (A B C D E : PO) (k k' : R), D <> E -> ~ alignes A B C -> vec D E = add_PP (mult_PP k (vec A B)) (mult_PP k' (vec A C)) -> para_plan_dr (plan A B C) (droite D E). intros. cut (ex (fun F : PO => vec A F = add_PP (mult_PP k (vec A B)) (mult_PP k' (vec A C)))); intros. elim H2; intros F H3; try clear H2; try exact H3. cut (vec A F = vec D E); intros. cut (A <> F). intros H30. apply def_para_plan_dr with (D := A) (E := F); auto with geo. unfold vec in H2. apply vecteur_def_coplanaires with (1 := H3); auto with geo. apply colineaires_paralleles with 1; auto with geo. rewrite H2; Ringvec. unfold not in |- *; intros; apply H. apply conversion_PP with (a := 1) (b := 1); auto with *. cut (vec D E = vec A F); intros. RingPP2 H5. rewrite H4. unfold vec in |- *. RingPP. auto with *. rewrite H3; auto. elim (classic (k' = - k)); intros. rewrite H2. replace (add_PP (mult_PP k (vec A B)) (mult_PP (- k) (vec A C))) with (mult_PP k (vec C B)). elim existence_representant_mult_vecteur with (A := A) (B := C) (C := B) (k := k); intros D0 H3; try clear existence_representant_mult_vecteur; try exact H3. exists D0; auto. unfold vec in |- *; RingPP. exists (barycentre (cons (1 + - (k + k')) A) (cons (k + k') (barycentre (cons k B) (cons k' C)))). unfold vec in |- *. pattern 1 at 2 in |- *. replace 1 with (1 + - (k + k') + (k + k')). repeat rewrite <- add_PP_barycentre; auto. RingPP. unfold not in |- *; intros; apply H2. replace k with (k + k' + - k'). rewrite H3. ring. ring. replace (1 + - (k + k') + (k + k')) with 1. auto with *. ring. ring. Qed. Lemma points_plan_espace : forall A B C D E : PO, ~ coplanaires A B C D -> (exists k : R, (exists k' : R, vec D E = add_PP (mult_PP k (vec A B)) (mult_PP k' (vec A C)))) \/ (exists a : R, (exists b : R, (exists d : R, add_PP (cons d D) (cons (1 + - d) E) = add_PP (cons a A) (add_PP (cons b B) (cons (1 + - (a + b)) C))))). intros A B C D E H0; try assumption. assert (~ alignes A B C). elim non_coplanaires_expl with (A := A) (B := B) (C := C) (D := D); [ intros H H1; try clear non_coplanaires_expl; try exact H | try trivial ]. elim repere_espace with (A := A) (B := B) (C := C) (D := D) (E := E); [ intros a H1; elim H1; intros b H2; elim H2; intros c H3; try clear H2 H1 repere_espace; try exact H3 | try trivial ]. elim (classic (a + b + c = 0)); intros. left. unfold vec in |- *. rewrite H3; rewrite H4. exists b; exists c. replace a with (- (b + c)). RingPP. replace a with (a + b + c + - (b + c)). rewrite H4; ring. ring. right. exists (/ (a + b + c) * a). exists (/ (a + b + c) * b). exists (/ (a + b + c) * (a + b + c + -1)). apply mult_PP_regulier with (a + b + c); auto. replace (mult_PP (a + b + c) (add_PP (cons (/ (a + b + c) * (a + b + c + -1)) D) (cons (1 + - (/ (a + b + c) * (a + b + c + -1))) E))) with (add_PP (cons (a + b + c + -1) D) (cons 1 E)). 2: FieldPP (a + b + c). rewrite H3. FieldPP (a + b + c). Qed. Theorem position_relative_droite_plan : forall A B C D E : PO, D <> E -> ~ alignes A B C -> para_plan_dr (plan A B C) (droite D E) \/ perce (droite D E) (plan A B C). unfold perce in |- *; intros. elim (classic (coplanaires A B C D)); intros. elim (classic (coplanaires A B C E)); intros. left; try assumption. apply paralleles_droite_incluse; auto. apply droite_incluse_plan2; auto. right; try assumption. split; [ idtac | try assumption ]. red in |- *; intros; apply H2. elim droite_incluse_plan with (A := A) (B := B) (C := C) (D := D) (E := E); [ try clear droite_incluse_plan; auto | auto | auto | auto ]. apply def_contact with D; auto with geo. lapply (points_plan_espace (A:=A) (B:=B) (C:=C) (D:=D) E); auto; intros. elim H2; [ intros H3; elim H3; [ intros k H4; elim H4; [ intros k' H5; try clear H4 H3 H2; try exact H5 ] ] | intros H3; try clear H2 ]. left; try assumption. apply vecteurs_para_plan_dr with (k := k) (k' := k'); auto. right; try assumption. elim H3; intros a H2; elim H2; intros b H4; elim H4; intros d H5; try clear H4 H2 H3; try exact H5. split; [ idtac | try assumption ]. red in |- *; intros; apply H1. elim droite_incluse_plan with (A := A) (B := B) (C := C) (D := D) (E := E); [ try clear droite_incluse_plan; auto | auto | auto | auto ]. apply def_contact with (barycentre (cons d D) (cons (1 + - d) E)); auto. apply barycentre_alignes; auto. replace (d + (1 + - d)) with 1. discrR. ring. unfold coplanaires, coplanaires1 in |- *. right; try assumption. pattern 1 at 1 in |- *. replace 1 with (d + (1 + - d)). rewrite <- add_PP_barycentre. rewrite H5. exists a; exists b; auto. replace (d + (1 + - d)) with 1. discrR. ring. ring. Qed.HighSchoolGeometry/Field_affine.v0000644000076500007650000001332412117747636016764 0ustar coqcoq00000000000000(* This program is free software; you can redistribute it and/or *) (* modify it under the terms of the GNU Lesser General Public License *) (* as published by the Free Software Foundation; either version 2.1 *) (* of the License, or (at your option) any later version. *) (* *) (* This program is distributed in the hope that it will be useful, *) (* but WITHOUT ANY WARRANTY; without even the implied warranty of *) (* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *) (* GNU General Public License for more details. *) (* *) (* You should have received a copy of the GNU Lesser General Public *) (* License along with this program; if not, write to the Free *) (* Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA *) (* 02110-1301 USA *) Require Export Rutile. Require Export Ring Field. Set Implicit Arguments. Unset Strict Implicit. Parameter PO : Type. Parameter PP : Type. Parameter add_PP : PP -> PP -> PP. Parameter mult_PP : R -> PP -> PP. Parameter cons : R -> PO -> PP. Parameter zero : PP. (* AM anneau abstrait*) Parameter AM : Type. Parameters (plusAM multAM minusAM : AM -> AM -> AM). Parameters (zeroAM : AM) (unAM : AM). Parameter oppAM : AM -> AM. Axiom AM_theory : ring_theory zeroAM unAM plusAM multAM minusAM oppAM (eq(A:=AM)). (* Injections de R, PO et PP dans AM*) Parameter fR : R -> AM. Parameter fPO : PO -> AM. Parameter fPP : PP -> AM. Axiom fPP_inj : forall A B : PP, fPP A = fPP B -> A = B. (* Transports des opérations *) Axiom fRadd : forall x y : R, fR (x + y) = plusAM (fR x) (fR y). Axiom fRmult : forall x y : R, fR (x * y) = multAM (fR x) (fR y). Axiom fRopp : forall x : R, fR (- x) = oppAM (fR x). Axiom fR0 : fR 0 = zeroAM. Axiom fR1 : fR 1 = unAM. Hypothesis fcons : forall (x : R) (A : PO), fPP (cons x A) = multAM (fR x) (fPO A). Axiom fmult : forall (x : R) (A : PP), fPP (mult_PP x A) = multAM (fR x) (fPP A). Axiom fadd : forall A B : PP, fPP (add_PP A B) = plusAM (fPP A) (fPP B). Axiom fzeroPP : fPP zero = zeroAM. (* Construction d'un corps *) Parameter invAM : AM -> AM. Definition divAM x y := multAM x (invAM y). Axiom fRinv : forall x : R, x <> 0 -> fR (/ x) = invAM (fR x). Axiom nonzeroAM : forall k : R, k <> 0 -> fR k <> zeroAM. Axiom invAM_l : forall x : AM, x <> zeroAM -> multAM (invAM x) x = unAM. Lemma AMField : field_theory zeroAM unAM plusAM multAM minusAM oppAM divAM invAM(eq(A:=AM)). constructor. apply AM_theory. rewrite <- fR1 in |- *; apply nonzeroAM; discrR. reflexivity. exact invAM_l. Qed. Add Field AMfield : AMField. (* Tactiques de simplification dans PP*) Ltac RewriteAM := repeat rewrite fcons || rewrite fmult || rewrite fadd || rewrite fRopp || rewrite fRadd || rewrite fRmult || rewrite fR0 || rewrite fzeroPP || (rewrite fRinv; [ idtac | auto ]) || rewrite fR1. Ltac RingPP := apply fPP_inj; RewriteAM; (ring || ring_simplify). Lemma l1 : forall A B C : PP, add_PP A B = C -> A = add_PP C (mult_PP (-1) B). intros. rewrite <- H. RingPP. Qed. Lemma l2 : forall A B C : PP, add_PP A B = C -> B = add_PP C (mult_PP (-1) A). intros. rewrite <- H. RingPP. Qed. Ltac RingPP1 H := rewrite (l1 H). Ltac RingPP2 H := rewrite (l2 H). Ltac FieldPP k := apply fPP_inj; RewriteAM; field; generalize (nonzeroAM (k:=k)); RewriteAM; auto. Lemma add_PP_zero : forall (P : PP) (A : PO), add_PP P (cons 0 A) = P. intros; RingPP. Qed. Lemma add_PP_A : forall (a b : R) (A : PO), add_PP (cons a A) (cons b A) = cons (a + b) A. intros; RingPP. Qed. Lemma add_PP_sym : forall P Q : PP, add_PP P Q = add_PP Q P. intros; RingPP. Qed. Lemma add_PP_assoc : forall P Q T : PP, add_PP P (add_PP Q T) = add_PP (add_PP P Q) T. intros; RingPP. Qed. Lemma def_mult_PP : forall (a k : R) (A : PO), mult_PP k (cons a A) = cons (k * a) A. intros; RingPP. Qed. Lemma mult_PP_1 : forall (a : R) (A : PO), mult_PP 1 (cons a A) = cons a A. intros; RingPP. Qed. Lemma mult_PP_0 : forall (a : R) (A : PO), mult_PP 0 (cons a A) = cons 0 A. intros; RingPP. Qed. Lemma distrib_mult_PP : forall (k : R) (P Q : PP), add_PP (mult_PP k P) (mult_PP k Q) = mult_PP k (add_PP P Q). intros; RingPP. Qed. Lemma distrib_mult_cons : forall (a b k : R) (A B : PO), add_PP (cons (k * a) A) (cons (k * b) B) = mult_PP k (add_PP (cons a A) (cons b B)). intros; RingPP. Qed. Lemma mult_PP_regulier : forall (k : R) (P Q : PP), k <> 0 -> mult_PP k P = mult_PP k Q -> P = Q :>PP. intros. replace P with (mult_PP (/ k) (mult_PP k P)). rewrite H0. FieldPP k. FieldPP k. Qed. Lemma add_PP_regulier : forall (P Q : PP) (a : R) (A : PO), add_PP P (cons a A) = add_PP Q (cons a A) :>PP -> P = Q :>PP. intros P Q c C H; try assumption. RingPP1 H. RingPP. Qed. Lemma add_PP_reg_gauche : forall (P Q : PP) (a : R) (A : PO), add_PP (cons a A) P = add_PP (cons a A) Q :>PP -> P = Q :>PP. intros P Q a A H; try assumption. RingPP2 H. RingPP. Qed. Lemma PP_0 : forall A B : PO, cons 0 A = cons 0 B. intros; RingPP. Qed. Lemma zero_add_PP : forall (P : PP) (A : PO), add_PP (cons 0 A) P = P :>PP. intros. RingPP. Qed. Lemma def_zero : forall A : PO, zero = cons 0 A. intros; RingPP. Qed. Lemma inversion_kPP : forall (k : R) (P Q : PP), k <> 0 -> P = mult_PP k Q -> Q = mult_PP (/ k) P :>PP. intros. rewrite H0. FieldPP k. Qed. Lemma cons_comp : forall (a b : R) (A B : PO), a = b -> A = B -> cons a A = cons b B. intros. rewrite H; rewrite H0; auto. Qed. Axiom cons_inj : forall (a b : R) (A B : PO), cons a A = cons b B -> a <> 0 -> a = b /\ A = B. HighSchoolGeometry/LICENSE0000644000076500007650000006350012073525613015236 0ustar coqcoq00000000000000 GNU LESSER GENERAL PUBLIC LICENSE Version 2.1, February 1999 Copyright (C) 1991, 1999 Free Software Foundation, Inc. 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA Everyone is permitted to copy and distribute verbatim copies of this license document, but changing it is not allowed. [This is the first released version of the Lesser GPL. It also counts as the successor of the GNU Library Public License, version 2, hence the version number 2.1.] Preamble The licenses for most software are designed to take away your freedom to share and change it. By contrast, the GNU General Public Licenses are intended to guarantee your freedom to share and change free software--to make sure the software is free for all its users. This license, the Lesser General Public License, applies to some specially designated software packages--typically libraries--of the Free Software Foundation and other authors who decide to use it. You can use it too, but we suggest you first think carefully about whether this license or the ordinary General Public License is the better strategy to use in any particular case, based on the explanations below. When we speak of free software, we are referring to freedom of use, not price. Our General Public Licenses are designed to make sure that you have the freedom to distribute copies of free software (and charge for this service if you wish); that you receive source code or can get it if you want it; that you can change the software and use pieces of it in new free programs; and that you are informed that you can do these things. To protect your rights, we need to make restrictions that forbid distributors to deny you these rights or to ask you to surrender these rights. These restrictions translate to certain responsibilities for you if you distribute copies of the library or if you modify it. For example, if you distribute copies of the library, whether gratis or for a fee, you must give the recipients all the rights that we gave you. You must make sure that they, too, receive or can get the source code. If you link other code with the library, you must provide complete object files to the recipients, so that they can relink them with the library after making changes to the library and recompiling it. And you must show them these terms so they know their rights. We protect your rights with a two-step method: (1) we copyright the library, and (2) we offer you this license, which gives you legal permission to copy, distribute and/or modify the library. To protect each distributor, we want to make it very clear that there is no warranty for the free library. Also, if the library is modified by someone else and passed on, the recipients should know that what they have is not the original version, so that the original author's reputation will not be affected by problems that might be introduced by others. Finally, software patents pose a constant threat to the existence of any free program. We wish to make sure that a company cannot effectively restrict the users of a free program by obtaining a restrictive license from a patent holder. Therefore, we insist that any patent license obtained for a version of the library must be consistent with the full freedom of use specified in this license. Most GNU software, including some libraries, is covered by the ordinary GNU General Public License. This license, the GNU Lesser General Public License, applies to certain designated libraries, and is quite different from the ordinary General Public License. We use this license for certain libraries in order to permit linking those libraries into non-free programs. When a program is linked with a library, whether statically or using a shared library, the combination of the two is legally speaking a combined work, a derivative of the original library. The ordinary General Public License therefore permits such linking only if the entire combination fits its criteria of freedom. The Lesser General Public License permits more lax criteria for linking other code with the library. We call this license the "Lesser" General Public License because it does Less to protect the user's freedom than the ordinary General Public License. It also provides other free software developers Less of an advantage over competing non-free programs. These disadvantages are the reason we use the ordinary General Public License for many libraries. However, the Lesser license provides advantages in certain special circumstances. For example, on rare occasions, there may be a special need to encourage the widest possible use of a certain library, so that it becomes a de-facto standard. To achieve this, non-free programs must be allowed to use the library. A more frequent case is that a free library does the same job as widely used non-free libraries. In this case, there is little to gain by limiting the free library to free software only, so we use the Lesser General Public License. In other cases, permission to use a particular library in non-free programs enables a greater number of people to use a large body of free software. For example, permission to use the GNU C Library in non-free programs enables many more people to use the whole GNU operating system, as well as its variant, the GNU/Linux operating system. Although the Lesser General Public License is Less protective of the users' freedom, it does ensure that the user of a program that is linked with the Library has the freedom and the wherewithal to run that program using a modified version of the Library. The precise terms and conditions for copying, distribution and modification follow. Pay close attention to the difference between a "work based on the library" and a "work that uses the library". The former contains code derived from the library, whereas the latter must be combined with the library in order to run. GNU LESSER GENERAL PUBLIC LICENSE TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION 0. This License Agreement applies to any software library or other program which contains a notice placed by the copyright holder or other authorized party saying it may be distributed under the terms of this Lesser General Public License (also called "this License"). Each licensee is addressed as "you". A "library" means a collection of software functions and/or data prepared so as to be conveniently linked with application programs (which use some of those functions and data) to form executables. The "Library", below, refers to any such software library or work which has been distributed under these terms. A "work based on the Library" means either the Library or any derivative work under copyright law: that is to say, a work containing the Library or a portion of it, either verbatim or with modifications and/or translated straightforwardly into another language. (Hereinafter, translation is included without limitation in the term "modification".) "Source code" for a work means the preferred form of the work for making modifications to it. For a library, complete source code means all the source code for all modules it contains, plus any associated interface definition files, plus the scripts used to control compilation and installation of the library. Activities other than copying, distribution and modification are not covered by this License; they are outside its scope. The act of running a program using the Library is not restricted, and output from such a program is covered only if its contents constitute a work based on the Library (independent of the use of the Library in a tool for writing it). Whether that is true depends on what the Library does and what the program that uses the Library does. 1. You may copy and distribute verbatim copies of the Library's complete source code as you receive it, in any medium, provided that you conspicuously and appropriately publish on each copy an appropriate copyright notice and disclaimer of warranty; keep intact all the notices that refer to this License and to the absence of any warranty; and distribute a copy of this License along with the Library. You may charge a fee for the physical act of transferring a copy, and you may at your option offer warranty protection in exchange for a fee. 2. You may modify your copy or copies of the Library or any portion of it, thus forming a work based on the Library, and copy and distribute such modifications or work under the terms of Section 1 above, provided that you also meet all of these conditions: a) The modified work must itself be a software library. b) You must cause the files modified to carry prominent notices stating that you changed the files and the date of any change. c) You must cause the whole of the work to be licensed at no charge to all third parties under the terms of this License. d) If a facility in the modified Library refers to a function or a table of data to be supplied by an application program that uses the facility, other than as an argument passed when the facility is invoked, then you must make a good faith effort to ensure that, in the event an application does not supply such function or table, the facility still operates, and performs whatever part of its purpose remains meaningful. (For example, a function in a library to compute square roots has a purpose that is entirely well-defined independent of the application. Therefore, Subsection 2d requires that any application-supplied function or table used by this function must be optional: if the application does not supply it, the square root function must still compute square roots.) These requirements apply to the modified work as a whole. If identifiable sections of that work are not derived from the Library, and can be reasonably considered independent and separate works in themselves, then this License, and its terms, do not apply to those sections when you distribute them as separate works. But when you distribute the same sections as part of a whole which is a work based on the Library, the distribution of the whole must be on the terms of this License, whose permissions for other licensees extend to the entire whole, and thus to each and every part regardless of who wrote it. Thus, it is not the intent of this section to claim rights or contest your rights to work written entirely by you; rather, the intent is to exercise the right to control the distribution of derivative or collective works based on the Library. In addition, mere aggregation of another work not based on the Library with the Library (or with a work based on the Library) on a volume of a storage or distribution medium does not bring the other work under the scope of this License. 3. You may opt to apply the terms of the ordinary GNU General Public License instead of this License to a given copy of the Library. To do this, you must alter all the notices that refer to this License, so that they refer to the ordinary GNU General Public License, version 2, instead of to this License. (If a newer version than version 2 of the ordinary GNU General Public License has appeared, then you can specify that version instead if you wish.) Do not make any other change in these notices. Once this change is made in a given copy, it is irreversible for that copy, so the ordinary GNU General Public License applies to all subsequent copies and derivative works made from that copy. This option is useful when you wish to copy part of the code of the Library into a program that is not a library. 4. You may copy and distribute the Library (or a portion or derivative of it, under Section 2) in object code or executable form under the terms of Sections 1 and 2 above provided that you accompany it with the complete corresponding machine-readable source code, which must be distributed under the terms of Sections 1 and 2 above on a medium customarily used for software interchange. If distribution of object code is made by offering access to copy from a designated place, then offering equivalent access to copy the source code from the same place satisfies the requirement to distribute the source code, even though third parties are not compelled to copy the source along with the object code. 5. A program that contains no derivative of any portion of the Library, but is designed to work with the Library by being compiled or linked with it, is called a "work that uses the Library". Such a work, in isolation, is not a derivative work of the Library, and therefore falls outside the scope of this License. However, linking a "work that uses the Library" with the Library creates an executable that is a derivative of the Library (because it contains portions of the Library), rather than a "work that uses the library". The executable is therefore covered by this License. Section 6 states terms for distribution of such executables. When a "work that uses the Library" uses material from a header file that is part of the Library, the object code for the work may be a derivative work of the Library even though the source code is not. Whether this is true is especially significant if the work can be linked without the Library, or if the work is itself a library. The threshold for this to be true is not precisely defined by law. If such an object file uses only numerical parameters, data structure layouts and accessors, and small macros and small inline functions (ten lines or less in length), then the use of the object file is unrestricted, regardless of whether it is legally a derivative work. (Executables containing this object code plus portions of the Library will still fall under Section 6.) Otherwise, if the work is a derivative of the Library, you may distribute the object code for the work under the terms of Section 6. Any executables containing that work also fall under Section 6, whether or not they are linked directly with the Library itself. 6. As an exception to the Sections above, you may also combine or link a "work that uses the Library" with the Library to produce a work containing portions of the Library, and distribute that work under terms of your choice, provided that the terms permit modification of the work for the customer's own use and reverse engineering for debugging such modifications. You must give prominent notice with each copy of the work that the Library is used in it and that the Library and its use are covered by this License. You must supply a copy of this License. If the work during execution displays copyright notices, you must include the copyright notice for the Library among them, as well as a reference directing the user to the copy of this License. Also, you must do one of these things: a) Accompany the work with the complete corresponding machine-readable source code for the Library including whatever changes were used in the work (which must be distributed under Sections 1 and 2 above); and, if the work is an executable linked with the Library, with the complete machine-readable "work that uses the Library", as object code and/or source code, so that the user can modify the Library and then relink to produce a modified executable containing the modified Library. (It is understood that the user who changes the contents of definitions files in the Library will not necessarily be able to recompile the application to use the modified definitions.) b) Use a suitable shared library mechanism for linking with the Library. A suitable mechanism is one that (1) uses at run time a copy of the library already present on the user's computer system, rather than copying library functions into the executable, and (2) will operate properly with a modified version of the library, if the user installs one, as long as the modified version is interface-compatible with the version that the work was made with. c) Accompany the work with a written offer, valid for at least three years, to give the same user the materials specified in Subsection 6a, above, for a charge no more than the cost of performing this distribution. d) If distribution of the work is made by offering access to copy from a designated place, offer equivalent access to copy the above specified materials from the same place. e) Verify that the user has already received a copy of these materials or that you have already sent this user a copy. For an executable, the required form of the "work that uses the Library" must include any data and utility programs needed for reproducing the executable from it. However, as a special exception, the materials to be distributed need not include anything that is normally distributed (in either source or binary form) with the major components (compiler, kernel, and so on) of the operating system on which the executable runs, unless that component itself accompanies the executable. It may happen that this requirement contradicts the license restrictions of other proprietary libraries that do not normally accompany the operating system. Such a contradiction means you cannot use both them and the Library together in an executable that you distribute. 7. You may place library facilities that are a work based on the Library side-by-side in a single library together with other library facilities not covered by this License, and distribute such a combined library, provided that the separate distribution of the work based on the Library and of the other library facilities is otherwise permitted, and provided that you do these two things: a) Accompany the combined library with a copy of the same work based on the Library, uncombined with any other library facilities. This must be distributed under the terms of the Sections above. b) Give prominent notice with the combined library of the fact that part of it is a work based on the Library, and explaining where to find the accompanying uncombined form of the same work. 8. You may not copy, modify, sublicense, link with, or distribute the Library except as expressly provided under this License. Any attempt otherwise to copy, modify, sublicense, link with, or distribute the Library is void, and will automatically terminate your rights under this License. However, parties who have received copies, or rights, from you under this License will not have their licenses terminated so long as such parties remain in full compliance. 9. You are not required to accept this License, since you have not signed it. However, nothing else grants you permission to modify or distribute the Library or its derivative works. These actions are prohibited by law if you do not accept this License. Therefore, by modifying or distributing the Library (or any work based on the Library), you indicate your acceptance of this License to do so, and all its terms and conditions for copying, distributing or modifying the Library or works based on it. 10. Each time you redistribute the Library (or any work based on the Library), the recipient automatically receives a license from the original licensor to copy, distribute, link with or modify the Library subject to these terms and conditions. You may not impose any further restrictions on the recipients' exercise of the rights granted herein. You are not responsible for enforcing compliance by third parties with this License. 11. If, as a consequence of a court judgment or allegation of patent infringement or for any other reason (not limited to patent issues), conditions are imposed on you (whether by court order, agreement or otherwise) that contradict the conditions of this License, they do not excuse you from the conditions of this License. If you cannot distribute so as to satisfy simultaneously your obligations under this License and any other pertinent obligations, then as a consequence you may not distribute the Library at all. For example, if a patent license would not permit royalty-free redistribution of the Library by all those who receive copies directly or indirectly through you, then the only way you could satisfy both it and this License would be to refrain entirely from distribution of the Library. If any portion of this section is held invalid or unenforceable under any particular circumstance, the balance of the section is intended to apply, and the section as a whole is intended to apply in other circumstances. It is not the purpose of this section to induce you to infringe any patents or other property right claims or to contest validity of any such claims; this section has the sole purpose of protecting the integrity of the free software distribution system which is implemented by public license practices. Many people have made generous contributions to the wide range of software distributed through that system in reliance on consistent application of that system; it is up to the author/donor to decide if he or she is willing to distribute software through any other system and a licensee cannot impose that choice. This section is intended to make thoroughly clear what is believed to be a consequence of the rest of this License. 12. If the distribution and/or use of the Library is restricted in certain countries either by patents or by copyrighted interfaces, the original copyright holder who places the Library under this License may add an explicit geographical distribution limitation excluding those countries, so that distribution is permitted only in or among countries not thus excluded. In such case, this License incorporates the limitation as if written in the body of this License. 13. The Free Software Foundation may publish revised and/or new versions of the Lesser General Public License from time to time. Such new versions will be similar in spirit to the present version, but may differ in detail to address new problems or concerns. Each version is given a distinguishing version number. If the Library specifies a version number of this License which applies to it and "any later version", you have the option of following the terms and conditions either of that version or of any later version published by the Free Software Foundation. If the Library does not specify a license version number, you may choose any version ever published by the Free Software Foundation. 14. If you wish to incorporate parts of the Library into other free programs whose distribution conditions are incompatible with these, write to the author to ask for permission. For software which is copyrighted by the Free Software Foundation, write to the Free Software Foundation; we sometimes make exceptions for this. Our decision will be guided by the two goals of preserving the free status of all derivatives of our free software and of promoting the sharing and reuse of software generally. NO WARRANTY 15. BECAUSE THE LIBRARY IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY FOR THE LIBRARY, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES PROVIDE THE LIBRARY "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE LIBRARY IS WITH YOU. SHOULD THE LIBRARY PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION. 16. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR REDISTRIBUTE THE LIBRARY AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE LIBRARY (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A FAILURE OF THE LIBRARY TO OPERATE WITH ANY OTHER SOFTWARE), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES. END OF TERMS AND CONDITIONS How to Apply These Terms to Your New Libraries If you develop a new library, and you want it to be of the greatest possible use to the public, we recommend making it free software that everyone can redistribute and change. You can do so by permitting redistribution under these terms (or, alternatively, under the terms of the ordinary General Public License). To apply these terms, attach the following notices to the library. It is safest to attach them to the start of each source file to most effectively convey the exclusion of warranty; and each file should have at least the "copyright" line and a pointer to where the full notice is found. Copyright (C) This library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with this library; if not, write to the Free Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA Also add information on how to contact you by electronic and paper mail. You should also get your employer (if you work as a programmer) or your school, if any, to sign a "copyright disclaimer" for the library, if necessary. Here is a sample; alter the names: Yoyodyne, Inc., hereby disclaims all copyright interest in the library `Frob' (a library for tweaking knobs) written by James Random Hacker. , 1 April 1990 Ty Coon, President of Vice That's all there is to it! HighSchoolGeometry/Make0000644000076500007650000000234412073525611015026 0ustar coqcoq00000000000000-R . HighSchoolGeometry affine_classiques.v aire_signee.v alignement.v angles_droites.v angles_vecteurs.v applications_cocyclicite.v barycentre.v cercle.v cocyclicite.v complexes_conjugaison.v complexes_dilatations.v complexes_exercice.v complexes_similitudes.v complexes_transformations.v complexes.v composee_dilatations.v composee_reflexions.v composee_transformations.v composee_translation_rotation.v coplanarite.v determinant.v dilatations.v distance_euclidienne.v Droite_espace.v droite_Euler.v Droite_plan_espace.v equations_droites.v euclidien_classiques.v exercice_espace.v Field_affine.v formes_complexes.v homothetie_plane.v homoth_Euler.v isocele.v mediatrice.v mesure_algebrique.v metrique_triangle.v milieu.v operations_complexes.v orthocentre.v orthogonalite_espace.v orthogonalite.v parallelisme_concours.v Plan_espace.v Plans_paralleles.v produit_scalaire.v projection_orthogonale.v reflexion_plane.v repere_ortho_plan.v repere_plan.v representant_unitaire.v rotation_plane.v Rutile.v similitudes_directes.v trigo.v vecteur.v transformations_contact.v puissance_cercle.v inversion.v equations_cercles.v contact.v complexes_inversion.v complexes_analytique.v complements_cercle.v HighSchoolGeometry/Makefile0000644000076500007650000001305012277005420015657 0ustar coqcoq00000000000000########################################################################## ## v # The Coq Proof Assistant ## ## /dev/null || $(CAMLBIN)camlp4 -where) CAMLP4:=$(notdir $(CAMLP4LIB)) COQSRC:=-I $(COQTOP)/kernel -I $(COQTOP)/lib \ -I $(COQTOP)/library -I $(COQTOP)/parsing \ -I $(COQTOP)/pretyping -I $(COQTOP)/interp \ -I $(COQTOP)/proofs -I $(COQTOP)/syntax -I $(COQTOP)/tactics \ -I $(COQTOP)/toplevel -I $(COQTOP)/contrib/correctness \ -I $(COQTOP)/contrib/extraction -I $(COQTOP)/contrib/field \ -I $(COQTOP)/contrib/fourier -I $(COQTOP)/contrib/graphs \ -I $(COQTOP)/contrib/interface -I $(COQTOP)/contrib/jprover \ -I $(COQTOP)/contrib/omega -I $(COQTOP)/contrib/romega \ -I $(COQTOP)/contrib/ring -I $(COQTOP)/contrib/xml \ -I $(CAMLP4LIB) ZFLAGS:=$(OCAMLLIBS) $(COQSRC) OPT:= COQFLAGS:=-q $(OPT) $(COQLIBS) $(OTHERFLAGS) $(COQ_XML) COQC:=$(COQBIN)coqc COQDEP:=$(COQBIN)coqdep -c GALLINA:=$(COQBIN)gallina COQDOC:=$(COQBIN)coqdoc CAMLC:=$(CAMLBIN)ocamlc -rectypes -c CAMLOPTC:=$(CAMLBIN)ocamlopt -c CAMLLINK:=$(CAMLBIN)ocamlc CAMLOPTLINK:=$(CAMLBIN)ocamlopt GRAMMARS:=grammar.cma CAMLP4EXTEND:=pa_extend.cmo pa_macro.cmo q_MLast.cmo PP:=-pp "$(CAMLBIN)$(CAMLP4)o -I . -I $(COQTOP)/parsing $(CAMLP4EXTEND) $(GRAMMARS) -impl" ################################### # # # Definition of the "all" target. # # # ################################### VFILES:=affine_classiques.v\ aire_signee.v\ alignement.v\ angles_droites.v\ angles_vecteurs.v\ applications_cocyclicite.v\ barycentre.v\ cercle.v\ cocyclicite.v\ complexes_conjugaison.v\ complexes_dilatations.v\ complexes_exercice.v\ complexes_similitudes.v\ complexes_transformations.v\ complexes.v\ composee_dilatations.v\ composee_reflexions.v\ composee_transformations.v\ composee_translation_rotation.v\ coplanarite.v\ determinant.v\ dilatations.v\ distance_euclidienne.v\ Droite_espace.v\ droite_Euler.v\ Droite_plan_espace.v\ equations_droites.v\ euclidien_classiques.v\ exercice_espace.v\ Field_affine.v\ formes_complexes.v\ homothetie_plane.v\ homoth_Euler.v\ isocele.v\ mediatrice.v\ mesure_algebrique.v\ metrique_triangle.v\ milieu.v\ operations_complexes.v\ orthocentre.v\ orthogonalite_espace.v\ orthogonalite.v\ parallelisme_concours.v\ Plan_espace.v\ Plans_paralleles.v\ produit_scalaire.v\ projection_orthogonale.v\ reflexion_plane.v\ repere_ortho_plan.v\ repere_plan.v\ representant_unitaire.v\ rotation_plane.v\ Rutile.v\ similitudes_directes.v\ trigo.v\ vecteur.v\ transformations_contact.v\ puissance_cercle.v\ inversion.v\ equations_cercles.v\ contact.v\ complexes_inversion.v\ complexes_analytique.v\ complements_cercle.v VOFILES:=$(VFILES:.v=.vo) GLOBFILES:=$(VFILES:.v=.glob) VIFILES:=$(VFILES:.v=.vi) GFILES:=$(VFILES:.v=.g) HTMLFILES:=$(VFILES:.v=.html) GHTMLFILES:=$(VFILES:.v=.g.html) all: $(VOFILES) spec: $(VIFILES) gallina: $(GFILES) html: $(GLOBFILES) $(VFILES) - mkdir html $(COQDOC) -toc -html $(COQDOCLIBS) -d html $(VFILES) gallinahtml: $(GLOBFILES) $(VFILES) - mkdir html $(COQDOC) -toc -html -g $(COQDOCLIBS) -d html $(VFILES) all.ps: $(VFILES) $(COQDOC) -toc -ps $(COQDOCLIBS) -o $@ `$(COQDEP) -sort -suffix .v $(VFILES)` all-gal.ps: $(VFILES) $(COQDOC) -toc -ps -g $(COQDOCLIBS) -o $@ `$(COQDEP) -sort -suffix .v $(VFILES)` #################### # # # Special targets. # # # #################### .PHONY: all opt byte archclean clean install depend html %.vo %.glob: %.v $(COQC) -dump-glob $*.glob $(COQDEBUG) $(COQFLAGS) $* %.vi: %.v $(COQC) -i $(COQDEBUG) $(COQFLAGS) $* %.g: %.v $(GALLINA) $< %.tex: %.v $(COQDOC) -latex $< -o $@ %.html: %.v %.glob $(COQDOC) -glob-from $*.glob -html $< -o $@ %.g.tex: %.v $(COQDOC) -latex -g $< -o $@ %.g.html: %.v %.glob $(COQDOC) -glob-from $*.glob -html -g $< -o $@ %.v.d: %.v $(COQDEP) -glob -slash $(COQLIBS) "$<" > "$@" || ( RV=$$?; rm -f "$@"; exit $${RV} ) byte: $(MAKE) all "OPT:=-byte" opt: $(MAKE) all "OPT:=-opt" install: mkdir -p `$(COQC) -where`/user-contrib cp -f $(VOFILES) `$(COQC) -where`/user-contrib Makefile: Make mv -f Makefile Makefile.bak $(COQBIN)coq_makefile -f Make -o Makefile clean: rm -f *.cmo *.cmi *.cmx *.o $(VOFILES) $(VIFILES) $(GFILES) *~ rm -f all.ps all-gal.ps all.glob $(VFILES:.v=.glob) $(HTMLFILES) $(GHTMLFILES) $(VFILES:.v=.tex) $(VFILES:.v=.g.tex) $(VFILES:.v=.v.d) - rm -rf html archclean: rm -f *.cmx *.o -include $(VFILES:.v=.v.d) .SECONDARY: $(VFILES:.v=.v.d) # WARNING # # This Makefile has been automagically generated # Edit at your own risks ! # # END OF WARNING HighSchoolGeometry/Plan_espace.v0000644000076500007650000003136712117747636016652 0ustar coqcoq00000000000000(* This program is free software; you can redistribute it and/or *) (* modify it under the terms of the GNU Lesser General Public License *) (* as published by the Free Software Foundation; either version 2.1 *) (* of the License, or (at your option) any later version. *) (* *) (* This program is distributed in the hope that it will be useful, *) (* but WITHOUT ANY WARRANTY; without even the implied warranty of *) (* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *) (* GNU General Public License for more details. *) (* *) (* You should have received a copy of the GNU Lesser General Public *) (* License along with this program; if not, write to the Free *) (* Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA *) (* 02110-1301 USA *) Require Export Plans_paralleles. Set Implicit Arguments. Unset Strict Implicit. Parameter secants : PL -> PL -> Prop. Axiom def_secants : forall A B C D E F I J : PO, ~ alignes A B C -> ~ alignes D E F -> I <> J -> incluse (droite I J) (plan A B C) -> incluse (droite I J) (plan D E F) -> ~ para_plan_plan (plan A B C) (plan D E F) -> secants (plan A B C) (plan D E F). Axiom def_secants2 : forall A B C D E F : PO, ~ alignes A B C -> ~ alignes D E F -> secants (plan A B C) (plan D E F) -> ~ para_plan_plan (plan A B C) (plan D E F) /\ (exists I : PO, (exists J : PO, I <> J /\ incluse (droite I J) (plan A B C) /\ incluse (droite I J) (plan D E F))). Theorem position_relative_plans : forall A B C D E F : PO, ~ alignes A B C -> ~ alignes D E F -> para_plan_plan (plan A B C) (plan D E F) \/ secants (plan A B C) (plan D E F). intros. lapply (plans_paralleles_ou_droite_incluse2 (A:=A) (B:=B) (C:=C) (D:=D) (E:=E) (F:=F)); intros; auto. elim H1; [ intros H2; try clear H1 | intros H2; elim H2; [ intros I H3; elim H3; [ intros J H4; elim H4; [ intros H5 H6; elim H6; [ intros H7 H8; try clear H6 H4 H3 H2 H1; try trivial ] ] ] ] | try trivial ]. left; try assumption. elim (classic (para_plan_plan (plan A B C) (plan D E F))); intros. left; try assumption. right; try assumption. apply def_secants with (I := I) (J := J); auto. Qed. Theorem toit : forall A B C D E F : PO, ~ alignes A B C -> ~ alignes D E F -> paralleles (droite D E) (droite A B) -> ~ para_plan_plan (plan A B C) (plan D E F) -> exists I : PO, (exists J : PO, (I <> J :>PO /\ paralleles (droite A B) (droite I J)) /\ incluse (droite I J) (plan A B C) /\ incluse (droite I J) (plan D E F)). intros. deroule_triangle A B C. deroule_triangle D E F. elim position_relative_droite_plan with (A := A) (B := B) (C := C) (D := D) (E := F); [ intros H9; try clear position_relative_droite_plan | unfold perce in |- *; intros H9; try clear position_relative_droite_plan; try exact H9 | try trivial | trivial ]. 2: elim H9; [ intros H10 H11; try clear H9; try exact H11 ]. absurd (para_plan_plan (plan A B C) (plan D E F)); auto. elim para_plan_dr_vecteur with (A := A) (B := B) (C := C) (D := D) (E := F); [ intros k H10; elim H10; [ intros k' H11; try clear H10 para_plan_dr_vecteur; auto ] | auto | auto | auto ]. elim paralleles_vecteur with (A := D) (B := E) (C := A) (D := B); [ intros k0 H12; try clear paralleles_vecteur; auto | auto | auto | auto ]. apply couple_vecteurs_coplanaires with (a := k0) (b := 0) (c := k) (d := k'); auto. rewrite H12; RingPP. elim def_contact2 with (A := A) (B := B) (C := C) (D := D) (E := F); [ intros I H12; try clear def_secants2 | trivial | trivial | trivial ]. elim H12; [ intros H9 H13; try clear H12; try exact H13 ]. exists I. elim existence_representant_vecteur with (A := I) (B := A) (C := B); intros J H14; try clear existence_representant_vecteur. exists J. cut (I <> J). intros H21. cut (paralleles (droite A B) (droite I J)). intros H16; try assumption. split; [ split; [ try assumption | idtac ] | idtac ]. try exact H16. split; [ try assumption | idtac ]. apply droite_incluse_plan2; auto. apply paralleles_droite_plan_coplanaires_incluse with (D := I) (E := J); auto. apply def_para_plan_dr with (D := A) (E := B); auto with geo. cut (coplanaires D E F I). intros H22. apply droite_incluse_plan2; auto. cut (paralleles (droite D E) (droite I J)); intros. apply paralleles_droite_plan_coplanaires_incluse with (D := I) (E := J); auto. apply def_para_plan_dr with (D := D) (E := E); auto with geo. apply paralleles_trans with (5 := H16); auto. auto with geo. apply colineaires_paralleles with 1; auto. rewrite H14; RingPP. unfold not in |- *; intros; apply H5. apply conversion_PP with (a := 1) (b := 1); auto with *. cut (vec A B = vec I J); intros. unfold vec in H15. RingPP2 H15. rewrite H12; RingPP. rewrite H14; auto. Qed. Lemma plans_paralleles_droite : forall A B C D E F I J : PO, ~ alignes A B C -> ~ alignes D E F -> I <> J -> para_plan_plan (plan A B C) (plan D E F) -> para_plan_dr (plan A B C) (droite I J) -> para_plan_dr (plan D E F) (droite I J). intros. deroule_triangle A B C. deroule_triangle D E F. elim para_plan_dr_vecteur with (A := A) (B := B) (C := C) (D := I) (E := J); [ intros k H10; elim H10; [ intros k' H11; try clear H10; try exact H11 ] | auto | auto | auto ]. elim plans_paralleles_vecteurs with (A := D) (B := E) (C := F) (D := A) (E := B) (F := C); auto. intros H10 H12; try assumption. elim H12; [ intros c H13; elim H13; [ intros d H14; try clear H13 H12; try exact H14 ] ]. elim H10; [ intros a H12; elim H12; [ intros b H13; try clear H12 H10; try exact H13 ] ]. cut (vec I J = add_PP (mult_PP k (add_PP (mult_PP a (vec D E)) (mult_PP b (vec D F)))) (mult_PP k' (add_PP (mult_PP c (vec D E)) (mult_PP d (vec D F))))); intros. apply vecteurs_para_plan_dr with (k := k * a + k' * c) (k' := k * b + k' * d); auto. rewrite H10; RingPP. rewrite H11; rewrite H14; rewrite H13; RingPP. apply para_plan_sym; auto. Qed. Lemma plans_paralleles_secants_droites_paralleles : forall A B C D E F I J K : PO, ~ alignes A B C -> ~ alignes D E F -> ~ alignes I J K -> para_plan_plan (plan A B C) (plan D E F) -> ~ para_plan_plan (plan A B C) (plan I J K) -> incluse (droite I J) (plan A B C) -> ex (fun G : PO => ex (fun L : PO => (G <> L /\ incluse (droite G L) (plan I J K)) /\ incluse (droite G L) (plan D E F) /\ paralleles (droite G L) (droite I J))). intros. deroule_triangle A B C. deroule_triangle D E F. deroule_triangle I J K. cut (para_plan_dr (plan D E F) (droite I J)); intros. elim position_relative_droite_plan with (A := D) (B := E) (C := F) (D := I) (E := K); [ intros H15; try clear position_relative_droite_plan | unfold perce in |- *; intros H15; try clear position_relative_droite_plan; try exact H15 | try trivial | try trivial ]. 2: elim H15; [ intros H16 H17; try clear H15; try exact H17 ]. cut (para_plan_plan (plan D E F) (plan I J K)); intros. absurd (para_plan_plan (plan A B C) (plan I J K)); auto. apply para_plan_trans with (D := D) (E := E) (F := F); auto. apply def_para_plan_plan; auto. elim def_contact2 with (3 := H17); [ intros G H15; elim H15; intros; try clear H15; auto | auto | auto ]. elim existence_representant_vecteur with (A := G) (B := I) (C := J); intros L H20; try clear existence_representant_vecteur. exists G; exists L. cut (G <> L); intros. cut (paralleles (droite G L) (droite I J)); intros. split; [ split; [ try assumption | idtac ] | idtac ]. cut (coplanaires I J K G); intros. apply droite_incluse_plan2; auto with geo. apply paralleles_droite_plan_coplanaires_incluse with (D := G) (E := L); auto. apply vecteurs_para_plan_dr with (k := 1) (k' := 0); auto. rewrite H20; RingPP. auto with geo. split; [ try assumption | auto ]. cut (para_plan_dr (plan D E F) (droite G L)); intros. apply droite_incluse_plan2; auto with geo. apply paralleles_droite_plan_coplanaires_incluse with (D := G) (E := L); auto. apply paralleles_droites_plan_trans with (D := I) (E := J); auto with geo. apply colineaires_paralleles with 1; auto with geo. rewrite H20; RingPP. unfold not in |- *; intros; apply H13. apply conversion_PP with (a := 1) (b := 1); auto with *. cut (vec I J = vec G L); intros. unfold vec in H21. RingPP2 H21. rewrite H15; RingPP. rewrite H20; auto. apply plans_paralleles_droite with (4 := H2); auto. apply paralleles_droite_incluse; auto. Qed. Parameter disjoints : PL -> PL -> Prop. Parameter confondus : PL -> PL -> Prop. Axiom def_disjoints : forall A B C D E F : PO, ~ alignes A B C -> ~ alignes D E F -> (forall I : PO, ~ (coplanaires A B C I /\ coplanaires D E F I)) -> disjoints (plan A B C) (plan D E F). Axiom def_disjoints2 : forall A B C D E F : PO, ~ alignes A B C -> ~ alignes D E F -> disjoints (plan A B C) (plan D E F) -> forall I : PO, ~ (coplanaires A B C I /\ coplanaires D E F I). Axiom def_confondus : forall A B C D E F : PO, ~ alignes A B C -> ~ alignes D E F -> (forall I : PO, coplanaires A B C I -> coplanaires D E F I) -> confondus (plan A B C) (plan D E F). Axiom def_confondus2 : forall A B C D E F : PO, ~ alignes A B C -> ~ alignes D E F -> confondus (plan A B C) (plan D E F) -> forall I : PO, coplanaires A B C I -> coplanaires D E F I. Lemma non_disjoints_exists : forall A B C D E F : PO, ~ alignes A B C -> ~ alignes D E F -> ~ disjoints (plan A B C) (plan D E F) -> exists I : PO, coplanaires A B C I /\ coplanaires D E F I. intros A B C D E F H H0 H1; try assumption. cut (~ (forall I : PO, ~ (coplanaires A B C I /\ coplanaires D E F I))); intros. elim not_all_not_ex with (U := PO) (P := fun I : PO => coplanaires A B C I /\ coplanaires D E F I); [ intros I H3; try clear not_all_not_ex; try exact H3 | auto ]. exists I; auto. red in |- *; (intros; apply H1). apply def_disjoints; auto. Qed. Theorem position_relative_plans_paralleles : forall A B C D E F : PO, ~ alignes A B C -> ~ alignes D E F -> para_plan_plan (plan A B C) (plan D E F) -> disjoints (plan A B C) (plan D E F) \/ confondus (plan A B C) (plan D E F). intros A B C D E F H H0 H3; try assumption. intros. assert (A <> B); auto with geo. assert (D <> E); auto with geo. elim (classic (disjoints (plan A B C) (plan D E F))); intros. left; try assumption. right; try assumption. elim non_disjoints_exists with (3 := H4); [ intros I H5; try clear non_disjoints_exists; try exact H3 | auto | auto ]. elim H5; [ intros H6 H7; try clear H5; try exact H6 ]. apply def_confondus; auto. intros J H5; try assumption. elim plans_paralleles_vecteurs with (A := D) (B := E) (C := F) (D := A) (E := B) (F := C); auto. intros. elim H9; intros c H10; elim H10; intros d H11; try clear H10 H9; try exact H11. elim H8; intros a H9; elim H9; intros b H10; try clear H9 H8; try exact H10. hcoplanaires H5 ipattern:x ipattern:k'. hcoplanaires H6 ipattern:x0 ipattern:k'0. hcoplanaires H7 ipattern:x1 ipattern:k'1. apply (vecteur_def_coplanaires (k:=x1 + -1 * (x0 * a + k'0 * c) + (x * a + k' * c)) (k':=k'1 + -1 * (x0 * b + k'0 * d) + (x * b + k' * d))). replace (vec D J) with (add_PP (add_PP (vec D I) (mult_PP (-1) (vec A I))) (vec A J)). rewrite H7. rewrite H6. rewrite H5. rewrite H10. rewrite H11. Ringvec. Ringvec. apply para_plan_sym; auto. Qed. Theorem position_relative_plans_general : forall A B C D E F : PO, ~ alignes A B C -> ~ alignes D E F -> (disjoints (plan A B C) (plan D E F) \/ confondus (plan A B C) (plan D E F)) \/ secants (plan A B C) (plan D E F). intros. assert (A <> B); auto with geo. assert (D <> E); auto with geo. elim (classic (para_plan_plan (plan A B C) (plan D E F))); intros. left; try assumption. apply position_relative_plans_paralleles; auto. right; try assumption. elim position_relative_plans with (A := A) (B := B) (C := C) (D := D) (E := E) (F := F); [ intros H4; try clear position_relative_plans | intros H4; try clear position_relative_plans; auto | auto | auto ]. tauto. Qed. Theorem position_relative_plans_non_disjoints : forall A B C D E F : PO, ~ alignes A B C -> ~ alignes D E F -> ~ disjoints (plan A B C) (plan D E F) -> secants (plan A B C) (plan D E F) \/ confondus (plan A B C) (plan D E F). intros. elim position_relative_plans_general with (A := A) (B := B) (C := C) (D := D) (E := E) (F := F); [ intros H2; elim H2; [ intros H3; try clear H2 position_relative_plans_general | intros H3; try clear H2 position_relative_plans_general; try exact H3 ] | intros H2 | auto | auto ]. elim H2; [ intros H4; try clear H2 | intros H4; try clear H2; try exact H4 ]. tauto. right; try assumption. elim H2; [ intros H4; try clear H2; try exact H4 | intros H4; try clear H2 ]. tauto. right; try assumption. left; try assumption. Qed.HighSchoolGeometry/Plans_paralleles.v0000644000076500007650000004415612117747636017721 0ustar coqcoq00000000000000(* This program is free software; you can redistribute it and/or *) (* modify it under the terms of the GNU Lesser General Public License *) (* as published by the Free Software Foundation; either version 2.1 *) (* of the License, or (at your option) any later version. *) (* *) (* This program is distributed in the hope that it will be useful, *) (* but WITHOUT ANY WARRANTY; without even the implied warranty of *) (* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *) (* GNU General Public License for more details. *) (* *) (* You should have received a copy of the GNU Lesser General Public *) (* License along with this program; if not, write to the Free *) (* Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA *) (* 02110-1301 USA *) Require Export Droite_plan_espace. Set Implicit Arguments. Unset Strict Implicit. Parameter para_plan_plan : PL -> PL -> Prop. Axiom def_para_plan_plan : forall A B C D E F : PO, ~ alignes A B C -> ~ alignes D E F -> para_plan_dr (plan A B C) (droite D E) -> para_plan_dr (plan A B C) (droite D F) -> para_plan_plan (plan A B C) (plan D E F). Axiom def_para_plan_plan2 : forall A B C D E F : PO, ~ alignes A B C -> ~ alignes D E F -> para_plan_plan (plan A B C) (plan D E F) -> para_plan_dr (plan A B C) (droite D E) /\ para_plan_dr (plan A B C) (droite D F). Lemma couple_vecteurs_coplanaires : forall (A B C D E F : PO) (a b c d : R), ~ alignes A B C -> ~ alignes D E F -> vec D E = add_PP (mult_PP a (vec A B)) (mult_PP b (vec A C)) :>PP -> vec D F = add_PP (mult_PP c (vec A B)) (mult_PP d (vec A C)) :>PP -> para_plan_plan (plan A B C) (plan D E F). intros. deroule_triangle D E F. apply def_para_plan_plan; auto. apply vecteurs_para_plan_dr with (k := a) (k' := b); auto. apply vecteurs_para_plan_dr with (k := c) (k' := d); auto. Qed. Lemma plans_paralleles_vecteurs : forall A B C D E F : PO, ~ alignes A B C -> ~ alignes D E F -> para_plan_plan (plan A B C) (plan D E F) -> (exists a : R, (exists b : R, vec D E = add_PP (mult_PP a (vec A B)) (mult_PP b (vec A C)) :>PP)) /\ (exists c : R, (exists d : R, vec D F = add_PP (mult_PP c (vec A B)) (mult_PP d (vec A C)) :>PP)). intros. elim def_para_plan_plan2 with (3 := H1); [ try clear def_para_plan_plan2; auto | auto | auto ]. intros. elim para_plan_dr_vecteur with (A := A) (B := B) (C := C) (D := D) (E := E); [ intros k H5; elim H5; intros k' H6; try clear H5 para_plan_dr_vecteur; try exact H6 | auto with geo | auto | auto ]. elim para_plan_dr_vecteur with (A := A) (B := B) (C := C) (D := D) (E := F); [ intros k0 H7; elim H7; intros k'0 H8; try clear H7 para_plan_dr_vecteur; try exact H8 | auto with geo | auto | auto ]. split; [ exists k | idtac ]. exists k'; auto. exists k0; exists k'0; auto. deroule_triangle D E F; auto. Qed. Lemma paralleles_droites_plan_trans : forall A B C D E F G : PO, ~ alignes A B C -> D <> E :>PO -> F <> G :>PO -> para_plan_dr (plan A B C) (droite D E) -> paralleles (droite D E) (droite F G) -> para_plan_dr (plan A B C) (droite F G). intros. elim def_para_plan_dr2 with (A := A) (B := B) (C := C) (F := D) (G := E); [ intros D0 H5; elim H5; intros E0 H6; elim H6; intros H7 H8; elim H8; intros H9 H10; try clear H8 H6 H5 def_para_plan_dr2; try exact H10 | auto | auto | auto ]. apply def_para_plan_dr with (D := D0) (E := E0); auto. elim H6; intros H4 H11; elim H4; intros H12 H13; try clear H4 H6; try exact H12. elim H7; intros H4 H11; try clear H7; try exact H11. apply paralleles_trans with (4 := H10); auto. Qed. Lemma para_plan_refl : forall A B C : PO, ~ alignes A B C -> para_plan_plan (plan A B C) (plan A B C). intros. deroule_triangle A B C. generalize (couple_vecteurs_coplanaires (A:=A) (B:=B) (C:=C) (D:=A) (E:=B) (F:=C) (a:=1) (b:=0) (c:=0) (d:=1)); intros H11; apply H11; auto. unfold vec in |- *; RingPP. unfold vec in |- *; RingPP. Qed. Lemma para_plan_sym : forall A B C D E F : PO, ~ alignes A B C -> ~ alignes D E F -> para_plan_plan (plan A B C) (plan D E F) -> para_plan_plan (plan D E F) (plan A B C). intros A B C D E F H H0 H1; try assumption. elim def_para_plan_plan2 with (A := A) (B := B) (C := C) (D := D) (E := E) (F := F); [ intros H2 H3; try clear def_para_plan_plan2; try exact H3 | auto | auto | auto ]. elim para_plan_dr_vecteur with (A := A) (B := B) (C := C) (D := D) (E := E); [ intros k H8; elim H8; intros k' H9; try clear H8 para_plan_dr_vecteur; auto | auto | auto | auto ]. elim para_plan_dr_vecteur with (A := A) (B := B) (C := C) (D := D) (E := F); [ intros k0 H10; elim H10; intros k'0 H11; try clear H10 para_plan_dr_vecteur; try exact H11 | auto | auto | auto ]. cut (ex (fun a : R => ex (fun b : R => vec A B = add_PP (mult_PP a (vec D E)) (mult_PP b (vec D F)))) /\ ex (fun c : R => ex (fun d : R => vec A C = add_PP (mult_PP c (vec D E)) (mult_PP d (vec D F))))). intros H12. elim H12; intros H13 H14; elim H13; intros a H15; elim H15; intros b H16; try clear H15 H13 H12; try exact H16. elim H14; intros c H12; elim H12; intros d H13; try clear H12 H14; try exact H13. apply couple_vecteurs_coplanaires with (a := a) (b := b) (c := c) (d := d); auto. cut (mult_PP k (vec D F) = add_PP (mult_PP (k * k0) (vec A B)) (mult_PP (k * k'0) (vec A C))); intros. cut (mult_PP k' (vec D F) = add_PP (mult_PP (k' * k0) (vec A B)) (mult_PP (k' * k'0) (vec A C))); intros. cut (mult_PP k0 (vec D E) = add_PP (mult_PP (k0 * k) (vec A B)) (mult_PP (k0 * k') (vec A C))); intros. cut (mult_PP k'0 (vec D E) = add_PP (mult_PP (k'0 * k) (vec A B)) (mult_PP (k'0 * k') (vec A C))); intros. cut (add_PP (mult_PP k (vec D F)) (mult_PP (- k0) (vec D E)) = mult_PP (k * k'0 + - (k0 * k')) (vec A C)); intros. cut (add_PP (mult_PP k' (vec D F)) (mult_PP (- k'0) (vec D E)) = mult_PP (k' * k0 + - (k'0 * k)) (vec A B)); intros. elim (classic (k * k'0 + - (k0 * k') = 0)); intros. cut (k' * k0 + - (k'0 * k) = 0); intros. rewrite H15 in H13. rewrite H14 in H12. elim (classic (k = 0)); intros. rewrite H16 in H15. rewrite H16 in H9. elim (classic (k' = 0)); intros. rewrite H17 in H9. absurd (D = E); auto with geo. apply conversion_PP with (a := 1) (b := 1); auto with *. unfold vec in H9. RingPP2 H9; RingPP. cut (k0 = 0); intros. clear H10; clear H8. rewrite H18 in H11. elim (classic (k'0 = 0)); intros. rewrite H8 in H11. absurd (D = F). apply non_alignes_distincts with E; auto. apply conversion_PP with (a := 1) (b := 1); auto with *. unfold vec in H11. RingPP2 H11; RingPP. absurd (alignes D E F); auto. apply colineaire_alignes with (k'0 * / k'); auto. rewrite H11; rewrite H9. unfold vec in |- *. FieldPP k'. cut (k' * k0 = 0); intros. RReplace k0 (/ k' * (k' * k0)). rewrite H18; field; auto. field; auto. rewrite <- H15; ring. absurd (alignes D E F); auto. apply colineaire_alignes with (/ k * k0); auto. cut (mult_PP k (vec D F) = mult_PP k0 (vec D E)); intros. apply mult_PP_regulier with k; auto. rewrite H17. FieldPP k. VReplace (mult_PP k0 (vec D E)) (add_PP (mult_PP k0 (vec D E)) (mult_PP 0 (vec A C))). rewrite <- H12; RingPP. RReplace (k' * k0 + - (k'0 * k)) (- (k * k'0 + - (k0 * k'))). rewrite H14; ring. cut (k' * k0 + - (k'0 * k) <> 0); intros. split; [ try assumption | idtac ]. exists (/ (k' * k0 + - (k'0 * k)) * - k'0); exists (/ (k' * k0 + - (k'0 * k)) * k'). apply mult_PP_regulier with (k' * k0 + - (k'0 * k)); auto. rewrite <- H13. FieldPP (k' * k0 + - (k'0 * k)). exists (/ (k * k'0 + - (k0 * k')) * - k0); exists (/ (k * k'0 + - (k0 * k')) * k). apply mult_PP_regulier with (k * k'0 + - (k0 * k')); auto with real. rewrite <- H12. FieldPP (k * k'0 + - (k0 * k')). RReplace (k' * k0 + - (k'0 * k)) (- (k * k'0 + - (k0 * k'))). auto with real. replace (mult_PP (- k'0) (vec D E)) with (add_PP (mult_PP (- k'0 * k) (vec A B)) (mult_PP (- k'0 * k') (vec A C))). rewrite H11; RingPP. apply mult_PP_regulier with (-1); auto with real. VReplace (mult_PP (-1) (mult_PP (- k'0) (vec D E))) (mult_PP k'0 (vec D E)). rewrite H7; RingPP. replace (mult_PP (- k0) (vec D E)) with (add_PP (mult_PP (- k0 * k) (vec A B)) (mult_PP (- k0 * k') (vec A C))). rewrite H4; RingPP. apply mult_PP_regulier with (-1); auto with real. VReplace (mult_PP (-1) (mult_PP (- k0) (vec D E))) (mult_PP k0 (vec D E)). rewrite H6; RingPP. rewrite H9; RingPP. rewrite H9; RingPP. rewrite H11; RingPP. rewrite H11; RingPP. apply non_alignes_distincts with E; auto. auto with geo. Qed. Lemma para_plan_trans : forall A B C D E F G H I : PO, ~ alignes A B C -> ~ alignes D E F -> ~ alignes G H I -> para_plan_plan (plan A B C) (plan D E F) -> para_plan_plan (plan D E F) (plan G H I) -> para_plan_plan (plan A B C) (plan G H I). intros A B C D E F G H I H0 H1 H2 H3 H4; try assumption. deroule_triangle A B C. deroule_triangle D E F. deroule_triangle G H I. elim def_para_plan_plan2 with (A := A) (B := B) (C := C) (D := D) (E := E) (F := F); [ intros H14 H15; try clear def_para_plan_plan2; auto | auto | auto | auto ]. elim def_para_plan_plan2 with (A := D) (B := E) (C := F) (D := G) (E := H) (F := I); [ intros; auto | auto | auto | auto ]. elim def_para_plan_plan2 with (A := D) (B := E) (C := F) (D := G) (E := H) (F := I); [ try clear def_para_plan_plan2; auto | auto | auto | auto ]. intros. elim para_plan_dr_vecteur with (A := A) (B := B) (C := C) (D := D) (E := E); [ intros k H20; elim H20; [ intros k' H21; try clear H20; auto ] | auto | auto | auto ]. elim para_plan_dr_vecteur with (A := A) (B := B) (C := C) (D := D) (E := F); [ intros k0 H22; elim H22; [ intros k'0 H23; try clear H22; auto ] | auto | auto | auto ]. elim para_plan_dr_vecteur with (A := D) (B := E) (C := F) (D := G) (E := H); [ intros k1 H20; elim H20; [ intros k'1 H22; try clear H20; auto ] | auto | auto | auto ]. elim para_plan_dr_vecteur with (A := D) (B := E) (C := F) (D := G) (E := I); [ intros k2 H20; elim H20; [ intros k'2 H24; try clear H20; auto ] | auto | auto | auto ]. cut (ex (fun a : R => ex (fun b : R => vec G I = add_PP (mult_PP a (vec A B)) (mult_PP b (vec A C)))) /\ ex (fun c : R => ex (fun d : R => vec G H = add_PP (mult_PP c (vec A B)) (mult_PP d (vec A C))))); intros. elim H20; [ intros H25 H26; elim H25; [ intros a H27; elim H27; [ intros b H28; try clear H27 H25 H20; try exact H28 ] ] ]. elim H26; [ intros c H20; elim H20; [ intros d H25; try clear H20 H26; try exact H25 ] ]. apply couple_vecteurs_coplanaires with (a := c) (b := d) (c := a) (d := b); auto. split; [ try assumption | idtac ]. cut (vec G I = add_PP (mult_PP k2 (add_PP (mult_PP k (vec A B)) (mult_PP k' (vec A C)))) (mult_PP k'2 (add_PP (mult_PP k0 (vec A B)) (mult_PP k'0 (vec A C))))); intros. exists (k2 * k + k'2 * k0). exists (k2 * k' + k'2 * k'0). rewrite H20; RingPP. rewrite <- H21; rewrite <- H23; rewrite H24; auto. cut (vec G H = add_PP (mult_PP k1 (add_PP (mult_PP k (vec A B)) (mult_PP k' (vec A C)))) (mult_PP k'1 (add_PP (mult_PP k0 (vec A B)) (mult_PP k'0 (vec A C))))); intros. exists (k1 * k + k'1 * k0). exists (k1 * k' + k'1 * k'0). rewrite H20; RingPP. rewrite <- H21; rewrite <- H23; rewrite H22; auto. Qed. Lemma plans_paralleles_ou_droite_incluse2 : forall A B C D E F : PO, ~ alignes A B C -> ~ alignes D E F -> para_plan_plan (plan A B C) (plan D E F) \/ (exists I : PO, (exists J : PO, I <> J :>PO /\ incluse (droite I J) (plan A B C) /\ incluse (droite I J) (plan D E F))). intros A B C D E F H H0; try assumption. deroule_triangle D E F. elim position_relative_droite_plan with (A := A) (B := B) (C := C) (D := D) (E := E); [ intros H4; try clear position_relative_droite_plan | intros H4; try clear position_relative_droite_plan; try exact H4 | try trivial | try trivial ]. elim position_relative_droite_plan with (A := A) (B := B) (C := C) (D := D) (E := F); [ intros H5; try clear position_relative_droite_plan | intros H5; try clear position_relative_droite_plan; try exact H5 | try trivial | try trivial ]. left; try assumption. apply def_para_plan_plan; auto. elim H5; intros. elim def_contact2 with (A := A) (B := B) (C := C) (D := D) (E := F); [ intros J H8; elim H8; [ intros H9 H10; try clear H8 def_contact2; try exact H10 ] | try trivial | try trivial | try trivial ]. right; try assumption. elim existence_representant_vecteur with (A := J) (B := E) (C := D); intros I; intros; try clear existence_representant_vecteur. exists I; exists J. cut (I <> J). intros H30. split; [ trivial | split; [ idtac | try assumption ] ]. cut (para_plan_dr (plan A B C) (droite J I)); intros. apply droite_incluse_plan2; auto. apply paralleles_droite_plan_coplanaires_incluse with (3 := H12); auto. apply paralleles_droites_plan_trans with (4 := H4); auto. apply def_paralleles with (-1); auto. unfold vec in H11. VReplace (cons (-1) I) (mult_PP (-1) (cons 1 I)). RingPP2 H11. Ringvec. cut (coplanaires D E F J). intros H20. apply droite_incluse_plan2; auto. cut (para_plan_dr (plan D E F) (droite J I)); intros. apply paralleles_droite_plan_coplanaires_incluse with (3 := H12); auto. apply def_para_plan_dr with (D := D) (E := E); auto with geo. apply def_paralleles with (-1); auto. unfold vec in H11. VReplace (cons (-1) I) (mult_PP (-1) (cons 1 I)). RingPP2 H11. Ringvec. unfold coplanaires in |- *. hPPalignes H9 ipattern:k. right; try assumption. exists k; exists 0. rewrite H9; RingPP. unfold vec in H11. unfold not in |- *; intros; apply H3. apply conversion_PP with (a := 1) (b := 1); auto. cut (add_PP (cons (-1) E) (cons 1 D) = add_PP (cons (-1) J) (cons 1 I)); intros; auto. RingPP2 H13. rewrite H12; RingPP. auto with *. elim position_relative_droite_plan with (A := A) (B := B) (C := C) (D := D) (E := F); [ intros H5; try clear position_relative_droite_plan | unfold perce in |- *; intros H5; try clear position_relative_droite_plan; try exact H5 | try trivial | try trivial ]. elim def_contact2 with (A := A) (B := B) (C := C) (D := D) (E := E); [ intros J H6; elim H6; [ intros H7 H8; try clear H6 def_contact2; try exact H8 ] | try trivial | try trivial | try trivial ]. right; try assumption. elim existence_representant_vecteur with (A := J) (B := D) (C := F); intros I; intros; try clear existence_representant_vecteur; try exact H5. exists I; exists J. cut (I <> J). intros H30. split; [ trivial | split; [ idtac | try assumption ] ]. cut (para_plan_dr (plan A B C) (droite J I)); intros. apply droite_incluse_plan2; auto. apply paralleles_droite_plan_coplanaires_incluse with (3 := H10); auto. apply paralleles_droites_plan_trans with (4 := H5); auto. apply def_paralleles with 1; auto. unfold vec in H9; auto. RingPP2 H9. RingPP. cut (coplanaires D E F J); auto with geo. intros H20. apply droite_incluse_plan2; auto. cut (para_plan_dr (plan D E F) (droite J I)); intros. apply paralleles_droite_plan_coplanaires_incluse with (3 := H10); auto with geo. apply def_para_plan_dr with (D := D) (E := F); auto with geo. apply def_paralleles with 1; auto. unfold vec in H9. RingPP2 H9. RingPP. unfold vec in H9. unfold not in |- *; intros; apply H1. apply conversion_PP with (a := 1) (b := 1); auto. cut (add_PP (cons (-1) F) (cons 1 D) = add_PP (cons 1 J) (cons (-1) I)); intros; auto. RingPP2 H11. rewrite H10; RingPP. VReplace (cons (-1) I) (mult_PP (-1) (cons 1 I)). RingPP2 H9. RingPP. auto with *. unfold perce in H4. elim H4; [ intros H6 H7; try clear H4; try exact H7 ]. elim def_contact2 with (A := A) (B := B) (C := C) (D := D) (E := E); [ intros J H6; elim H6; [ intros H7 H8; try clear H6; try exact H8 ] | trivial | trivial | trivial ]. elim def_contact2 with (A := A) (B := B) (C := C) (D := D) (E := F); [ intros I H6; elim H6; [ intros H9 H10; try clear H6; try exact H10 ] | trivial | trivial | trivial ]. right. elim (classic (I = J)); intros. cut (I = D); intros. elim position_relative_droite_plan with (A := A) (B := B) (C := C) (D := E) (E := F); [ intros H12; try clear position_relative_droite_plan | unfold perce in |- *; intros H12; try clear position_relative_droite_plan; trivial | trivial | trivial ]. elim existence_representant_vecteur with (A := I) (B := E) (C := F); intros K H13; try clear existence_representant_vecteur. cut (E <> F); intros. cut (I <> K); intros. exists I; exists K. split; [ trivial | split; [ idtac | try assumption ] ]. apply droite_incluse_plan2; auto with geo. cut (para_plan_dr (plan A B C) (droite I K)); intros. apply paralleles_droite_plan_coplanaires_incluse with (3 := H16); auto with geo. apply paralleles_droites_plan_trans with (4 := H12); auto with geo. apply def_paralleles with 1; auto. unfold vec in H13. RingPP2 H13. RingPP. apply droite_incluse_plan2; auto with geo. apply paralleles_droite_plan_coplanaires_incluse with (D := I) (E := K); auto with geo. apply def_para_plan_dr with (D := E) (E := F); auto with geo. apply def_paralleles with 1; auto. unfold vec in H13. RingPP2 H13. RingPP. unfold not in |- *; intros; apply H14. apply conversion_PP with (a := 1) (b := 1); auto. unfold vec in H12. cut (add_PP (cons (-1) E) (cons 1 F) = add_PP (cons (-1) I) (cons 1 K)); intros; auto. RingPP2 H16. rewrite H15; RingPP. auto with *. unfold not in |- *; intros; apply H0. rewrite H14; auto with geo. elim H12; [ intros H13 H14; try clear H12; try exact H14 ]. elim def_contact2 with (A := A) (B := B) (C := C) (D := E) (E := F); [ intros K H12; try clear def_perce2; try exact H8 | trivial | trivial | trivial ]. elim H12; [ intros H15 H16; try clear H12; try exact H16 ]. exists I; exists K. cut (I <> K); intros. split; [ trivial | split; [ idtac | try assumption ] ]. apply droite_incluse_plan2; auto. apply droite_incluse_plan2; auto. rewrite H11; auto with geo. auto with geo. rewrite H11; auto. unfold not in |- *; intros; apply H0. rewrite H12; auto with geo. apply concours_unique with (A := D) (A1 := E) (B := F) (B1 := D); auto with geo. rewrite H6; auto. exists I; exists J. split; [ trivial | split; [ idtac | try assumption ] ]. apply droite_incluse_plan2; auto. apply droite_incluse_plan2; auto. auto with geo. auto with geo. elim H5; [ intros H6 H9; try clear H5; try exact H9 ]. elim H4; auto. Qed.HighSchoolGeometry/README0000644000076500007650000002037712073525614015117 0ustar coqcoq00000000000000========== The english part is after ================================= Ce développement propose une collection de "chapitres" couvrant une large partie du programme de géométrie du lycée en France. Le but n'est pas d'avoir un nombre minimal d'axiomes mais de "coller au plus près" des définitions, théorèmes et démonstrations donnés au lycée. Pour privilégier le raisonnement, la formalisation choisie n'utilise pas le recours à la méthode analytique. On trouvera expliquée en détail la démarche utilisée dans le rapport de recherche RR-4893 : "Premiers pas vers un cours de géométrie en Coq pour le lycée" disponible à : http://www.inria.fr/rrrt/rr-4893.html Dans la partie "géométrie affine (dimension 2 et 3)", sont formalisés - les points, vecteurs, barycentres, mesures algébriques, (Rutile.v, Field_affine.v, vecteur.v, barycentre.v, milieu.v, mesure_algebrique.v) - les notions d'alignement et de coplanarité, (alignement.v, coplanarite.v) - les notions de parallélisme et concours de droites, (parallelisme_concours.v) - les preuves des théorèmes de Thalès et de Desargues. (affine_classiques.v) Dans la partie "géométrie affine dans l'espace", ont été démontrés les théorèmes concernant: - les positions relatives de deux droites dans l'espace (Droite_espace.v) - les positions relatives d'une droite et d'un plan (Droite_plan_espace.v) - les positions relatives de deux plans (Plans_paralleles.v) - les propriétés d'incidence et de parallélisme de plusieurs droites et plans de l'espace. (Plan_espace.v) Dans la partie "géométrie euclidienne (dimension 2 et 3)", sont formalisés - le produit scalaire, la notion d'orthogonalité de vecteurs et de vecteurs unitaires, (produit_scalaire.v, orthogonalite.v, representant_unitaire.v) - la distance euclidienne et la projection orthogonale sur une droite. (distance_euclidienne.v, projection_orthogonale.v) - les preuves des théorèmes de Pythagore, de la médiane et l'étude de ligne de niveau (euclidien_classiques.v) Dans la partie "orthogonalité dans l'espace", est formalisée - la notion de droite et plan orthogonaux (orthogonalite_espace.v) - un exercice donné au baccalauréat S est traité comme application (exercice_espace.v). Dans la partie "géométrie euclidienne plane", sont formalisés - les repères affines, les repère orthogonaux et la notion de coordonnées de points (repere_plan.v, repere_ortho_plan.v) - les angles orientés de vecteurs et de droites (angles_vecteurs.v, angles_droites.v) - la trigonométrie (trigo.v) - la trigonométrie du triangle rectangle et les théorèmes d'Al-Kashi et des sinus (metrique_triangle.v) - les notions de médiatrice, triangle isocèle, orthocentre (mediatrice.v, isocele.v, orthocentre.v) - les notions de cercle, cocyclicité, contact (tangente et cercles tangents) (cercle.v, cocyclicite.v, complements_cercle.v, contact.v) - les notions d'aires signées et de déterminant de vecteurs (aire_signee.v, determinant.v) - une partie de géométrie analytique concernant les équations de droites et les équations de cercle (equations_droites.v, equations_cercles.v) Dans la partie "transformations planes", sont étudiées - les translations, homothéties et leur composées (dilatations.v, composee_dilatations.v, homothetie_plane.v) - les rotations, symétries axiales (rotation_plane.v, reflexion_plane.v) - les composées de ces transformations dont les similitudes directes. (composee_reflexions.v, composee_translation_rotation.v, composee_transformations.v, similitudes_directes.v) - les propriétés de conservation du contact par ces transformations (transformations_contact.v) Dans la partie "applications", sont démontrés - les théorèmes de Miquel, des symétriques de l'orthocentre, de la droite de Simson (applications_cocyclicite.v) - les notions de puissance d'un point par rapport à un cercle et d'inversion plane (puissance_cercle.v, inversion.v) - les théorèmes de la droite d'Euler et du cercle des neuf points (droite_Euler.v et homoth_Euler.v). Dans la partie "nombres complexes", sont démontrées - les propriétés algébriques du corps des nombres complexes (complexes.v, formes_complexes.v, operations_complexes.v, complexes_conjugaison.v) - la caractérisation géométrique des transformations d'écriture complexe : z -> a z + b (complexes_dilations.v, complexes_similitudes.v, complexes_transformations.v, complexes_exercice.v) - l'écriture complexe de l'inversion (complexes_inversion.v) - l'écriture analytique de toutes les transformations étudiées (complexes_analytique.v) ========================= ENGLISH PART ====================================== This library consists in a collection of "chapters" spanning most of geometry taught to French high-shool students. We do not even try to minimize the number of axioms but rather to get as close as possible to informal definitions, theorems and proofs. In order to focus on reasoning issues, we use a non analytic description of euclidean geometry. The interested reader could find details about this work in RR-4893 : "Premiers pas vers un cours de géométrie en Coq pour le lycée" available from: http://www.inria.fr/rrrt/rr-4893.html The first part "2-3 dimensional affine geometry" deals with formalising: - points, vectors, barycenters, oriented lengths, (Rutile.v, Field_affine.v, vecteur.v, barycentre.v, milieu.v, mesure_algebrique.v) - collinearity, coplanarity, (alignement.v, coplanarite.v) - parallelism and incidence of straight lines, (parallelisme_concours.v) - proofs of Thales and Desargues theorems.(affine_classiques.v) In the second part "3 dimensional affine geometry", we prove theorems about: - relative positions of two straight lines in the space (Droite_espace.v) - relative positions of a straight line and a plane (Droite_plan_espace.v) - relative positions of two planes (Plans_paralleles.v) - parallelism and incidence properties for several planes and straight lines (Plan_espace.v) The third part "2-3 dimensional euclidean geometry" deals with formalising: - scalar product, orthogonal vectors, and unitary vectors (produit_scalaire.v, orthogonalite.v, representant_unitaire.v) - eulidean distance and orthogonal projection on a line (distance_euclidienne.v, projection_orthogonale.v) - proofs of Pythagorean theorem, median theorem (euclidien_classiques.v) The fourth part "space orthogonality" deals with formalising: - orthogonal line and plan (orthogonalite_espace.v) We use these definitions to solve a high-school diploma (baccalaureat) exercise in a formal way.(exercice_espace.v). The fifth part "plane euclidean geometry" deals with formalising: - affine coordinate system, orthogonal coordinate system, affine coordinates (repere_plan.v, repere_ortho_plan.v) - oriented angles (angles_vecteurs.v, angles_droites.v) - trigonometry (trigo.v) - proofs of Pythagorean theorem, median theorem, Al-Kashi and sine theorems (metrique_triangle.v) - perpendicular bisector, isocel triangle, orthocenter, (mediatrice.v, isocele.v, orthocentre.v) - circle, cocyclicity, tangency (line or circle tangent) (cercle.v, cocyclicite.v, complements_cercle.v, contact.v) - signed area, determinant (aire_signee.v, determinant.v) - equations for straight lines and circles in plane geometry (equations_droites.v, equations_cercles.v) The sixth part "plane transformations", deals with formalising: - translations, homothety (dilatations.v, composee_dilatations.v, homothetie_plane.v) - rotations, reflexions (rotation_plane.v, reflexion_plane.v) - composition of these transformations. (composee_reflexions.v, composee_translation_rotation.v, composee_transformations.v, similitudes_directes.v) - conservation of tangency for these transformations. (transformations_contact.v) In the seventh part "applications", we prove: - Miquel's theorem, orthocenter theorem, Simson line (applications_cocyclicite.v) - circle power and plane inversion (puissance_cercle.v, inversion.v) - Euler line theorem and nine point circle theorem (droite_Euler.v et homoth_Euler.v). The eighth part "complex numbers", deals with formalising: - the field properties of complex numbers (complexes.v, formes_complexes.v, operations_complexes.v, complexes_conjugaison.v) - application to geometry of complex numbers (complexes_dilations.v, complexes_similitudes.v, complexes_transformations.v, complexes_exercice.v, complexes_inversion.v, complexes_analytique.v) HighSchoolGeometry/Rutile.v0000644000076500007650000001457112073525613015670 0ustar coqcoq00000000000000(* This program is free software; you can redistribute it and/or *) (* modify it under the terms of the GNU Lesser General Public License *) (* as published by the Free Software Foundation; either version 2.1 *) (* of the License, or (at your option) any later version. *) (* *) (* This program is distributed in the hope that it will be useful, *) (* but WITHOUT ANY WARRANTY; without even the implied warranty of *) (* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *) (* GNU General Public License for more details. *) (* *) (* You should have received a copy of the GNU Lesser General Public *) (* License along with this program; if not, write to the Free *) (* Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA *) (* 02110-1301 USA *) Require Export Rbase. Require Export Rfunctions. Require Export R_sqrt. Require Export Fourier. Lemma def_sqrt : forall x : R, x >= 0 -> sqrt x * sqrt x = x. intros. apply sqrt_sqrt; auto with real. Qed. Lemma sqrt_pos : forall x : R, x >= 0 -> sqrt x >= 0. intros. apply Rle_ge. apply sqrt_positivity; auto with real. Qed. Lemma Rmult_pos : forall x y : R, x >= 0 -> y >= 0 -> x * y >= 0. intros. apply Rle_ge. apply Rmult_le_pos; auto with real. Qed. Lemma Rinv_le_pos : forall x : R, x <> 0 -> x >= 0 -> / x >= 0. intros. inversion H0. apply Rle_ge. apply Rlt_le; auto with real. absurd (x = 0); auto. Qed. Lemma non_sqrt_zero : forall r : R, r >= 0 -> r <> 0 -> sqrt r <> 0. unfold not in |- *; intros. apply H0. rewrite <- (def_sqrt r); auto. rewrite H1; ring. Qed. Lemma Rinv_sqrt_pos : forall r : R, r <> 0 -> r >= 0 -> / sqrt r >= 0. intros r H H0; try assumption. apply Rinv_le_pos; auto. apply non_sqrt_zero; auto. apply sqrt_pos; auto. Qed. Hint Resolve non_sqrt_zero Rinv_sqrt_pos Rinv_le_pos Rmult_pos sqrt_pos def_sqrt: real. Lemma resolution : forall x y : R, x >= 0 -> y >= 0 -> x * x = y * y -> x = y. intros. rewrite <- (def_sqrt x); auto with real. rewrite <- (def_sqrt y); auto with real. rewrite <- sqrt_mult; auto with real. rewrite <- sqrt_mult; auto with real. Qed. Lemma inversion_sqr : forall x y : R, x >= 0 -> y >= 0 -> x = y * y -> y = sqrt x. intros; symmetry in |- *. apply sqrt_lem_1; auto with real. Qed. Lemma sqrt_Rinv : forall x : R, x >= 0 -> x <> 0 -> sqrt (/ x) = / sqrt x. intros. inversion H. replace (/ x) with (1 / x); auto with real. rewrite sqrt_div; auto with real. rewrite sqrt_1. replace (1 / sqrt x) with (1 * / sqrt x); auto with real. replace (1 / x) with (1 * / x); auto with real. absurd (x = 0); auto. Qed. Lemma resolution2 : forall x y x' y' : R, x <> 0 -> x = y -> x * x' = y * y' -> x' = y'. intros. cut (y <> 0); intros. replace x' with (/ x * x * x'). replace (/ x * x * x') with (/ x * (x * x')). rewrite H1; rewrite H0. replace (/ y * (y * y')) with (/ y * y * y'). replace (/ y * y) with 1. ring. auto with real. ring. ring. replace (/ x * x) with 1. ring. auto with real. rewrite <- H0; auto. Qed. Lemma deux_demi : 2 * / 2 = 1. cut (2 <> 0); intros. auto with real. try discrR. Qed. Hint Resolve deux_demi: real. Lemma deux_demi_a : forall a : R, a = / 2 * a + / 2 * a. intros. replace (/ 2 * a + / 2 * a) with (2 * / 2 * a). replace (2 * / 2) with 1; auto with real. ring. Qed. Hint Resolve deux_demi_a: real. Lemma integre_not : forall a b : R, a <> 0 -> b <> 0 -> a * b <> 0. intros. apply Rmult_integral_contrapositive; (split; auto; try discrR). Qed. Hint Resolve integre_not: real. Axiom lR14 : 1 + - / 2 = / 2. Hint Resolve lR14: real. Lemma lR15 : forall k : R, k * k = (1 + - k) * (1 + - k) -> k = / 2. intros. cut (2 <> 0); intros. cut (2 * k = 1); intros. replace k with (/ 2 * (2 * k)). rewrite H1. ring. replace (/ 2 * (2 * k)) with (/ 2 * 2 * k). replace (/ 2 * 2) with 1. ring. auto with real. ring. cut ((1 + - k) * (1 + - k) = - (2 * k) + (k * k + 1)); intros. rewrite <- H in H1. cut (2 * k = k * k + 1 + - (k * k)); intros. rewrite H2. ring. pattern (k * k) at 2 in |- *. rewrite H1. replace (- (- (2 * k) + (k * k + 1))) with (2 * k + - (k * k + 1)). ring. ring. ring. discrR. Qed. Hint Resolve lR15: real. Lemma lR20 : forall a : R, ~ a >= 0 -> -1 * a >= 0. intros. replace (-1 * a) with (- a). cut (0 <= - a); intros. auto with real. apply Ropp_0_ge_le_contravar. cut (0 > a); intros. fourier. apply Rfourier_not_le_gt; intros. apply H; auto with real. ring. Qed. Hint Resolve lR20: real. Lemma non_produit_un : forall k k' : R, k' * k <> 1 -> 1 + - (k' * k) <> 0. intros; red in |- *; intros. apply H. replace 1 with (1 + - (k' * k) + k' * k); [ idtac | ring ]. rewrite H0; ring. Qed. Hint Resolve non_produit_un: real. Lemma opp_inv_demi_nonzero : - / 2 <> 0. cut (-2 <> 0); intros. replace (- / 2) with (/ -2); auto with real. rewrite Ropp_inv_permute; auto with real. discrR. Qed. Hint Resolve opp_inv_demi_nonzero: real. Lemma nonzero_un : 1 <> 0. discrR. Qed. Lemma nonzero_oppun : -1 <> 0. discrR. Qed. Lemma nonzero_deux : 2 <> 0. discrR. Qed. Lemma nonzero_oppdeux : -2 <> 0. discrR. Qed. Lemma nonzero_invdeux : / 2 <> 0. cut (2 <> 0); intros; auto with real. discrR. Qed. Lemma nonzero_trois : 3 <> 0. discrR. Qed. Lemma nonzero_opptrois : -3 <> 0. discrR. Qed. Lemma nonzero_invtrois : / 3 <> 0. cut (3 <> 0); intros; auto with real. discrR. Qed. Hint Resolve nonzero_invtrois nonzero_opptrois nonzero_trois nonzero_invdeux nonzero_oppdeux nonzero_deux nonzero_oppun nonzero_un: real. Lemma double_zero : forall a : R, 2 * a = 0 -> a = 0. intros. replace a with (/ 2 * (2 * a)); auto with real. field. Qed. Lemma zero_double : forall a : R, a = 0 -> 2 * a = 0. intuition. Qed. Hint Resolve double_zero zero_double: real. Lemma nonzero_oppinvtrois : - / 3 <> 0. cut (-3 <> 0); intros; auto with real. Qed. Lemma nonzero_oppinvdeux : - / 2 <> 0. cut (-2 <> 0); intros; auto with real. Qed. Hint Resolve nonzero_oppinvtrois nonzero_oppinvdeux: real. Lemma Rgt_inv : forall k : R, k > 0 -> / k > 0. intros. cut (k <> 0); intros; [ idtac | auto with real ]. cut (k >= 0); intros. cut (/ k >= 0); intros. 2: apply Rinv_le_pos; auto. elim H2; intros; auto. absurd (/ k = 0); auto with real. red in |- *. left; try assumption. Qed. Hint Resolve Rgt_inv: real. Definition R2 := 2. Definition R4 := 2 + 2. Hint Unfold R2 R4: real geo. HighSchoolGeometry/affine_classiques.v0000644000076500007650000003734012073525614020110 0ustar coqcoq00000000000000(* This program is free software; you can redistribute it and/or *) (* modify it under the terms of the GNU Lesser General Public License *) (* as published by the Free Software Foundation; either version 2.1 *) (* of the License, or (at your option) any later version. *) (* *) (* This program is distributed in the hope that it will be useful, *) (* but WITHOUT ANY WARRANTY; without even the implied warranty of *) (* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *) (* GNU General Public License for more details. *) (* *) (* You should have received a copy of the GNU Lesser General Public *) (* License along with this program; if not, write to the Free *) (* Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA *) (* 02110-1301 USA *) Require Export parallelisme_concours. Set Implicit Arguments. Unset Strict Implicit. Lemma triangle_droite_milieu_paralleles : forall A B C A' B' : PO, triangle A B C -> A' = milieu B C :>PO -> B' = milieu A C :>PO -> paralleles (droite A B) (droite A' B'). intros A B C A' B' H H0 H1; try assumption. deroule_triangle A B C. apply colineaires_paralleles with (-2); auto. apply (deux_milieux_distincts (A:=B) (B:=C) (C:=A)); auto with geo. rewrite <- (droite_milieu (A:=C) (B:=A) (C:=B) (I:=B') (J:=A')); auto with geo. Ringvec. Qed. Lemma milieu_parallelogrammme : forall A B C D I : PO, vec A B = vec D C -> I = milieu A C -> I = milieu B D. unfold vec in |- *; intros. elim cons_inj with (a := 2) (b := 2) (A := I) (B := milieu B D); intros; auto; try discrR. rewrite <- add_PP_milieu. rewrite H0. rewrite <- add_PP_milieu. RingPP2 H. RingPP. Qed. Lemma milieu_parallelogrammme_rec: forall (A B C D I : PO), I = milieu A C -> I = milieu B D -> vec A B = vec D C. unfold vec; intros. assert (add_PP (cons 1 B) (cons 1 D) = add_PP (cons 1 A) (cons 1 C)). repeat rewrite add_PP_milieu. rewrite <- H. rewrite <- H0; auto. RingPP1 H1. RingPP. Qed. Lemma caract_milieu_parallelogramme: forall (A B C D : PO), (milieu A C = milieu B D <-> parallelogramme A B C D). intros. elim (existence_milieu A C); [intros I H; (try clear existence_milieu)]. rewrite <- H. unfold parallelogramme; split; intros. apply milieu_parallelogrammme_rec with I; auto. eapply milieu_parallelogrammme;eauto. Qed. Lemma Thales_PP : forall A B C D : PO, A <> C -> B <> D -> paralleles (droite A C) (droite B D) -> exists k : R, add_PP (cons 1 A) (cons k B) = add_PP (cons 1 C) (cons k D) :>PP. intros A B C D H10 H11 H; try assumption. elim def_paralleles2 with (3 := H); auto. intros k H2. exists (- k). RingPP1 H2. RingPP. Qed. Lemma reciproque_Thales_PP : forall (A B C D : PO) (k : R), A <> C :>PO -> B <> D :>PO -> add_PP (cons 1 A) (cons k B) = add_PP (cons 1 C) (cons k D) -> paralleles (droite A C) (droite B D). intros A B C D k H10 H11 H; try assumption. apply def_paralleles with (- k); auto. replace (- - k) with k; try ring. RingPP2 H. RingPP. Qed. Theorem Thales_expl : forall A B C D : PO, A <> C :>PO -> B <> D :>PO -> paralleles (droite A C) (droite B D) -> vec B A = vec D C \/ (exists k : R, (exists I : PO, vec I A = mult_PP k (vec I B) /\ vec I C = mult_PP k (vec I D))). intros A B C D H11 H10 H; try assumption. elim Thales_PP with (3 := H); auto. intros k H2. elim (classic (k = -1)); intros H3. unfold vec in |- *; left. rewrite <- H3; auto. rewrite add_PP_sym; auto. rewrite H2; auto. Ringvec. right; try assumption. exists (- k). exists (barycentre (cons 1 A) (cons k B)). split; [ try assumption | idtac ]. apply add_PP_vec_reg with (a := k) (A := barycentre (cons 1 A) (cons k B)) (B := B). rewrite add_PP_sym; auto. rewrite <- mult_1_vec; auto. rewrite def_vecteur_bary; auto. Ringvec. unfold not in |- *; intros; apply H3. replace (-1) with (-1 + (1 + k)). try ring. rewrite H0; try ring. cut (barycentre (cons 1 A) (cons k B) = barycentre (cons 1 C) (cons k D)); intros. rewrite H0; try ring. apply add_PP_vec_reg with (a := k) (A := barycentre (cons 1 C) (cons k D)) (B := D). rewrite add_PP_sym; auto. rewrite <- mult_1_vec; auto. rewrite def_vecteur_bary; auto. Ringvec. unfold not in |- *; intros; apply H3. replace (-1) with (-1 + (1 + k)). try ring. rewrite H1; try ring. elim cons_inj with (a := 1 + k) (b := 1 + k) (A := barycentre (cons 1 A) (cons k B)) (B := barycentre (cons 1 C) (cons k D)); (intros; auto). repeat rewrite <- add_PP_barycentre; auto. unfold not in |- *; intros; apply H3. replace (-1) with (-1 + (1 + k)). try ring. rewrite H0; try ring. unfold not in |- *; intros; apply H3. replace (-1) with (-1 + (1 + k)). try ring. rewrite H0; try ring. unfold not in |- *; intros; apply H3. replace (-1) with (-1 + (1 + k)). try ring. rewrite H0; try ring. Qed. Theorem reciproque_Thales_expl : forall (A B C D I : PO) (k : R), A <> C :>PO -> B <> D :>PO -> vec I A = mult_PP k (vec I B) :>PP -> vec I C = mult_PP k (vec I D) :>PP -> paralleles (droite A C) (droite B D). unfold vec in |- *; intros A B C D I k H10 H11 H H0. apply reciproque_Thales_PP with (- k); auto. RingPP2 H. RingPP2 H0. RingPP. Qed. Lemma trapeze_complet_PP : forall A B C D I J : PO, A <> B :>PO -> C <> D :>PO -> paralleles (droite A B) (droite C D) -> I = milieu C D -> J = milieu A B -> ex (fun k : R => add_PP (cons 1 A) (cons k C) = add_PP (cons 1 B) (cons k D) :>PP /\ add_PP (cons 1 A) (cons k C) = add_PP (cons 1 J) (cons k I) :>PP). intros A B C D I J H10 H11 H H0 H1; try assumption. elim Thales_PP with (3 := H); auto. intros x H2; try assumption. exists x. split; [ try assumption | idtac ]. rewrite H1; rewrite H0. apply mult_PP_regulier with (k := 2); try discrR. repeat rewrite <- distrib_mult_cons. replace (2 * 1) with 2; try ring; auto. rewrite <- add_PP_milieu. replace (2 * x) with (x * 2); try ring; auto. repeat rewrite <- def_mult_PP. rewrite <- add_PP_milieu. repeat rewrite <- add_PP_A. RingPP1 H2. RingPP. Qed. Lemma trapeze_complet_expl : forall A B C D I J : PO, A <> B :>PO -> C <> D :>PO -> paralleles (droite A B) (droite C D) -> I = milieu C D -> J = milieu A B -> vec C A = vec D B /\ vec C A = vec I J \/ concours_3 A C B D J I. intros A B C D I J H10 H11 H H0 H1; try assumption. unfold concours_3, vec in |- *; intros. elim trapeze_complet_PP with (A := A) (B := B) (C := C) (D := D) (I := I) (J := J); [ intros k H2 | auto | auto | auto | auto | auto ]. elim H2; intros H3 H4; try clear H2; try exact H3. elim (classic (k = -1)); intros. rewrite H2 in H3. rewrite H2 in H4. left; try assumption. split; [ try assumption | idtac ]. RingPP1 H3; RingPP. RingPP1 H4; RingPP. right; try assumption. cut (1 + k <> 0); intros. rewrite add_PP_barycentre in H4; auto. rewrite add_PP_barycentre in H4; auto. rewrite add_PP_barycentre in H3; auto. rewrite add_PP_barycentre in H3; auto. exists (barycentre (cons 1 A) (cons k C)). split; [ apply barycentre_alignes; auto | idtac ]. split; [ try assumption | idtac ]. replace (barycentre (cons 1 A) (cons k C)) with (barycentre (cons 1 B) (cons k D)). apply barycentre_alignes; auto. apply conversion_PP with (a := 1 + k) (b := 1 + k); auto. replace (barycentre (cons 1 A) (cons k C)) with (barycentre (cons 1 J) (cons k I)). apply barycentre_alignes; auto. apply conversion_PP with (a := 1 + k) (b := 1 + k); auto. unfold not in |- *; intros; apply H2. replace k with (-1 + (1 + k)). rewrite H5; ring. ring. Qed. Hint Immediate paralleles_ABBA paralleles_sym: geo. Lemma trapeze_complet_expl2 : forall A B C D I J : PO, A <> B :>PO -> C <> D :>PO -> paralleles (droite A B) (droite C D) -> I = milieu C D -> J = milieu A B -> vec D A = vec C B /\ vec D A = vec I J \/ concours_3 A D B C J I. intros. elim (trapeze_complet_expl (A:=A) (B:=B) (C:=D) (D:=C) (I:=I) (J:=J)); auto with geo; intros. apply paralleles_trans with (C := C) (D := D); auto with geo. Qed. Theorem Desargues : forall A B C A1 B1 C1 S : PO, C <> C1 -> B <> B1 -> C <> S -> B <> S -> C1 <> S -> B1 <> S -> A1 <> B1 -> A1 <> C1 -> B <> C -> B1 <> C1 -> triangle A A1 B -> triangle A A1 C -> alignes A A1 S -> alignes B B1 S -> alignes C C1 S -> paralleles (droite A B) (droite A1 B1) -> paralleles (droite A C) (droite A1 C1) -> paralleles (droite B C) (droite B1 C1). intros. deroule_triangle A A1 B. deroule_triangle A A1 C. elim Thales_PP with (3 := H15); intros; auto. elim Thales_PP with (3 := H14); intros; auto. apply reciproque_Thales_PP with x; auto. elim (classic (1 + x = 0)); intros. cut (x = -1); [ intros | auto ]. rewrite H27 in H24. absurd (add_PP (cons 1 A) (cons (-1) A1) = add_PP (cons 1 C) (cons (-1) C1)); auto. apply parallelogramme_non_concours with S; auto. replace x with (-1 + (1 + x)); auto. rewrite H26. ring. ring. elim (classic (1 + x0 = 0)); intros. cut (x0 = -1); [ intros | auto ]. rewrite H28 in H25. absurd (add_PP (cons 1 A) (cons (-1) A1) = add_PP (cons 1 B) (cons (-1) B1)); auto. apply parallelogramme_non_concours with S; auto. replace x0 with (-1 + (1 + x0)); auto. rewrite H27. ring. ring. rewrite add_PP_barycentre; auto. rewrite add_PP_barycentre; auto. cut (barycentre (cons 1 A) (cons x A1) = barycentre (cons 1 C) (cons x C1)); intros. cut (barycentre (cons 1 A) (cons x0 A1) = barycentre (cons 1 B) (cons x0 B1)); intros. cut (S = barycentre (cons 1 A) (cons x A1) /\ S = barycentre (cons 1 A) (cons x0 A1)); intros. cut (x = x0); [ intros | auto ]. elim H30; intros; try clear H30. rewrite <- H28; auto. rewrite H31. rewrite <- H29; auto. apply unicite_coef_bar with (A := A) (B := A1) (x := x) (x0 := x0); auto. elim H30; intros; try clear H30. rewrite <- H31; auto. split; [ try assumption | idtac ]. apply concours_unique with (A := A) (B := C) (A1 := A1) (B1 := C1); auto with geo. rewrite H28. rewrite permute_barycentre; auto. apply barycentre_alignes; auto. replace (x + 1) with (1 + x); auto. ring. apply concours_unique with (A := A) (B := B) (A1 := A1) (B1 := B1); auto with geo. rewrite H29. rewrite permute_barycentre; auto. apply barycentre_alignes; auto. replace (x0 + 1) with (1 + x0); auto. ring. apply conversion_PP with (a := 1 + x0) (b := 1 + x0); auto with *. rewrite <- add_PP_barycentre; auto. rewrite <- add_PP_barycentre; auto. apply conversion_PP with (a := 1 + x) (b := 1 + x); auto with *. rewrite <- add_PP_barycentre; auto. rewrite <- add_PP_barycentre; auto. Qed. Lemma Thales_concours : forall (k : R) (A B C I J : PO), triangle A B C -> k <> 0 :>R -> vec A I = mult_PP k (vec A B) :>PP -> paralleles (droite B C) (droite I J) -> alignes A C J -> vec A J = mult_PP k (vec A C) :>PP. intros k A B C I J H H0 H2 H3 H4; try assumption. elim (classic (k = 1)); intros. cut (B = I); intros. cut (J = C); intros. rewrite H6; rewrite H1; Ringvec. generalize (alignes_paralleles_confondus (A:=A) (B:=B)); intros H16; apply H16; auto. pattern B at 2 in |- *; rewrite H5; auto. apply vecteur_nul_conf. replace (vec B I) with (add_PP (mult_PP (-1) (vec A B)) (vec A I)); [ idtac | Ringvec ]. rewrite H2; rewrite H1; Ringvec. generalize H2; unfold vec in |- *; intros H98. deroule_triangle A B C. cut (1 + - k <> 0). intros H102. cut (- k <> 0). intros H103. cut (1 + - / k <> 0). intros H104. cut (B <> I). intros H99. cut (I <> J); intros. cut (alignes B I A). intros H100. cut (~ alignes B I C). intros H101. elim Thales_PP with (A := B) (B := I) (C := C) (D := J); [ intros x H10; try clear Thales_PP; try exact H10 | auto | auto | auto ]. elim (classic (x = -1)); intros. cut (C <> J); intros. rewrite H11 in H10. absurd (add_PP (cons 1 B) (cons (-1) I) = add_PP (cons 1 C) (cons (-1) J)); auto. apply parallelogramme_non_concours with A; auto with geo. red in |- *; intros; apply H99. apply conversion_PP with (a := 1) (b := 1); try ring. RingPP1 H10. rewrite H11; rewrite H12; RingPP. discrR. cut (1 + x <> 0); intros. cut (C <> J); intros. cut (barycentre (cons 1 B) (cons x I) = barycentre (cons 1 C) (cons x J)); intros. cut (cons 1 J = add_PP (cons (1 + - k) A) (cons k C)); intros. rewrite H15; RingPP. cut (A = barycentre (cons 1 B) (cons x I)); intros. cut (A = barycentre (cons (- k) B) (cons 1 I)); intros. cut (x = - / k); intros. rewrite <- H15 in H14. rewrite H17 in H14. rewrite H17 in H15. cut (A = barycentre (cons (- k) C) (cons 1 J)); intros. rewrite H18. replace (1 + - k) with (- k + 1); [ idtac | ring ]. rewrite <- add_PP_barycentre; auto. RingPP. replace (- k + 1) with (1 + - k); [ auto | ring ]. rewrite H14. rewrite <- homogene_barycentre with (k := - k); auto. replace (- k * 1) with (- k) by ring. replace (- k * - / k) with 1 by (field;trivial). reflexivity. cut (A = barycentre (cons 1 B) (cons (- / k) I)); intros. apply unicite_coef_bar with (A := B) (B := I) (x := x) (x0 := - / k); auto. rewrite <- H15; auto. rewrite H16. symmetry in |- *. rewrite <- homogene_barycentre with (k := - k); auto. replace (- k * 1) with (- k) by ring. replace (- k * - / k) with 1 by (field;trivial). reflexivity. cut (cons (1 + - k) A = add_PP (cons 1 I) (cons (- k) B)); intros. rewrite permute_barycentre; auto. apply conversion_PP with (a := 1 + - k) (b := 1 + - k); auto. rewrite <- add_PP_barycentre; auto. replace (- k + 1) with (1 + - k); [ auto | ring ]. RingPP2 H98; RingPP. apply concours_unique with (A := B) (B := C) (A1 := I) (B1 := J); auto. apply permute_alignes; auto with geo. apply barycentre_alignes; auto. rewrite H14. apply permute_alignes; auto. apply barycentre_alignes; auto. apply conversion_PP with (a := 1 + x) (b := 1 + x); auto. rewrite <- add_PP_barycentre; auto. rewrite <- add_PP_barycentre; auto. red in |- *; intros; apply H101. replace C with (barycentre (cons 1 B) (cons x I)). apply barycentre_alignes; auto. apply conversion_PP with (a := 1 + x) (b := 1 + x); try ring; auto. rewrite <- add_PP_barycentre; auto. rewrite H10; rewrite H13; Ringvec. red in |- *; intros; apply H11. replace (-1) with (-1 + 0) by ring. rewrite <- H12; ring. cut (~ alignes B A C); intros; auto with geo. red in |- *; intros; apply H10. halignes H11 ipattern:y. apply colineaire_alignes with ((1 + - k) * y). rewrite H12; unfold vec in |- *. RingPP2 H98. replace (add_PP (mult_PP k (add_PP (cons (-1) A) (cons 1 B))) (mult_PP (-1) (cons (-1) A))) with (add_PP (cons (1 + - k) A) (cons k B)); [ idtac | RingPP ]. replace (add_PP (cons (-1) B) (add_PP (cons (1 + - k) A) (cons k B))) with (add_PP (cons (1 + - k) A) (cons (-1 * (1 + - k)) B)); [ idtac | RingPP ]. replace ((1 + - k) * y) with (y * (1 + - k)); [ idtac | ring ]. RingPP. apply colineaire_alignes with (/ (1 + - k)). replace (vec B I) with (add_PP (vec B A) (vec A I)); [ idtac | Ringvec ]. rewrite H2. Fieldvec (1 + - k). cut (~ alignes A C B); intros; auto with geo. red in |- *; intros; apply H9. halignes H4 ipattern:x. apply colineaire_alignes with (/ k * x). apply mult_PP_regulier with k; auto. rewrite <- H2; rewrite H10; rewrite H11. Fieldvec k. red in |- *; intros; apply H102. elim produit_vecteur_nul with (a := 1 + - k) (A := A) (B := B); [ intros H10; try clear produit_vecteur_nul; try exact H10 | intros H10; try clear produit_vecteur_nul | try clear produit_vecteur_nul ]. absurd (A = B); auto. replace (mult_PP (1 + - k) (vec A B)) with (add_PP (vec A B) (mult_PP (-1) (mult_PP k (vec A B)))); [ idtac | Ringvec ]. rewrite <- H2; rewrite H9; Ringvec. replace (1 + - / k) with (- / k * (1 + - k)); try ring; auto. apply integre_not; auto with real. field. auto with real. auto with real. red in |- *; intros; apply H1. replace 1 with (1 + - k + k); [ idtac | ring ]. rewrite H9; ring. Qed. Lemma reciproque_droite_milieu : forall A B C I J : PO, triangle A B C -> I = milieu A B :>PO -> paralleles (droite B C) (droite I J) -> alignes A C J -> J = milieu A C :>PO. intros. apply vecteur_milieu. apply (Thales_concours (k:=/ 2) (A:=A) (B:=B) (C:=C) (I:=I) (J:=J)); auto. cut (2 <> 0); intros. auto with real. discrR. apply milieu_vecteur2; auto. Qed. HighSchoolGeometry/aire_signee.v0000644000076500007650000004715612117747636016715 0ustar coqcoq00000000000000(* This program is free software; you can redistribute it and/or *) (* modify it under the terms of the GNU Lesser General Public License *) (* as published by the Free Software Foundation; either version 2.1 *) (* of the License, or (at your option) any later version. *) (* *) (* This program is distributed in the hope that it will be useful, *) (* but WITHOUT ANY WARRANTY; without even the implied warranty of *) (* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *) (* GNU General Public License for more details. *) (* *) (* You should have received a copy of the GNU Lesser General Public *) (* License along with this program; if not, write to the Free *) (* Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA *) (* 02110-1301 USA *) Require Export trigo. Set Implicit Arguments. Unset Strict Implicit. Parameter aire : PP -> PP -> R. Axiom def_aire_0 : forall A B C D : PO, A = B \/ C = D -> aire (vec A B) (vec C D) = 0. Axiom def_aire : forall A B C D : PO, A <> B -> C <> D -> aire (vec A B) (vec C D) = distance A B * (distance C D * Sin (cons_AV (vec A B) (vec C D))). Lemma Sin_opp : forall A B C D : PO, A <> B -> C <> D -> Sin (cons_AV (vec C D) (vec A B)) = - Sin (cons_AV (vec A B) (vec C D)). intros. elim (existence_representant_vecteur A C D); intros E; intros. rewrite <- H1. cut (A <> E); intros. mesure A B A E. rewrite H3. generalize (mes_oppx (A:=A) (B:=B) (C:=A) (D:=E) (x:=x)); auto; intros. rewrite <- (egalite_sin_Sin (A:=A) (B:=B) (C:=E) (x:=x)); auto. rewrite <- (egalite_sin_Sin (A:=A) (B:=E) (C:=B) (x:=- x)); auto. rewrite sin_impaire; auto. apply distinct_egalite_vecteur with (A := C) (B := D); auto. Qed. Lemma aire_anti_symetrique : forall A B C D : PO, aire (vec A B) (vec C D) = - aire (vec C D) (vec A B). intros. elim (classic (A = B \/ C = D)); intros. rewrite def_aire_0; auto. rewrite def_aire_0; auto. ring. tauto. cut (A <> B /\ C <> D); intros. elim H0; intros. rewrite def_aire; auto. rewrite def_aire; auto. rewrite Sin_opp; auto. ring. apply not_or_and; auto. Qed. Lemma aire_ABAB : forall A B : PO, aire (vec A B) (vec A B) = 0. intros. elim (classic (A = B)); intros. rewrite def_aire_0; auto. rewrite def_aire; auto. rewrite <- (egalite_sin_Sin (A:=A) (B:=B) (C:=B) (x:=0)); auto. rewrite sin_zero; ring. apply angle_nul; auto. Qed. Lemma aire_AB_oppAB : forall A B C : PO, aire (vec A B) (mult_PP (-1) (vec A B)) = 0. intros. elim (existence_representant_mult_vecteur A A B (-1)); auto; intros D H. rewrite <- H. elim (classic (A = B)); intros. rewrite def_aire_0; auto. cut (A <> D); intros. rewrite def_aire; auto. rewrite <- (egalite_sin_Sin (A:=A) (B:=B) (C:=D) (x:=pi)); auto. rewrite sin_pi; ring. replace (vec A D) with (vec B A). apply angle_plat; auto. rewrite H; Ringvec. apply distinct_produit_vecteur with (3 := H); auto with real. Qed. Hint Resolve aire_ABAB aire_AB_oppAB aire_anti_symetrique: geo. Ltac deroule_representant_unitaire A B C := elim (existence_representant_unitaire (A:=A) (B:=B)); auto; intros C; intros; elim (def_representant_unitaire2 (A:=A) (B:=B) (C:=C)); auto; intros; applatit_and; cut (A <> C); intros; [ idtac | auto with geo ]. Hint Resolve sin_zero sin_pisurdeux sin_pi angle_nul angle_plat: geo. Lemma Sin_angles_alignes : forall A B C : PO, A <> B -> A <> C -> alignes A B C -> Sin (cons_AV (vec A B) (vec A C)) = 0. intros. deroule_representant_unitaire A B ipattern:D. deroule_representant_unitaire A C ipattern:E. rewrite angles_representants_unitaires; auto. elim alignes_representant_unitaire with (A := A) (B := B) (C := C); [ intros H12 | intros H12 | auto | auto | auto ]. rewrite H12; rewrite <- H7. rewrite <- (egalite_sin_Sin (A:=A) (B:=E) (C:=E) (x:=0)); auto with geo. rewrite H12; rewrite <- H2. elim existence_representant_mult_vecteur with (A := A) (B := A) (C := D) (k := -1); [ intros F H13; try clear existence_representant_mult_vecteur; try exact H13 ]. rewrite <- H13. rewrite <- (egalite_sin_Sin (A:=A) (B:=D) (C:=F) (x:=pi)); auto with geo. apply distinct_produit_vecteur with (3 := H13); auto with real. rewrite H13. VReplace (mult_PP (-1) (vec A D)) (vec D A); auto with geo. Qed. Lemma aire_vecteur_nul_r : forall A B : PO, aire (vec A B) zero = 0. intros. VReplace zero (vec A A). rewrite def_aire_0; auto. Qed. Hint Resolve aire_vecteur_nul_r: geo. Lemma aire_vecteur_nul_l : forall A B : PO, aire zero (vec A B) = 0. intros. VReplace zero (vec A A). rewrite def_aire_0; auto. Qed. Hint Resolve aire_vecteur_nul_l: geo. Lemma aire_alignement : forall A B C : PO, alignes A B C -> aire (vec A B) (vec A C) = 0. intros. discrimine A B. VReplace (vec B B) zero; auto with geo. discrimine A C. VReplace (vec C C) zero; auto with geo. rewrite def_aire; auto. rewrite Sin_angles_alignes; auto. ring. Qed. Lemma aire_colinearite : forall (k : R) (A B C D : PO), vec C D = mult_PP k (vec A B) -> aire (vec A B) (vec C D) = 0. intros. discrimine A B. VReplace (vec B B) zero; auto with geo. discrimine C D. VReplace (vec D D) zero; auto with geo. elim existence_representant_mult_vecteur with (A := A) (B := A) (C := B) (k := k); [ intros E H2; try clear existence_representant_mult_vecteur; try exact H2 ]. replace (vec C D) with (vec A E). apply aire_alignement; auto. apply colineaire_alignes with k; auto. rewrite H; auto. Qed. Hint Resolve distance_refl2 egalite_vecteur_distance: geo. Lemma aire_colineaire_l : forall (k : R) (A B C D : PO), aire (mult_PP k (vec A B)) (vec C D) = k * aire (vec A B) (vec C D). intros. discrimine A B. VReplace (mult_PP k (vec B B)) zero; auto with geo. VReplace (vec B B) zero; auto with geo. rewrite aire_vecteur_nul_l; ring. discrimine C D. VReplace (vec D D) zero; auto with geo. elim existence_representant_mult_vecteur with (A := A) (B := A) (C := B) (k := k); [ intros E H2; rewrite <- H2 ]. repeat rewrite aire_vecteur_nul_r; ring. elim existence_representant_mult_vecteur with (A := A) (B := A) (C := B) (k := k); [ intros E H2; rewrite <- H2 ]. discrimine k 0. replace (vec A E) with zero. ring_simplify; auto with geo. rewrite H2; rewrite H1; Ringvec. cut (A <> E); intros. elim existence_representant_vecteur with (A := A) (B := C) (C := D); [ intros F H4; rewrite <- H4; intros ]. cut (A <> F); intros. deroule_representant_unitaire A B ipattern:G. deroule_representant_unitaire A F ipattern:L. rewrite def_aire; auto. rewrite def_aire; auto. rewrite angles_representants_unitaires; auto. rewrite angles_representants_unitaires; auto. elim Rtotal_order with (r1 := k) (r2 := 0); [ intros H16; try clear total_order | intros H16; elim H16; [ intros H17; try clear H16 | intros H17; try clear H16; try exact H17 ] ]. rewrite (produit_negatif_representant_unitaire (k:=k) (A:=A) (B:=B) (C:=E)); auto. rewrite <- H11; rewrite <- H6. elim existence_representant_mult_vecteur with (A := A) (B := A) (C := G) (k := -1); [ intros K H17; try clear existence_representant_mult_vecteur; try exact H17 ]. mesure A G A L. rewrite H18; rewrite <- H17. rewrite <- (egalite_sin_Sin (A:=A) (B:=G) (C:=L) (x:=x)); auto. rewrite <- (egalite_sin_Sin (A:=A) (B:=K) (C:=L) (x:=pi + x)); auto. elim pi_plus_x with (x := x); [ intros H19 H20; try clear pi_plus_x; try exact H20 ]. rewrite H20. replace (distance A E) with (- k * distance A B). ring. symmetry in |- *. rewrite <- Rabs_left; auto with real. apply colinearite_distance; auto. apply distinct_produit_vecteur with (3 := H17); auto with real. replace (cons_AV (vec A K) (vec A L)) with (plus (cons_AV (vec A K) (vec A G)) (cons_AV (vec A G) (vec A L))). replace (vec A K) with (vec G A). rewrite <- angle_plat; auto. rewrite <- H18; rewrite <- add_mes_compatible; auto. rewrite H17; Ringvec. rewrite Chasles; auto. apply distinct_produit_vecteur with (3 := H17); auto with real. absurd (k = 0); auto. rewrite <- (produit_positif_representant_unitaire (k:=k) (A:=A) (B:=B) (C:=E)) ; auto. rewrite <- H11; rewrite <- H6. elim existence_representant_mult_vecteur with (A := A) (B := A) (C := G) (k := -1); [ intros K H18; try clear existence_representant_mult_vecteur ]. mesure A G A L. replace (distance A E) with (k * distance A B). ring. symmetry in |- *. rewrite <- (Rabs_right k); auto with real. apply colinearite_distance; auto. apply Rgt_ge; auto. apply distinct_egalite_vecteur with (2 := H4); auto. apply distinct_produit_vecteur with (3 := H2); auto with real. Qed. Lemma aire_colineaire_r : forall (k : R) (A B C D : PO), aire (vec A B) (mult_PP k (vec C D)) = k * aire (vec A B) (vec C D). intros. elim existence_representant_mult_vecteur with (A := A) (B := C) (C := D) (k := k); [ intros E H2; rewrite <- H2 ]. rewrite aire_anti_symetrique. rewrite H2; rewrite aire_colineaire_l; auto. rewrite aire_anti_symetrique; ring. Qed. Hint Resolve aire_colineaire_r aire_colineaire_l: geo. Lemma aire_nulle_colineaires : forall A B C D : PO, A <> B -> aire (vec A B) (vec C D) = 0 -> exists k : R, vec C D = mult_PP k (vec A B). intros. discrimine C D. exists 0. Ringvec. cut (Sin (cons_AV (vec A B) (vec C D)) = 0); intros. deroule_representant_unitaire A B ipattern:E. deroule_representant_unitaire C D ipattern:J. elim existence_representant_vecteur with (A := A) (B := C) (C := J); [ intros F H14; intros ]. elim existence_ROND_AB with (A := A) (B := E); [ intros G H13 | auto with geo ]. cut (vec A F = add_PP (mult_PP (Cos (cons_AV (vec A E) (vec A F))) (vec A E)) (mult_PP (Sin (cons_AV (vec A E) (vec A F))) (vec A G))); intros. halignes H4 ipattern:k. assert (alignes C J D); auto with geo. halignes H17 ipattern:k'. cut (Sin (cons_AV (vec A E) (vec A F)) = 0); intros. rewrite H18; rewrite <- H14; rewrite H15. pattern (vec A E) at 2 in |- *; rewrite H16; rewrite H19. exists (k' * (Cos (cons_AV (vec A E) (vec A F)) * k)). Ringvec. rewrite <- H2. rewrite H14. rewrite angles_representants_unitaires; auto. rewrite angles_representants_unitaires; auto. rewrite H8; rewrite H3. rewrite representant_unitaire_bis; auto. rewrite representant_unitaire_bis; auto. apply coordonnees_Cos_Sin; auto. apply carre_scalaire_1_distance. rewrite H14; auto. replace (Sin (cons_AV (vec A B) (vec C D))) with (aire (vec A B) (vec C D) * / (distance A B * distance C D)). rewrite H0; ring. rewrite def_aire; auto. field; auto with geo. Qed. Lemma aire_orthogonal_direct : forall A B C D : PO, A <> B -> C <> D -> image_angle pisurdeux = cons_AV (vec A B) (vec C D) -> aire (vec A B) (vec C D) = distance A B * distance C D. intros A B C D H H0; try assumption. elim existence_representant_vecteur with (A := A) (B := C) (C := D); [ intros E H2; rewrite <- H2; intros ]. rewrite def_aire; auto. rewrite <- (egalite_sin_Sin (A:=A) (B:=B) (C:=E) (x:=pisurdeux)); auto with geo. replace (distance C D) with (distance A E); auto with geo. rewrite sin_pisurdeux; ring. apply distinct_egalite_vecteur with (2 := H2); auto with geo. apply distinct_egalite_vecteur with (2 := H2); auto with geo. Qed. Lemma aire_orthogonal_indirect : forall A B C D : PO, A <> B -> C <> D -> image_angle (- pisurdeux) = cons_AV (vec A B) (vec C D) -> aire (vec A B) (vec C D) = - (distance A B * distance C D). intros A B C D H H0; try assumption. elim existence_representant_vecteur with (A := A) (B := C) (C := D); [ intros E H2; rewrite <- H2; intros ]. rewrite def_aire; auto. rewrite <- (egalite_sin_Sin (A:=A) (B:=B) (C:=E) (x:=- pisurdeux)); auto with geo. replace (distance C D) with (distance A E); auto with geo. rewrite sin_impaire; rewrite sin_pisurdeux; ring. apply distinct_egalite_vecteur with (2 := H2); auto with geo. apply distinct_egalite_vecteur with (2 := H2); auto with geo. Qed. Lemma aire_orthogonal : forall A B C D : PO, orthogonal (vec A B) (vec C D) -> Rabs (aire (vec A B) (vec C D)) = distance A B * distance C D. intros. discrimine A B. VReplace (vec B B) zero; auto with geo. rewrite aire_vecteur_nul_l; rewrite Rabs_R0. replace (distance B B) with 0; [ring|idtac]. symmetry in |- *; auto with geo. discrimine C D. VReplace (vec D D) zero; auto with geo. rewrite aire_vecteur_nul_r; rewrite Rabs_R0. replace (distance D D) with 0; [ring|idtac]. symmetry in |- *; auto with geo. elim orthogonal_pisurdeux_or with (A := A) (B := B) (C := C) (D := D); [ intros H2; try clear orthogonal_pisurdeux_or | intros H2; try clear orthogonal_pisurdeux_or; try exact H2 | auto | auto | auto ]. rewrite aire_orthogonal_direct; auto. rewrite Rabs_mult; rewrite Rabs_right; auto with geo. rewrite Rabs_right; auto with geo. rewrite aire_orthogonal_indirect; auto. rewrite Rabs_Ropp; rewrite Rabs_mult; rewrite Rabs_right; auto with geo. rewrite Rabs_right; auto with geo. Qed. Axiom aire_distrib_l : forall A B C D E F : PO, aire (vec A B) (add_PP (vec C D) (vec E F)) = aire (vec A B) (vec C D) + aire (vec A B) (vec E F). Lemma aire_distrib_r : forall A B C D E F : PO, aire (add_PP (vec A B) (vec C D)) (vec E F) = aire (vec A B) (vec E F) + aire (vec C D) (vec E F). intros. replace (aire (vec A B) (vec E F) + aire (vec C D) (vec E F)) with (- (aire (vec E F) (vec A B) + aire (vec E F) (vec C D))). rewrite <- aire_distrib_l. elim existence_representant_som_vecteur with (A := A) (B := B) (C := C) (D := D); [ intros G H2; rewrite <- H2 ]. auto with geo. rewrite aire_anti_symetrique. rewrite (aire_anti_symetrique E F C D); ring. Qed. Lemma aire_ordre_cycle : forall A B C : PO, aire (vec B C) (vec B A) = aire (vec A B) (vec A C). intros. VReplace (vec B C) (add_PP (vec B A) (vec A C)). rewrite aire_distrib_r; rewrite aire_ABAB; ring_simplify. VReplace (vec B A) (mult_PP (-1) (vec A B)). rewrite aire_colineaire_r; rewrite aire_anti_symetrique; ring. Qed. Lemma aire_ordre_cycle2 : forall A B C : PO, aire (vec C A) (vec C B) = aire (vec A B) (vec A C). intros. rewrite aire_ordre_cycle; rewrite aire_ordre_cycle; auto. Qed. Lemma produit_longueur_absolu_Sin : forall A B C : PO, A <> B -> A <> C -> B <> C -> distance A B * (distance A C * Rabs (Sin (cons_AV (vec A B) (vec A C)))) = distance B C * (distance B A * Rabs (Sin (cons_AV (vec B C) (vec B A)))). intros. replace (distance A B * (distance A C * Rabs (Sin (cons_AV (vec A B) (vec A C))))) with (Rabs (aire (vec A B) (vec A C))). rewrite <- aire_ordre_cycle; auto. rewrite def_aire; auto. repeat rewrite Rabs_mult. rewrite Rabs_right; auto with geo. rewrite Rabs_right; auto with geo. rewrite def_aire; auto. repeat rewrite Rabs_mult. rewrite Rabs_right; auto with geo. rewrite Rabs_right; auto with geo. Qed. Lemma produit_longueur_absolu_Sin2 : forall A B C : PO, A <> B -> A <> C -> B <> C -> distance A B * (distance A C * Rabs (Sin (cons_AV (vec A B) (vec A C)))) = distance C A * (distance C B * Rabs (Sin (cons_AV (vec C A) (vec C B)))). intros. replace (distance A B * (distance A C * Rabs (Sin (cons_AV (vec A B) (vec A C))))) with (Rabs (aire (vec A B) (vec A C))). rewrite <- aire_ordre_cycle2; auto. rewrite def_aire; auto. repeat rewrite Rabs_mult. rewrite Rabs_right; auto with geo. rewrite Rabs_right; auto with geo. rewrite def_aire; auto. repeat rewrite Rabs_mult. rewrite Rabs_right; auto with geo. rewrite Rabs_right; auto with geo. Qed. Hint Resolve distance_sym: geo. Theorem sinA_sur_a : forall (a b c sin_A sin_B sin_C : R) (A B C : PO), triangle A B C -> a = distance B C -> b = distance A C -> c = distance A B -> sin_A = Rabs (Sin (cons_AV (vec A B) (vec A C))) -> sin_B = Rabs (Sin (cons_AV (vec B C) (vec B A))) -> sin_C = Rabs (Sin (cons_AV (vec C A) (vec C B))) -> sin_A / a = sin_B / b /\ sin_A / a = sin_C / c. intros. rewrite H0; rewrite H1; rewrite H2; rewrite H5; rewrite H4; rewrite H3. deroule_triangle A B C. split; [ try assumption | idtac ]. replace (Rabs (Sin (cons_AV (vec A B) (vec A C)))) with (/ distance A B * / distance A C * (distance B C * (distance B A * Rabs (Sin (cons_AV (vec B C) (vec B A)))))). replace (distance A B) with (distance B A); auto with geo. field; repeat split; auto with geo. rewrite <- produit_longueur_absolu_Sin; auto. field; split; auto with geo. replace (Rabs (Sin (cons_AV (vec A B) (vec A C)))) with (/ distance A B * / distance A C * (distance C A * (distance C B * Rabs (Sin (cons_AV (vec C A) (vec C B)))))). replace (distance A C) with (distance C A); auto with geo. replace (distance B C) with (distance C B); auto with geo. field; repeat split; auto with geo. rewrite <- produit_longueur_absolu_Sin2; auto. field; split; auto with geo. Qed. Definition aire_triangle (A B C : PO) := / 2 * Rabs (aire (vec A B) (vec A C)). Lemma aire_triangle_ordre_permute : forall A B C : PO, aire_triangle A B C = aire_triangle A C B. unfold aire_triangle in |- *; intros. rewrite aire_anti_symetrique; rewrite Rabs_Ropp; auto. Qed. Lemma aire_triangle_ordre_cycle : forall A B C : PO, aire_triangle A B C = aire_triangle B C A. unfold aire_triangle in |- *; intros. rewrite <- aire_ordre_cycle; auto. Qed. Theorem sinA_sur_a_aire : forall (a b c sin_A sin_B sin_C S : R) (A B C : PO), triangle A B C -> a = distance B C -> b = distance A C -> c = distance A B -> S = aire_triangle A B C -> sin_A = Rabs (Sin (cons_AV (vec A B) (vec A C))) -> sin_B = Rabs (Sin (cons_AV (vec B C) (vec B A))) -> sin_C = Rabs (Sin (cons_AV (vec C A) (vec C B))) -> (sin_A / a = sin_B / b /\ sin_A / a = sin_C / c) /\ sin_A / a = 2 * S / (a * (b * c)). unfold aire_triangle in |- *; intros a b c d e f g A B C H H0 H1 H2 H3 H4 H5 H6. split; [ try assumption | idtac ]. apply sinA_sur_a with (1 := H); auto. deroule_triangle A B C. rewrite H0; rewrite H1; rewrite H2; rewrite H4; rewrite H3. rewrite def_aire; auto. rewrite Rabs_mult. rewrite Rabs_mult. rewrite (Rabs_right (distance A B)); auto with geo. rewrite (Rabs_right (distance A C)); auto with geo. rewrite <- H4; rewrite <- H2; rewrite <- H1; rewrite <- H0. field. rewrite H0; rewrite H1; rewrite H2. repeat split; auto with geo. Qed. Require Export projection_orthogonale. Lemma aire_avec_projete : forall A B C H : PO, A <> B -> H = projete_orthogonal A B C -> aire (vec A B) (vec A C) = aire (vec A B) (vec H C). intros. elim (def_projete_orthogonal2 (A:=A) (B:=B) (C:=C) (H:=H)); auto; intros. VReplace (vec A C) (add_PP (vec A H) (vec H C)). repeat rewrite aire_distrib_l. rewrite aire_alignement; auto. ring. Qed. Lemma projete_Sinus : forall A B C H : PO, A <> B -> A <> C -> H = projete_orthogonal A B C -> distance H C = distance A C * Rabs (Sin (cons_AV (vec A B) (vec A C))). intros. apply Rmult_eq_reg_l with (distance A B); auto with geo. elim (def_projete_orthogonal2 (A:=A) (B:=B) (C:=C) (H:=H)); auto; intros. rewrite <- aire_orthogonal; auto. rewrite <- aire_avec_projete; auto. rewrite def_aire; auto. rewrite Rabs_mult; rewrite Rabs_right; auto with geo. rewrite Rabs_mult; rewrite Rabs_right; auto with geo. Qed. Lemma projete_sinus : forall (x : R) (A B C H : PO), A <> B -> A <> C -> H = projete_orthogonal A B C -> image_angle x = cons_AV (vec A B) (vec A C) -> distance H C = distance A C * Rabs (sin x). intros. rewrite (egalite_sin_Sin (A:=A) (B:=B) (C:=C) (x:=x)); auto. rewrite (projete_Sinus (A:=A) (B:=B) (C:=C) (H:=H)); auto. Qed. Lemma aire_triangle_projete : forall A B C H : PO, A <> B -> H = projete_orthogonal A B C -> aire_triangle A B C = / 2 * (distance A B * distance H C). unfold aire_triangle in |- *; intros. discrimine A C. assert (H = A). rewrite <- H2 in H1. apply projete_axe with (2 := H1); auto with geo. assert (H = C). rewrite H3; auto. assert (distance H C = 0); auto with geo. rewrite H5. rewrite def_aire_0. rewrite Rabs_right; auto with real. right; auto. rewrite def_aire; auto. rewrite (projete_Sinus (A:=A) (B:=B) (C:=C) (H:=H)); auto. rewrite Rabs_mult. rewrite Rabs_mult. rewrite (Rabs_right (distance A B)); auto with geo. rewrite (Rabs_right (distance A C)); auto with geo. Qed. HighSchoolGeometry/alignement.v0000644000076500007650000002214712073525613016545 0ustar coqcoq00000000000000(* This program is free software; you can redistribute it and/or *) (* modify it under the terms of the GNU Lesser General Public License *) (* as published by the Free Software Foundation; either version 2.1 *) (* of the License, or (at your option) any later version. *) (* *) (* This program is distributed in the hope that it will be useful, *) (* but WITHOUT ANY WARRANTY; without even the implied warranty of *) (* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *) (* GNU General Public License for more details. *) (* *) (* You should have received a copy of the GNU Lesser General Public *) (* License along with this program; if not, write to the Free *) (* Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA *) (* 02110-1301 USA *) Require Export vecteur. Set Implicit Arguments. Unset Strict Implicit. Definition col_vec (A B C D : PO) := exists k : R, vec C D = mult_PP k (vec A B) :>PP. Definition alignes1 (A B C : PO) := exists k : R, cons 1 C = add_PP (cons k A) (cons (1 + - k) B). Lemma colineaire_alignes1 : forall (k : R) (A B C : PO), vec A C = mult_PP k (vec A B) -> alignes1 A B C. unfold alignes1, vec in |- *; intros. exists (1 + - k); auto. RingPP2 H. RingPP. Qed. Lemma alignes1_colineaire : forall A B C : PO, alignes1 A B C -> col_vec A B A C. unfold alignes1, vec, col_vec in |- *; intros. elim H; intros k H0; try clear H; try exact H0. exists (1 + - k); auto. unfold vec in |- *; rewrite H0. RingPP. Qed. Lemma cas_degenere_alignes1 : forall A B C : PO, A <> C -> ~ alignes1 A A C. unfold alignes1 in |- *; intros. unfold not in |- *; intros. elim H0; intros k H1; try clear H0; try exact H1. apply H. apply conversion_PP with (a := k + (1 + - k)) (b := 1); auto. rewrite H1; RingPP. RReplace (k + (1 + - k)) 1. discrR. ring. Qed. Definition alignes (A B C : PO) := A = B \/ alignes1 A B C. Lemma alignes_trivial : forall A B : PO, alignes A B A. unfold alignes, alignes1 in |- *; intros. right; try assumption. exists 1. RingPP. Qed. Lemma alignes_trivial2 : forall A B : PO, alignes A B B. unfold alignes, alignes1 in |- *; intros. right; try assumption. exists 0. RingPP. Qed. Lemma alignes_trivial3 : forall A B : PO, alignes A A B. unfold alignes, alignes1 in |- *; intros. tauto. Qed. Hint Resolve alignes_trivial alignes_trivial2 alignes_trivial3: geo. Lemma existence_point_droite : forall A B : PO, exists C, alignes A B C. Proof. intros. exists A. auto with geo. Qed. Lemma non_alignes_expl : forall A B C : PO, ~ alignes A B C -> A <> B /\ ~ alignes1 A B C. unfold alignes in |- *; intros. intuition. Qed. Lemma non_alignes_distincts : forall A B C : PO, ~ alignes A B C -> A <> C. unfold not, alignes, alignes1 in |- *; intros. apply H. rewrite H0. right; exists 1. RingPP. Qed. Lemma non_alignes_distincts2 : forall A B C : PO, ~ alignes A B C -> B <> C. unfold not, alignes, alignes1 in |- *; intros. apply H. rewrite H0. right; exists 0; RingPP. Qed. Lemma non_alignes_distincts3 : forall A B C : PO, ~ alignes A B C -> A <> B. unfold alignes in |- *; intros. intuition. Qed. Hint Resolve non_alignes_distincts non_alignes_distincts2 non_alignes_distincts3: geo. Lemma colineaire_alignes : forall (k : R) (A B C : PO), vec A C = mult_PP k (vec A B) -> alignes A B C. unfold alignes in |- *; intros. right; try assumption. apply colineaire_alignes1 with k; auto. Qed. Hint Unfold alignes: geo. Ltac hPPalignes H x := elim H; clear H; intros H; [ tauto || (try rewrite H; auto with geo) | elim H; clear H; intros x H ]. Ltac halignes H k := elim H; clear H; intros H; [ tauto || (try rewrite H; auto with geo) | elim (alignes1_colineaire H); intros k; intros ]. Lemma permute_alignes : forall A B C : PO, alignes A B C -> alignes B A C. intros. halignes H ipattern:x. apply colineaire_alignes with (1 + - x). VReplace (vec B C) (add_PP (vec B A) (vec A C)). rewrite H0; Ringvec. Qed. Hint Immediate permute_alignes: geo. Lemma alignes_ordre_cycle : forall A B C : PO, alignes A B C -> alignes B C A. intros. halignes H ipattern:x. discrimine B C; auto with geo. cut (1 + - x <> 0); intros. apply colineaire_alignes with (/ (1 + - x)). VReplace (vec B C) (add_PP (vec B A) (vec A C)). rewrite H0. Fieldvec (1 + - x). apply distinct_col_nonun with (2 := H0); auto. Qed. Lemma alignes_ordre_permute : forall A B C : PO, alignes A B C -> alignes A C B. intros. halignes H ipattern:x. discrimine A C; auto with geo. apply colineaire_alignes with (/ x); auto with geo. Qed. Hint Resolve alignes_ordre_permute alignes_ordre_cycle: geo. Lemma alignes_ordre_cycle2 : forall A B C : PO, alignes A B C -> alignes C A B. intros. apply permute_alignes; auto with geo. Qed. Hint Resolve alignes_ordre_cycle2: geo. Lemma alignes_ordre_cycle3 : forall A B C : PO, alignes A B C -> alignes C B A. intros. apply permute_alignes; auto with geo. Qed. Hint Resolve alignes_ordre_cycle3: geo. Lemma non_alignes_permute : forall A B C : PO, ~ alignes A B C -> ~ alignes B A C. intros. contrapose ipattern:H0. apply permute_alignes; auto. Qed. Hint Resolve non_alignes_permute: geo. Lemma non_alignes_ordre_permute : forall A B C : PO, A <> B -> ~ alignes A B C -> ~ alignes A C B. intros. contrapose H0. apply alignes_ordre_permute; auto. Qed. Hint Resolve non_alignes_ordre_permute: geo. Lemma non_alignes_ordre_cycle : forall A B C : PO, ~ alignes B C A -> ~ alignes A B C. intros. contrapose H. apply alignes_ordre_cycle; auto. Qed. Hint Resolve non_alignes_ordre_cycle: geo. Lemma non_alignes_ordre_cycle2 : forall A B C : PO, ~ alignes C A B -> ~ alignes A B C. intros. contrapose H. apply alignes_ordre_cycle2; auto. Qed. Hint Resolve non_alignes_ordre_cycle2: geo. Lemma non_alignes_ordre_cycle3 : forall A B C : PO, ~ alignes C B A -> ~ alignes A B C. intros. contrapose H. apply alignes_ordre_cycle3; auto. Qed. Hint Resolve non_alignes_ordre_cycle3: geo. Lemma alignes_trans : forall A B C D : PO, A <> B :>PO -> alignes A B C -> alignes A B D -> alignes A C D. intros. assert (alignes A C B); auto with geo. halignes H2 ipattern:k. halignes H1 ipattern:k0. apply colineaire_alignes with (k0 * k). rewrite H4; rewrite H3. Ringvec. Qed. Lemma alignes_trans2 : forall A B C D : PO, A <> B -> alignes A B C -> alignes A B D -> alignes B C D. intros. assert (alignes B A D); auto with geo. halignes H2 ipattern:k. assert (A = B); auto. tauto. assert (alignes B C A); auto with geo. halignes H4 ipattern:k0. apply colineaire_alignes with (k * k0). rewrite H3; rewrite H5. Ringvec. Qed. Hint Resolve alignes_trans alignes_trans2: geo. Definition triangle (A B C : PO) : Prop := ~ alignes A B C. Ltac deroule_triangle A B C := match goal with | h:(triangle A B C) |- _ => generalize h; unfold triangle in |- *; intros; lapply (non_alignes_distincts (A:=A) (B:=B) (C:=C)); auto; intros; lapply (non_alignes_distincts2 (A:=A) (B:=B) (C:=C)); auto; intros; lapply (non_alignes_distincts3 (A:=A) (B:=B) (C:=C)); auto; intros | h:(~ alignes A B C) |- _ => lapply (non_alignes_distincts (A:=A) (B:=B) (C:=C)); auto; intros; lapply (non_alignes_distincts2 (A:=A) (B:=B) (C:=C)); auto; intros; lapply (non_alignes_distincts3 (A:=A) (B:=B) (C:=C)); auto; intros end. Lemma alignes_non_alignes_trans : forall A B C D : PO, A <> D -> ~ alignes A B C -> alignes A B D -> ~ alignes A D C. intros. contrapose H0. eauto with geo. Qed. Hint Resolve alignes_non_alignes_trans: geo. Lemma alignes_non_alignes_trans2 : forall A B C D : PO, A <> D -> ~ alignes A B C -> alignes A B D -> ~ alignes A C D. intros. eauto with geo. Qed. Lemma alignes_non_alignes_trans3 : forall A B C D : PO, A <> D -> ~ alignes A B C -> alignes A C D -> ~ alignes A B D. intros. contrapose H0. eauto with geo. Qed. Hint Resolve alignes_non_alignes_trans3: geo. Lemma alignes_non_alignes_trans4 : forall A B C D : PO, A <> D -> ~ alignes A B C -> alignes A C D -> ~ alignes A D B. intros. eauto with geo. Qed. Lemma add_PP_alignes : forall (a b : R) (A B C : PO), a + b <> 0 -> add_PP (cons a A) (cons b B) = cons (a + b) C -> alignes A B C. unfold alignes, alignes1, vec in |- *; intros. right; try assumption. exists (1 + - (/ (a + b) * b)). apply mult_PP_regulier with (a + b); auto. replace (mult_PP (a + b) (cons 1 C)) with (cons (a + b) C); [ idtac | RingPP ]. rewrite <- H0. FieldPP (a + b). Qed. Lemma triangle_ordre_cycle : forall A B C : PO, triangle A B C -> triangle B C A. unfold triangle in |- *; intros; auto with geo. Qed. Lemma triangle_ordre_permute : forall A B C : PO, triangle A B C -> triangle A C B. unfold triangle in |- *; intros; auto with geo. Qed. Hint Resolve triangle_ordre_cycle triangle_ordre_permute: geo. Lemma triangle_ordre_cycle2 : forall A B C : PO, triangle A B C -> triangle C A B. auto with geo. Qed. Lemma triangle_ordre_cycle3 : forall A B C : PO, triangle A B C -> triangle C B A. auto with geo. Qed. Lemma permute_ordre_triangle : forall A B C : PO, triangle A B C -> triangle B A C. auto with geo. Qed.HighSchoolGeometry/angles_droites.v0000644000076500007650000004721412117747636017440 0ustar coqcoq00000000000000(* This program is free software; you can redistribute it and/or *) (* modify it under the terms of the GNU Lesser General Public License *) (* as published by the Free Software Foundation; either version 2.1 *) (* of the License, or (at your option) any later version. *) (* *) (* This program is distributed in the hope that it will be useful, *) (* but WITHOUT ANY WARRANTY; without even the implied warranty of *) (* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *) (* GNU General Public License for more details. *) (* *) (* You should have received a copy of the GNU Lesser General Public *) (* License along with this program; if not, write to the Free *) (* Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA *) (* 02110-1301 USA *) Require Export angles_vecteurs. Set Implicit Arguments. Unset Strict Implicit. Definition double_AV (angl : AV) := plus angl angl. Lemma double_Chasles : forall A B C D E F : PO, A <> B :>PO -> C <> D :>PO -> E <> F :>PO -> plus (double_AV (cons_AV (vec A B) (vec C D))) (double_AV (cons_AV (vec C D) (vec E F))) = double_AV (cons_AV (vec A B) (vec E F)) :>AV. unfold double_AV in |- *. intros. replace (plus (plus (cons_AV (vec A B) (vec C D)) (cons_AV (vec A B) (vec C D))) (plus (cons_AV (vec C D) (vec E F)) (cons_AV (vec C D) (vec E F)))) with (plus (plus (cons_AV (vec A B) (vec C D)) (cons_AV (vec C D) (vec E F))) (plus (cons_AV (vec A B) (vec C D)) (cons_AV (vec C D) (vec E F)))). rewrite Chasles; auto. mesure A B C D. mesure C D E F. replace (x + x0 + (x + x0)) with (x + x + (x0 + x0)); auto. ring. Qed. Lemma double_opp : forall A B C D : PO, A <> B :>PO -> C <> D :>PO -> double_AV (opp (cons_AV (vec A B) (vec C D))) = opp (double_AV (cons_AV (vec A B) (vec C D))) :>AV. unfold double_AV in |- *; intros. rewrite <- opp_plus_plus_opp; auto. Qed. Lemma zero_plus_double : forall A B C D : PO, A <> B :>PO -> C <> D :>PO -> plus (image_angle 0) (double_AV (cons_AV (vec A B) (vec C D))) = double_AV (cons_AV (vec A B) (vec C D)) :>AV. intros. replace (image_angle 0) with (double_AV (cons_AV (vec A B) (vec A B))). rewrite double_Chasles; auto. unfold double_AV in |- *. rewrite <- angle_nul; auto. rewrite <- add_mes_compatible; auto. replace (0 + 0) with 0; auto. ring. Qed. Lemma angle_alignes : forall A B C : PO, A <> B :>PO -> A <> C :>PO -> alignes A B C -> double_AV (cons_AV (vec A B) (vec A C)) = image_angle 0. intros A B C H H0 H1; unfold double_AV in |- *. rewrite angles_representants_unitaires; auto. elim alignes_representant_unitaire with (A := A) (B := B) (C := C); [ intros; try clear alignes_representant_unitaire; auto | intros; auto | auto | auto | auto ]. rewrite H2. rewrite <- angles_representants_unitaires; auto. rewrite <- angle_nul; auto. rewrite <- add_mes_compatible. replace (0 + 0) with 0; try ring; auto. elim existence_representant_unitaire with (A := A) (B := B); [ intros; try clear existence_representant_unitaire | auto ]. rewrite <- H3. replace (representant_unitaire (vec A C)) with (vec x A). cut (A <> x); intros. rewrite <- angle_plat; auto. rewrite <- add_mes_compatible. replace (pi + pi) with deuxpi; auto. rewrite pi_plus_pi; auto. apply distance_non_nulle. elim def_representant_unitaire2 with (A := A) (B := B) (C := x); [ intros; elim H5; intros H22 H23; rewrite H22; try discrR | auto | auto ]. rewrite H2; rewrite <- H3. Ringvec. Qed. Lemma angle_droites_paralleles : forall A B C D : PO, A <> B :>PO -> C <> D :>PO -> paralleles (droite C D) (droite A B) -> double_AV (cons_AV (vec A B) (vec C D)) = image_angle 0. intros. elim paralleles_vecteur with (A := C) (B := D) (C := A) (D := B); [ intros k H3; try clear paralleles_vecteur; auto | auto | auto | auto ]. elim existence_representant_mult_vecteur with (A := A) (B := A) (C := B) (k := k); intros E H4; try clear existence_representant_mult_vecteur; try exact H4. cut (vec C D = vec A E); intros. rewrite H2. cut (alignes A B E); intros. apply angle_alignes with (3 := H5); auto. unfold not in |- *; intros; apply H0. apply conversion_PP with (a := 1) (b := 1); auto with real. RingPP2 H2. rewrite H6. Ringvec. apply colineaire_alignes with k; auto. rewrite H4; auto. Qed. Lemma alignement_et_angles : forall A B C D E F : PO, A <> B :>PO -> D <> E :>PO -> A <> C :>PO -> D <> F :>PO -> alignes A B C -> alignes D E F -> double_AV (cons_AV (vec A B) (vec D E)) = double_AV (cons_AV (vec A C) (vec D F)) :>AV. intros; unfold double_AV in |- *. rewrite angles_representants_unitaires; auto. rewrite angles_representants_unitaires; auto. elim existence_representant_unitaire with (A := D) (B := E); [ intros; try clear existence_representant_unitaire | auto ]. cut (D <> x); intros. elim existence_representant_unitaire with (A := A) (B := C); [ intros; try clear existence_representant_unitaire | auto ]. cut (A <> x0); intros. elim existence_representant_vecteur with (A := A) (B := D) (C := x); intros. cut (A <> x1); intros. elim alignes_representant_unitaire with (A := A) (B := B) (C := C); [ intros; try clear alignes_representant_unitaire; auto | intros; auto | auto | auto | auto ]. elim alignes_representant_unitaire with (A := D) (B := E) (C := F); [ intros; try clear alignes_representant_unitaire; auto | intros; auto | auto | auto | auto ]. rewrite H12; rewrite H11; auto. rewrite H12; rewrite H11; auto. replace (mult_PP (-1) (representant_unitaire (vec D E))) with (vec x D). rewrite <- H7; rewrite <- H5. replace (cons_AV (vec A x0) (vec x D)) with (plus (cons_AV (vec A x0) (vec D x)) (cons_AV (vec D x) (vec x D))). rewrite <- angle_plat; auto. rewrite <- H9. mesure A x0 A x1. replace (x2 + pi + (x2 + pi)) with (x2 + x2 + deuxpi); auto. rewrite (add_mes_compatible (x2 + x2) deuxpi). rewrite pi_plus_pi. rewrite <- add_mes_compatible. replace (x2 + x2 + 0) with (x2 + x2); auto. ring. unfold deuxpi; ring. rewrite Chasles; auto. rewrite <- H5. Ringvec. elim alignes_representant_unitaire with (A := D) (B := E) (C := F); [ intros; try clear alignes_representant_unitaire; auto | intros; auto | auto | auto | auto ]. replace (representant_unitaire (vec A B)) with (vec x0 A). rewrite <- H7; rewrite <- H12; rewrite <- H5; rewrite <- H9. replace (cons_AV (vec x0 A) (vec A x1)) with (plus (cons_AV (vec x0 A) (vec A x0)) (cons_AV (vec A x0) (vec A x1))). mesure A x0 A x1. rewrite <- angle_plat; auto. rewrite <- add_mes_compatible. rewrite <- add_mes_compatible. replace (pi + x2 + (pi + x2)) with (x2 + x2 + deuxpi); auto. rewrite (add_mes_compatible (x2 + x2) deuxpi). rewrite pi_plus_pi. rewrite <- add_mes_compatible. replace (x2 + x2 + 0) with (x2 + x2); auto. ring. unfold deuxpi; ring. rewrite Chasles; auto. replace (vec x0 A) with (mult_PP (-1) (representant_unitaire (vec A C))); auto. rewrite H11. Ringvec. rewrite <- H7. Ringvec. replace (representant_unitaire (vec A B)) with (vec x0 A). rewrite H12; auto. replace (mult_PP (-1) (representant_unitaire (vec D E))) with (vec x1 A). rewrite <- H7; rewrite <- H5; rewrite <- H9. replace (cons_AV (vec x0 A) (vec A x1)) with (plus (cons_AV (vec x0 A) (vec A x0)) (cons_AV (vec A x0) (vec A x1))). mesure A x0 A x1. rewrite <- angle_plat; auto. rewrite <- add_mes_compatible. replace (cons_AV (vec A x0) (vec x1 A)) with (plus (cons_AV (vec A x0) (vec A x1)) (cons_AV (vec A x1) (vec x1 A))). rewrite <- angle_plat; auto. rewrite <- H13. repeat rewrite <- add_mes_compatible. replace (pi + x2 + (pi + x2)) with (x2 + x2 + (pi + pi)); auto. replace (x2 + x2 + (pi + pi)) with (x2 + pi + (x2 + pi)); auto. unfold deuxpi; ring. ring. rewrite Chasles; auto. rewrite Chasles; auto. VReplace (vec x1 A) (mult_PP (-1) (vec A x1)); auto. rewrite H9; rewrite H5; auto. VReplace (vec x0 A) (mult_PP (-1) (vec A x0)). rewrite H7; rewrite H11. Ringvec. unfold not in |- *; intros; apply H6. apply conversion_PP with (a := 1) (b := 1); auto with real. cut (vec D x = vec A x1); intros. RingPP2 H11. rewrite H10. Ringvec. rewrite H9; auto. apply distance_non_nulle. elim def_representant_unitaire2 with (A := A) (B := C) (C := x0); [ intros; elim H9; intros H22 H23; rewrite H22; try discrR | auto | auto ]. apply distance_non_nulle. elim def_representant_unitaire2 with (A := D) (B := E) (C := x); [ intros; elim H7; intros H22 H23; rewrite H22; try discrR | auto | auto ]. Qed. Parameter AD : Type. Parameter cons_AD : DR -> DR -> AD. Axiom AV_vers_AD : forall A B C D E F G I : PO, A <> B :>PO -> C <> D :>PO -> E <> F :>PO -> G <> I :>PO -> double_AV (cons_AV (vec A B) (vec C D)) = double_AV (cons_AV (vec E F) (vec G I)) :>AV -> cons_AD (droite A B) (droite C D) = cons_AD (droite E F) (droite G I) :>AD. Lemma egalite_angles_droites : forall A B C D E F : PO, A <> B :>PO -> D <> E :>PO -> A <> C :>PO -> D <> F :>PO -> alignes A B C -> alignes D E F -> cons_AD (droite A B) (droite D E) = cons_AD (droite A C) (droite D F) :>AD. intros. apply AV_vers_AD; auto. apply alignement_et_angles; auto. Qed. Lemma angles_droites_colinearite : forall (A B C D E F G I : PO) (k1 k2 : R), A <> B :>PO -> C <> D :>PO -> E <> F :>PO -> G <> I :>PO -> vec E F = mult_PP k1 (vec A B) :>PP -> vec G I = mult_PP k2 (vec C D) :>PP -> cons_AD (droite A B) (droite C D) = cons_AD (droite E F) (droite G I) :>AD. intros. apply AV_vers_AD; auto. cut (k1 <> 0); intros. cut (k2 <> 0). intros H16; try assumption. elim existence_representant_vecteur with (A := A) (B := E) (C := F). intros J H6; try assumption. elim existence_representant_vecteur with (A := C) (B := G) (C := I). intros K H7; try assumption. rewrite <- H6 in H3. rewrite <- H7 in H4. cut (alignes A B J); intros. cut (A <> J); intros. cut (alignes C D K); intros. cut (C <> K); intros. rewrite (alignement_et_angles (A:=A) (B:=B) (C:=J) (D:=C) (E:=D) (F:=K)); auto. rewrite H6; rewrite H7; auto. apply distinct_produit_vecteur with (3 := H4); auto. apply colineaire_alignes with (1 := H4); auto. apply distinct_produit_vecteur with (3 := H3); auto. apply colineaire_alignes with (1 := H3); auto. red in |- *; intros; apply H2. apply conversion_PP with (a := 1) (b := 1); auto; try discrR. unfold vec in H4. RingPP2 H4. rewrite H6. RingPP. red in |- *; intros; apply H1. unfold vec in H3. apply conversion_PP with (a := 1) (b := 1); auto; try discrR. RingPP2 H3. rewrite H5. RingPP. Qed. Lemma angles_et_colinearite : forall (A B C D E F G I : PO) (k1 k2 : R), A <> B :>PO -> C <> D :>PO -> E <> F :>PO -> G <> I :>PO -> vec E F = mult_PP k1 (vec A B) :>PP -> vec G I = mult_PP k2 (vec C D) :>PP -> double_AV (cons_AV (vec A B) (vec C D)) = double_AV (cons_AV (vec E F) (vec G I)) :>AV. intros A B C D E F G I k1 k2 H H0 H1 H2 H3 H4; try assumption. cut (k1 <> 0); intros. cut (k2 <> 0). intros H16; try assumption. elim existence_representant_vecteur with (A := A) (B := E) (C := F). intros J H6; try assumption. elim existence_representant_vecteur with (A := C) (B := G) (C := I). intros K H7; try assumption. rewrite <- H6 in H3. rewrite <- H7 in H4. cut (alignes A B J); intros. cut (A <> J); intros. cut (alignes C D K); intros. cut (C <> K); intros. rewrite (alignement_et_angles (A:=A) (B:=B) (C:=J) (D:=C) (E:=D) (F:=K)); auto. rewrite H6; rewrite H7; auto. apply distinct_produit_vecteur with (3 := H4); auto. apply colineaire_alignes with (1 := H4); auto. apply distinct_produit_vecteur with (3 := H3); auto. apply colineaire_alignes with (1 := H3); auto. red in |- *; intros; apply H2. apply conversion_PP with (a := 1) (b := 1); auto; try discrR. unfold vec in H4. RingPP2 H4. rewrite H6. RingPP. red in |- *; intros; apply H1. unfold vec in H3. apply conversion_PP with (a := 1) (b := 1); auto; try discrR. RingPP2 H3. rewrite H5. RingPP. Qed. Lemma angles_et_paralleles : forall A B C D E F G I : PO, A <> B :>PO -> C <> D :>PO -> E <> F :>PO -> G <> I :>PO -> paralleles (droite E F) (droite A B) -> paralleles (droite G I) (droite C D) -> double_AV (cons_AV (vec A B) (vec C D)) = double_AV (cons_AV (vec E F) (vec G I)) :>AV. intros A B C D E F G I H H0 H1 H2 H3 H4; try assumption. elim (paralleles_vecteur (A:=E) (B:=F) (C:=A) (D:=B)); auto. intros x H5; try assumption. elim (paralleles_vecteur (A:=G) (B:=I) (C:=C) (D:=D)); auto. intros x0 H6; try assumption. apply angles_et_colinearite with (k1 := x) (k2 := x0); auto. Qed. Lemma angles_droites_paralleles : forall A B C D E F G I : PO, A <> B :>PO -> C <> D :>PO -> E <> F :>PO -> G <> I :>PO -> paralleles (droite E F) (droite A B) -> paralleles (droite G I) (droite C D) -> cons_AD (droite A B) (droite C D) = cons_AD (droite E F) (droite G I) :>AD. intros A B C D E F G I H H0 H1 H2 H3 H4; try assumption. elim (paralleles_vecteur (A:=E) (B:=F) (C:=A) (D:=B)); auto. intros x H5; try assumption. elim (paralleles_vecteur (A:=G) (B:=I) (C:=C) (D:=D)); auto. intros x0 H6; try assumption. apply angles_droites_colinearite with (k1 := x) (k2 := x0); auto. Qed. Lemma angle_non_paralleles : forall A B C D : PO, A <> B :>PO -> C <> D :>PO -> double_AV (cons_AV (vec A B) (vec C D)) <> image_angle 0 :>AV -> ~ paralleles (droite C D) (droite A B). intros; red in |- *; intros. apply H1; apply angle_droites_paralleles; auto. Qed. Axiom droites_paralleles_angle : forall A B C D : PO, A <> B :>PO -> C <> D :>PO -> double_AV (cons_AV (vec A B) (vec C D)) = image_angle 0 -> paralleles (droite A B) (droite C D). Lemma existence_orthogonal : forall A B : PO, A <> B :>PO -> ex (fun C : PO => A <> C :>PO /\ orthogonal (vec A B) (vec A C)). intros. elim existence_representant_unitaire with (A := A) (B := B); [ intros D H0; try clear existence_representant_unitaire; try exact H0 | auto ]. elim existence_representant_angle with (A := A) (B := D) (C := A) (x := pisurdeux); [ intros C H2; elim H2; intros H3 H4; try clear H2; try exact H4 | auto ]. exists C. split; [ auto with geo | idtac ]. apply pisurdeux_droit. rewrite angles_representants_unitaires; auto with geo. replace (representant_unitaire (vec A C)) with (vec A C); auto with geo. rewrite <- H0; auto. elim def_representant_unitaire2 with (A := A) (B := B) (C := D); auto; intros. elim H2; intros; auto with geo. Qed. Comments "," "soit_orthogonal" "cree" "un" "vecteur" "AC" "orthogonal" "a" "AB" "et" "echoue" "si" "A=B". Ltac soit_orthogonal A B C := elim (existence_orthogonal (A:=A) (B:=B)); [ intros C toto; elim toto; clear toto; intros | auto ]. Lemma orthogonal_angles : forall A B C D : PO, A <> B :>PO -> C <> D :>PO -> orthogonal (vec A B) (vec C D) -> double_AV (cons_AV (vec A B) (vec C D)) = image_angle pi. intros. elim existence_representant_unitaire with (A := A) (B := B); [ intros E H2; try clear existence_representant_unitaire; try exact H2 | auto ]. elim existence_representant_angle with (A := A) (B := E) (C := A) (x := pisurdeux); [ intros F H5; elim H5; intros H3 H4; try clear H5; try exact H4 | auto ]. cut (orthogonal (vec A B) (vec A F)); intros. elim (orthogonal_paralleles (A:=A) (B:=B) (C:=F) (E:=C) (F:=D)); auto with geo; intros. cut (x <> 0); intros. rewrite (angles_et_colinearite (A:=A) (B:=B) (C:=C) (D:=D) (E:=A) (F:=B) (G:=A) (I:=F) (k1:=1) (k2:=/ x)); auto with geo. rewrite angles_representants_unitaires; auto with geo. replace (representant_unitaire (vec A F)) with (vec A F); auto with geo. rewrite <- H2; auto. unfold double_AV in |- *; rewrite <- H4. rewrite <- add_mes_compatible; (unfold pi in |- *; auto with geo). Ringvec. rewrite H6. Fieldvec x. red in |- *; intros; apply H0. apply (produit_zero_conf H6); auto. apply pisurdeux_droit. rewrite angles_representants_unitaires; auto with geo. replace (representant_unitaire (vec A F)) with (vec A F); auto with geo. rewrite <- H2; auto. apply carre_scalaire_1_distance; auto. elim def_representant_unitaire2 with (A := A) (B := B) (C := E); auto; intros. elim H4; auto. Qed. Lemma angles_orthogonal : forall A B C D : PO, A <> B :>PO -> C <> D :>PO -> double_AV (cons_AV (vec A B) (vec C D)) = image_angle pi :>AV -> orthogonal (vec A B) (vec C D). intros. soit_orthogonal A B ipattern:E. apply ortho_sym. apply paralleles_orthogonal with (A := A) (B := E); auto with geo. apply droites_paralleles_angle; auto. replace (double_AV (cons_AV (vec A E) (vec C D))) with (plus (double_AV (cons_AV (vec A E) (vec A B))) (double_AV (cons_AV (vec A B) (vec C D)))); auto. cut (double_AV (cons_AV (vec A E) (vec A B)) = image_angle pi); intros. rewrite H1; rewrite H4; rewrite <- add_mes_compatible; rewrite <- pi_plus_pi; (unfold deuxpi in |- *; auto). apply orthogonal_angles; auto with geo. rewrite double_Chasles; auto with geo. Qed. Lemma angles_droites_orthogonales : forall A B C D E F G I : PO, A <> B :>PO -> C <> D :>PO -> E <> F :>PO -> G <> I :>PO -> orthogonal (vec A B) (vec E F) -> orthogonal (vec C D) (vec G I) -> double_AV (cons_AV (vec E F) (vec G I)) = double_AV (cons_AV (vec A B) (vec C D)). unfold double_AV in |- *; intros. replace (cons_AV (vec A B) (vec C D)) with (plus (plus (cons_AV (vec A B) (vec E F)) (cons_AV (vec E F) (vec G I))) (cons_AV (vec G I) (vec C D))). mesure E F G I. mesure A B E F. mesure G I C D. replace (x0 + x + x1 + (x0 + x + x1)) with (x + x + (x0 + x0) + (x1 + x1)). symmetry in |- *. rewrite add_mes_compatible. rewrite add_mes_compatible. replace (image_angle (x0 + x0)) with (image_angle pi). replace (image_angle (x1 + x1)) with (image_angle pi). repeat rewrite <- add_mes_compatible. replace (x + x + pi + pi) with (x + x + deuxpi). rewrite add_mes_compatible; rewrite pi_plus_pi; rewrite <- add_mes_compatible. replace (x + x + 0) with (x + x); auto. ring. unfold deuxpi in |- *; ring. rewrite add_mes_compatible; rewrite H7. replace (plus (cons_AV (vec G I) (vec C D)) (cons_AV (vec G I) (vec C D))) with (double_AV (cons_AV (vec G I) (vec C D))); auto. rewrite orthogonal_angles; auto with geo. rewrite add_mes_compatible; rewrite H6. replace (plus (cons_AV (vec A B) (vec E F)) (cons_AV (vec A B) (vec E F))) with (double_AV (cons_AV (vec A B) (vec E F))); auto. rewrite orthogonal_angles; auto with geo. ring. rewrite Chasles; auto. rewrite Chasles; auto. Qed. Lemma angles_droites_droites_orthogonales : forall A B C D E F G I : PO, A <> B :>PO -> C <> D :>PO -> E <> F :>PO -> G <> I :>PO -> orthogonal (vec A B) (vec E F) -> orthogonal (vec C D) (vec G I) -> cons_AD (droite E F) (droite G I) = cons_AD (droite A B) (droite C D). intros. apply AV_vers_AD; auto. apply angles_droites_orthogonales; auto. Qed. Lemma alignes_angle : forall A B C : PO, A <> B :>PO -> A <> C :>PO -> double_AV (cons_AV (vec A B) (vec A C)) = image_angle 0 -> alignes A B C. intros. cut (paralleles (droite A B) (droite A C)); intros. elim (paralleles_vecteur (A:=A) (B:=B) (C:=A) (D:=C)); auto; intros. lapply (colineaire_alignes (k:=x) (A:=A) (B:=C) (C:=B)); auto with geo. apply droites_paralleles_angle; auto. Qed. Hint Resolve alignes_angle: geo. Lemma non_alignes_angle : forall A B C : PO, A <> B :>PO -> A <> C :>PO -> ~ alignes A B C -> double_AV (cons_AV (vec A B) (vec A C)) <> image_angle 0 :>AV. red in |- *; intros. apply H1. apply alignes_angle; auto with geo. Qed. Lemma angle_non_alignes : forall A B C : PO, A <> B :>PO -> A <> C :>PO -> double_AV (cons_AV (vec A B) (vec A C)) <> image_angle 0 :>AV -> ~ alignes A B C. intros. cut (~ paralleles (droite A C) (droite A B)); intros. red in |- *; intros; apply H2. apply paralleles_sym; auto. apply alignes_paralleles; auto. apply angle_non_paralleles; auto. Qed. Lemma alignement_triangle : forall A B C D E : PO, A <> D :>PO -> A <> E :>PO -> triangle A B C -> alignes A B D -> alignes A C E -> triangle A D E. intros. deroule_triangle A B C. apply angle_non_alignes; auto with geo. rewrite <- (alignement_et_angles (A:=A) (B:=B) (C:=D) (D:=A) (E:=C) (F:=E)); auto with geo. Qed. HighSchoolGeometry/angles_vecteurs.v0000644000076500007650000005473612117747636017636 0ustar coqcoq00000000000000(* This program is free software; you can redistribute it and/or *) (* modify it under the terms of the GNU Lesser General Public License *) (* as published by the Free Software Foundation; either version 2.1 *) (* of the License, or (at your option) any later version. *) (* *) (* This program is distributed in the hope that it will be useful, *) (* but WITHOUT ANY WARRANTY; without even the implied warranty of *) (* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *) (* GNU General Public License for more details. *) (* *) (* You should have received a copy of the GNU Lesser General Public *) (* License along with this program; if not, write to the Free *) (* Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA *) (* 02110-1301 USA *) Require Export repere_ortho_plan. Set Implicit Arguments. Unset Strict Implicit. Parameter AV : Type. Parameter cons_AV : PP -> PP -> AV. Parameter plus : AV -> AV -> AV. Parameter opp : AV -> AV. Axiom existence_AB_unitaire : exists A : PO, (exists B : PO, distance A B = 1). (* Tout angle a un représentant non unique parmi les angles orientés de vecteurs unitaires*) Axiom existence_representant_cons : forall (a : AV) (A B C : PO), distance A B = 1 -> exists D : PO, distance C D = 1 /\ a = cons_AV (vec A B) (vec C D). (* Tout angle orienté de vecteurs non nuls est égal à l'angle orienté des vecteurs unitaires correspondants*) Axiom angles_representants_unitaires : forall A B C D E F : PO, A <> B -> C <> D -> cons_AV (vec A B) (vec C D) = cons_AV (representant_unitaire (vec A B)) (representant_unitaire (vec C D)). Axiom Chasles : forall A B C D E F : PO, A <> B -> C <> D -> E <> F -> plus (cons_AV (vec A B) (vec C D)) (cons_AV (vec C D) (vec E F)) = cons_AV (vec A B) (vec E F). Axiom def_opp : forall A B C D : PO, A <> B -> C <> D -> opp (cons_AV (vec A B) (vec C D)) = cons_AV (vec C D) (vec A B). Parameter AV0 : AV. (* Enroulement de R sur le cercle trigonométrique*) Parameter image_angle : R -> AV. Axiom AV0_zero : AV0 = image_angle 0. Axiom unicite_representant_angle_nul : forall A B C : PO, distance A B = 1 -> distance A C = 1 -> cons_AV (vec A B) (vec A C) = image_angle 0 -> C = B. Axiom tout_angle_a_une_mesure : forall A B C D : PO, A <> B :>PO -> C <> D :>PO -> exists x : R, image_angle x = cons_AV (vec A B) (vec C D) :>AV. (* Compatibilité des opérations *) Axiom add_mes_compatible : forall x y : R, image_angle (x + y) = plus (image_angle x) (image_angle y). Axiom mes_opp : forall x : R, image_angle (- x) = opp (image_angle x). (* Cas particuliers : angles plats et angles droits*) Parameter pisurdeux : R. Definition pi := pisurdeux + pisurdeux. Definition deuxpi := pi + pi. Axiom angle_plat : forall A B : PO, A <> B -> image_angle pi = cons_AV (vec A B) (vec B A). Axiom pisurdeux_droit : forall A B C : PO, image_angle pisurdeux = cons_AV (vec A B) (vec A C) -> orthogonal (vec A B) (vec A C). Axiom droit_direct_ou_indirect : forall A B C : PO, A <> B -> A <> C -> orthogonal (vec A B) (vec A C) -> image_angle pisurdeux = cons_AV (vec A B) (vec A C) \/ image_angle (- pisurdeux) = cons_AV (vec A B) (vec A C). Lemma existence_representant_angle : forall (A B C : PO) (x : R), distance A B = 1 -> exists D : PO, distance C D = 1 /\ image_angle x = cons_AV (vec A B) (vec C D). intros. apply existence_representant_cons; auto. Qed. Lemma tout_angle_mesure : forall a : AV, exists x : R, a = image_angle x :>AV. intros. elim existence_AB_unitaire; [ intros A H; elim H; [ intros B H0; try clear H existence_AB_unitaire; try exact H0 ] ]. elim existence_representant_cons with (a := a) (A := A) (B := B) (C := A); [ intros D H1; elim H1; [ intros H2 H3; try clear H1 existence_representant_cons; try exact H3 ] | auto ]. elim (tout_angle_a_une_mesure (A:=A) (B:=B) (C:=A) (D:=D)); auto with geo; intros. exists x. rewrite H4; auto. Qed. Hint Resolve mes_opp add_mes_compatible: geo. Ltac mes a := elim (tout_angle_mesure a); intros; match goal with | h:(a = image_angle ?X1) |- _ => try rewrite h; repeat rewrite <- mes_opp; repeat rewrite <- add_mes_compatible; repeat rewrite <- mes_opp end. Hint Resolve def_opp Chasles angles_representants_unitaires: geo. Ltac mesure A B C D := elim (tout_angle_a_une_mesure (A:=A) (B:=B) (C:=C) (D:=D)); auto with geo; intros; match goal with | h:(image_angle ?X1 = cons_AV (vec A B) (vec C D)) |- _ => try rewrite <- h; repeat rewrite <- mes_opp; repeat rewrite <- add_mes_compatible; repeat rewrite <- mes_opp end. Lemma plus_commutative : forall a b : AV, plus a b = plus b a :>AV. intros. mes a. mes b. repeat rewrite <- add_mes_compatible. replace (x + x0) with (x0 + x); [ auto | ring ]. Qed. Lemma plus_angle_zero : forall a : AV, plus a (image_angle 0) = a. intros. mes a. replace (x + 0) with x; [ auto | ring ]. Qed. Lemma plus_associative : forall a b c : AV, plus a (plus b c) = plus (plus a b) c :>AV. intros. mes a. mes b. mes c. replace (x + (x0 + x1)) with (x + x0 + x1); [ auto | ring ]. Qed. Hint Resolve plus_angle_zero: geo. Lemma opp_angle : forall a b : AV, plus a b = image_angle 0 :>AV -> b = opp a :>AV. intros. mes a. mes b. replace (image_angle (- x)) with (plus (image_angle (- x)) (image_angle 0)); auto with geo. rewrite <- H. rewrite H1; rewrite H0. repeat rewrite <- add_mes_compatible. pattern x0 at 1 in |- *. replace x0 with (- x + (x + x0)); auto. ring. Qed. Lemma plus_angle_oppose : forall a : AV, plus a (opp a) = image_angle 0. intros. mes a. replace (x + - x) with 0; [ auto | ring ]. Qed. Lemma mes_oppx : forall (A B C D : PO) (x : R), A <> B -> C <> D -> image_angle x = cons_AV (vec A B) (vec C D) -> image_angle (- x) = cons_AV (vec C D) (vec A B). intros. rewrite <- def_opp; auto. rewrite <- H1; rewrite <- mes_opp; auto with geo. Qed. Lemma mes_opp_opp : forall (A B C D E F G I : PO) (a b : R), A <> B -> C <> D -> E <> F -> G <> I -> image_angle a = cons_AV (vec A B) (vec C D) -> image_angle b = cons_AV (vec E F) (vec G I) -> image_angle b = image_angle (- a) -> cons_AV (vec E F) (vec G I) = opp (cons_AV (vec A B) (vec C D)). intros A B C D E F G I a b H H0 H1 H2 H3 H4 H5; try assumption. rewrite <- H4; rewrite def_opp; auto. rewrite <- (mes_oppx (A:=A) (B:=B) (C:=C) (D:=D) (x:=a)); auto. Qed. Lemma permute_angles : forall A B C D E F G I : PO, A <> B :>PO -> C <> D :>PO -> E <> F :>PO -> G <> I :>PO -> cons_AV (vec A B) (vec C D) = cons_AV (vec E F) (vec G I) :>AV -> cons_AV (vec C D) (vec A B) = cons_AV (vec G I) (vec E F) :>AV. intros A B C D E F G I H H0 H1 H2 H3; try assumption. rewrite <- def_opp; auto. rewrite <- (def_opp (A:=E) (B:=F) (C:=G) (D:=I)); auto. rewrite <- H3; auto. Qed. Hint Resolve permute_angles: geo. Lemma opp_plus_plus_opp : forall A B C D E F G I : PO, A <> B :>PO -> C <> D :>PO -> E <> F :>PO -> G <> I :>PO -> opp (plus (cons_AV (vec A B) (vec C D)) (cons_AV (vec E F) (vec G I))) = plus (opp (cons_AV (vec A B) (vec C D))) (opp (cons_AV (vec E F) (vec G I))) :>AV. intros A B C D E F G I H H0 H1 H2; try assumption. mesure A B C D. mesure E F G I. replace (- (x + x0)) with (- x + - x0); auto. ring. Qed. Hint Resolve opp_plus_plus_opp: geo. Lemma Chasles_diff : forall A B C D E F : PO, A <> B :>PO -> C <> D :>PO -> E <> F :>PO -> plus (cons_AV (vec A B) (vec C D)) (opp (cons_AV (vec A B) (vec E F))) = cons_AV (vec E F) (vec C D) :>AV. intros. rewrite def_opp; auto. rewrite plus_commutative; auto with geo. Qed. Hint Resolve pisurdeux_droit: geo. Lemma pisurdeux_scalaire_nul : forall A B C : PO, image_angle pisurdeux = cons_AV (vec A B) (vec A C) -> scalaire (vec A B) (vec A C) = 0. intros. apply def_orthogonal. apply pisurdeux_droit; auto. Qed. Hint Resolve pisurdeux_scalaire_nul: geo. Lemma orthogonal_pisurdeux_or : forall A B C D : PO, A <> B -> C <> D -> orthogonal (vec A B) (vec C D) -> image_angle pisurdeux = cons_AV (vec A B) (vec C D) \/ image_angle (- pisurdeux) = cons_AV (vec A B) (vec C D). intros A B C D H H0; try assumption. elim existence_representant_vecteur with (A := A) (B := C) (C := D); [ intros E H2; rewrite <- H2; intros ]. apply droit_direct_ou_indirect; auto. apply distinct_egalite_vecteur with (2 := H2); auto. Qed. Lemma angle_nul : forall A B : PO, A <> B -> image_angle 0 = cons_AV (vec A B) (vec A B). intros. elim existence_representant_unitaire with (A := A) (B := B); [ intros C H0; try clear existence_representant_unitaire; try exact H0 | auto ]. rewrite angles_representants_unitaires; auto. rewrite <- H0. cut (A <> C); intros. cut (image_angle (- pi) = cons_AV (vec C A) (vec A C)); intros. replace 0 with (pi + - pi). rewrite add_mes_compatible; rewrite H2; rewrite (angle_plat (A:=A) (B:=C)); auto. rewrite Chasles; auto. ring. apply mes_oppx; auto. rewrite (angle_plat (A:=A) (B:=C)); auto. elim (def_representant_unitaire2 (A:=A) (B:=B) (C:=C)); auto; intros. elim H2; auto with geo. Qed. Lemma pi_plus_pi : image_angle deuxpi = image_angle 0. unfold deuxpi in |- *; intros. elim existence_AB_unitaire; intros A H; elim H; intros B H0; try clear H; try exact H0. cut (A <> B); intros. rewrite add_mes_compatible. pattern (image_angle pi) at 1 in |- *. rewrite (angle_plat (A:=A) (B:=B)); auto. rewrite (angle_plat (A:=B) (B:=A)); auto. rewrite Chasles; auto. rewrite <- angle_nul; auto. auto with geo. Qed. Lemma mesure_mod_deuxpi : forall (x : R) (A B C D : PO), A <> B -> C <> D -> image_angle x = cons_AV (vec A B) (vec C D) -> image_angle (x + deuxpi) = cons_AV (vec A B) (vec C D). intros. rewrite add_mes_compatible. rewrite pi_plus_pi. rewrite H1. rewrite (angle_nul (A:=C) (B:=D)); auto. apply Chasles; auto. Qed. Lemma angle_oppu_oppv : forall A B C D : PO, A <> B :>PO -> C <> D :>PO -> cons_AV (vec B A) (vec D C) = cons_AV (vec A B) (vec C D) :>AV. intros. replace (cons_AV (vec B A) (vec D C)) with (plus (cons_AV (vec B A) (vec A B)) (plus (cons_AV (vec A B) (vec C D)) (cons_AV (vec C D) (vec D C)))). rewrite <- angle_plat; auto. rewrite <- angle_plat; auto. mesure A B C D. replace (pi + (x + pi)) with (x + deuxpi); try ring; auto. rewrite (mesure_mod_deuxpi (x:=x) (A:=A) (B:=B) (C:=C) (D:=D)); auto. unfold deuxpi in |- *; ring. repeat rewrite Chasles; auto. Qed. Hint Resolve angle_oppu_oppv: geo. Theorem somme_triangle : forall A B C : PO, A <> B :>PO -> A <> C :>PO -> B <> C :>PO -> plus (cons_AV (vec A B) (vec A C)) (plus (cons_AV (vec B C) (vec B A)) (cons_AV (vec C A) (vec C B))) = image_angle pi :>AV. intros A B C H H0 H1; try assumption. rewrite <- (angle_oppu_oppv (A:=C) (B:=A) (C:=C) (D:=B)); auto. mesure A B A C. mesure B C B A. mesure A C B C. replace (x + (x0 + x1)) with (x + x1 + x0). repeat rewrite add_mes_compatible. rewrite H4; rewrite H3; rewrite H2; repeat rewrite Chasles; auto. rewrite <- angle_plat; auto. ring. Qed. Lemma angle_triangle : forall A B C : PO, A <> B -> A <> C -> B <> C -> plus (image_angle pi) (opp (plus (cons_AV (vec A B) (vec A C)) (cons_AV (vec B C) (vec B A)))) = cons_AV (vec C A) (vec C B). intros. rewrite <- (somme_triangle (A:=A) (B:=B) (C:=C)); auto. rewrite opp_plus_plus_opp; auto. mesure B C B A. mesure C A C B. mesure A B A C. replace (x1 + (x + x0) + (- x1 + - x)) with x0; auto. ring. Qed. Hint Resolve angle_triangle: geo. Lemma angles_complementaires_triangle_rectangle : forall (A B C : PO) (a : R), A <> B -> A <> C -> B <> C -> orthogonal (vec B A) (vec B C) -> image_angle a = cons_AV (vec A B) (vec A C) -> image_angle (pisurdeux + - a) = cons_AV (vec C A) (vec C B) \/ image_angle (- pisurdeux + - a) = cons_AV (vec C A) (vec C B). intros. generalize (somme_triangle (A:=A) (B:=B) (C:=C)); intros. replace (cons_AV (vec C A) (vec C B)) with (plus (image_angle pi) (opp (plus (cons_AV (vec A B) (vec A C)) (cons_AV (vec B C) (vec B A))))); auto with geo. rewrite opp_plus_plus_opp; auto. rewrite <- H3. elim orthogonal_pisurdeux_or with (A := B) (B := C) (C := B) (D := A); [ intros H10; try clear orthogonal_pisurdeux_or | intros H10; try clear orthogonal_pisurdeux_or | auto | auto | auto with geo ]. rewrite <- H10. repeat rewrite <- mes_opp. repeat rewrite <- add_mes_compatible. left; try assumption. replace (pisurdeux + - a) with (pi + (- a + - pisurdeux)); auto. unfold pi in |- *; ring. rewrite <- H10. repeat rewrite <- mes_opp. repeat rewrite <- add_mes_compatible. right; try assumption. rewrite <- (plus_angle_zero (image_angle (- pisurdeux + - a))). rewrite <- pi_plus_pi. repeat rewrite <- add_mes_compatible. replace (- pisurdeux + - a + deuxpi) with (pi + (- a + - - pisurdeux)); auto. unfold deuxpi, pi in |- *; ring. Qed. Lemma angle_produit_positif_r : forall (k : R) (A B C D E : PO), A <> B :>PO -> D <> E :>PO -> k > 0 -> vec A C = mult_PP k (vec A B) :>PP -> cons_AV (vec D E) (vec A C) = cons_AV (vec D E) (vec A B). intros. cut (A <> C); intros. 2: apply distinct_produit_vecteur with (3 := H2); auto. rewrite angles_representants_unitaires; auto. rewrite angles_representants_unitaires; auto. rewrite (produit_positif_representant_unitaire (k:=k) (A:=A) (B:=B) (C:=C)); auto. auto with real. Qed. Hint Resolve angles_representants_unitaires: geo. Lemma angle_produit_negatif_r : forall (k : R) (A B C D E : PO), A <> B -> D <> E -> k < 0 -> vec A C = mult_PP k (vec A B) -> cons_AV (vec D E) (vec A C) = plus (cons_AV (vec D E) (vec A B)) (image_angle pi). intros. cut (A <> C); intros. 2: apply distinct_produit_vecteur with (3 := H2); auto. rewrite angles_representants_unitaires; auto. rewrite angles_representants_unitaires; auto. rewrite (produit_negatif_representant_unitaire (k:=k) (A:=A) (B:=B) (C:=C)); auto. elim existence_representant_unitaire with (A := A) (B := B); [ intros B' H4 | auto ]. rewrite <- H4. elim def_representant_unitaire2 with (A := A) (B := B) (C := B'); [ intros; elim H6; intros H7 H8; try clear H6; try exact H7 | auto | auto ]. cut (A <> B'); intros; auto with geo. replace (mult_PP (-1) (vec A B')) with (vec B' A); [ idtac | Ringvec ]. rewrite (angle_plat (A:=A) (B:=B')); auto. elim existence_representant_unitaire with (A := D) (B := E); [ intros F H9 | auto ]. elim def_representant_unitaire2 with (A := D) (B := E) (C := F); [ intros; elim H11; intros H12 H13; try clear H11; try exact H12 | auto | auto ]. cut (D <> F); intros; auto with geo. rewrite <- H9; rewrite Chasles; auto. auto with real. Qed. Lemma angle_produit_negatif_r2 : forall (k : R) (A B C D : PO), A <> B -> C <> D -> k < 0 -> cons_AV (vec C D) (mult_PP k (vec A B)) = plus (cons_AV (vec C D) (vec A B)) (image_angle pi). intros. elim existence_representant_mult_vecteur with (A := A) (B := A) (C := B) (k := k); intros E H2; try clear existence_representant_mult_vecteur; rewrite <- H2. rewrite (angle_produit_negatif_r (k:=k) (A:=A) (B:=B) (C:=E) (D:=C) (E:=D)); auto. Qed. Lemma angle_produit_negatif_l : forall (k : R) (A B C D : PO), A <> B -> C <> D -> k < 0 -> cons_AV (mult_PP k (vec A B)) (vec C D) = plus (cons_AV (vec A B) (vec C D)) (image_angle pi). intros. elim existence_representant_mult_vecteur with (A := A) (B := A) (C := B) (k := k); intros E H2; try clear existence_representant_mult_vecteur; rewrite <- H2. cut (A <> E); intros. cut (cons_AV (vec C D) (vec A E) = plus (cons_AV (vec C D) (vec A B)) (image_angle pi)); intros. 2: rewrite (angle_produit_negatif_r (k:=k) (A:=A) (B:=B) (C:=E) (D:=C) (E:=D)) ; auto. rewrite (angle_plat (A:=C) (B:=D)); auto. rewrite Chasles; auto. apply permute_angles; auto. rewrite H4. rewrite (angle_plat (A:=D) (B:=C)); auto. rewrite plus_commutative; rewrite Chasles; auto. apply distinct_produit_vecteur with (3 := H2); auto with real. Qed. Lemma angle_produit_positif_r2 : forall (k : R) (A B C D : PO), A <> B -> C <> D -> k > 0 -> cons_AV (vec C D) (mult_PP k (vec A B)) = cons_AV (vec C D) (vec A B). intros. elim existence_representant_mult_vecteur with (A := A) (B := A) (C := B) (k := k); intros E H2; try clear existence_representant_mult_vecteur; rewrite <- H2. rewrite (angle_produit_positif_r (k:=k) (A:=A) (B:=B) (C:=E) (D:=C) (E:=D)); auto. Qed. Lemma angle_produit_positif_l : forall (k : R) (A B C D : PO), A <> B -> C <> D -> k > 0 -> cons_AV (mult_PP k (vec A B)) (vec C D) = cons_AV (vec A B) (vec C D). intros. elim existence_representant_mult_vecteur with (A := A) (B := A) (C := B) (k := k); intros E H2; try clear existence_representant_mult_vecteur; rewrite <- H2. cut (A <> E); intros. cut (cons_AV (vec C D) (vec A E) = cons_AV (vec C D) (vec A B)); intros. 2: rewrite (angle_produit_positif_r (k:=k) (A:=A) (B:=B) (C:=E) (D:=C) (E:=D)) ; auto. apply permute_angles; auto. apply distinct_produit_vecteur with (3 := H2); auto with real. Qed. Lemma angle_nul_positif_colineaire : forall A B C : PO, A <> B -> A <> C -> cons_AV (vec A B) (vec A C) = image_angle 0 -> exists k : R, k > 0 /\ vec A C = mult_PP k (vec A B). intros A B C H H0; try assumption. cut (cons_AV (vec A B) (vec A C) = cons_AV (representant_unitaire (vec A B)) (representant_unitaire (vec A C))); auto with geo. elim existence_representant_unitaire with (A := A) (B := B); [ intros B' H3; try clear existence_representant_unitaire; rewrite <- H3 | auto ]. elim existence_representant_unitaire with (A := A) (B := C); [ intros C' H4; rewrite <- H4 | auto ]. intros H1; rewrite H1; intros. elim def_representant_unitaire2 with (A := A) (B := B) (C := B'); [ intros | auto | auto ]. elim def_representant_unitaire2 with (A := A) (B := C) (C := C'); [ intros | auto | auto ]. elim H8; intros H9 H10; try clear H8; try exact H10. elim H6; intros H8 H11; try clear H6; try exact H11. cut (C' = B'); intros. 2: apply unicite_representant_angle_nul with A; auto with geo. apply egalite_representant_unitaire; auto with geo. rewrite <- H4; rewrite <- H3; rewrite <- H6; auto. Qed. Lemma angles_milieu : forall A B C I : PO, B <> C :>PO -> B <> A :>PO -> I = milieu B C :>PO -> cons_AV (vec B C) (vec B A) = cons_AV (vec B I) (vec B A) :>AV. intros. replace (vec B C) with (mult_PP 2 (vec B I)); auto with geo. apply angle_produit_positif_l; auto. rewrite H1; apply milieu_distinct; auto. fourier. rewrite <- (milieu_vecteur_double (A:=B) (B:=C) (M:=I)); auto. Qed. Lemma angles_milieu2 : forall A B C I : PO, B <> C :>PO -> C <> A :>PO -> I = milieu B C :>PO -> cons_AV (vec C A) (vec C B) = cons_AV (vec C A) (vec C I) :>AV. intros. replace (vec C B) with (mult_PP 2 (vec C I)); auto with geo. apply angle_produit_positif_r2; auto. rewrite H1; apply milieu_distinct2; auto. fourier. rewrite <- (milieu_vecteur_double (A:=C) (B:=B) (M:=I)); auto with geo. Qed. Lemma milieu_angles : forall A B M N : PO, A <> B -> M <> N -> M = milieu A B -> cons_AV (vec M A) (vec M N) = plus (cons_AV (vec M B) (vec M N)) (image_angle pi) :>AV. intros. VReplace (vec M A) (mult_PP (-1) (vec A M)). rewrite <- (milieu_vecteur H1); auto. apply angle_produit_negatif_l; auto. cut (B <> M); intros; auto. rewrite H1; apply milieu_distinct; auto. rewrite H1; apply milieu_distinct2; auto. fourier. Qed. Axiom milieu_angles_orthogonaux : forall A B M N : PO, A <> B -> M <> N -> M = milieu A B -> orthogonal (vec A B) (vec M N) -> cons_AV (vec M A) (vec M N) = cons_AV (vec M N) (vec M B) :>AV. Lemma alignes_distance_positif_colineaire : forall (k : R) (A B C : PO), A <> B -> A <> C -> cons_AV (vec A B) (vec A C) = image_angle 0 -> distance A C = k * distance A B -> vec A C = mult_PP k (vec A B). intros. elim angle_nul_positif_colineaire with (A := A) (B := B) (C := C); [ intros k0 H3; elim H3; intros H4 H5; try clear H3; try exact H5 | auto | auto | auto ]. replace k with k0; auto. cut (distance A C = k0 * distance A B); intros. apply Rmult_eq_reg_l with (distance A B); auto with geo real. replace (distance A B * k0) with (distance A C) by (rewrite H3 in |- *; ring). rewrite H2 in |- *; ring. replace k0 with (Rabs k0); auto with geo real. apply Rabs_right; auto with real. fourier. Qed. Lemma angle_pi_negatif_colineaire : forall A B C : PO, A <> B -> A <> C -> cons_AV (vec A B) (vec A C) = image_angle pi -> exists k : R, k < 0 /\ vec A C = mult_PP k (vec A B). intros A B C H H0; try assumption. cut (cons_AV (vec A B) (vec A C) = cons_AV (representant_unitaire (vec A B)) (representant_unitaire (vec A C))); auto with geo. elim existence_representant_unitaire with (A := A) (B := B); [ intros B' H3; try clear existence_representant_unitaire; rewrite <- H3 | auto ]. elim existence_representant_unitaire with (A := A) (B := C); [ intros C' H4; rewrite <- H4 | auto ]. intros H1; rewrite H1; intros. elim def_representant_unitaire2 with (A := A) (B := B) (C := B'); [ intros | auto | auto ]. elim def_representant_unitaire2 with (A := A) (B := C) (C := C'); [ intros | auto | auto ]. elim H8; intros H9 H10; try clear H8; try exact H10. elim H6; intros H8 H11; try clear H6; try exact H11. cut (A <> B'); intros; auto with geo. cut (A <> C'); intros; auto with geo. apply oppose_representant_unitaire; auto. rewrite <- H4; rewrite <- H3. elim existence_representant_mult_vecteur with (A := A) (B := A) (C := B') (k := -1); intros D; intros. rewrite <- H13. replace D with C'; auto. cut (scalaire (vec A D) (vec A D) = 1); intros. apply unicite_representant_angle_nul with A; auto with geo. replace (vec A D) with (vec B' A). replace (cons_AV (vec B' A) (vec A C')) with (plus (cons_AV (vec B' A) (vec A B')) (cons_AV (vec A B') (vec A C'))). rewrite <- angle_plat; [ idtac | auto ]. rewrite H2; rewrite <- add_mes_compatible. replace (pi + pi) with deuxpi; auto. rewrite pi_plus_pi; auto. rewrite Chasles; auto. rewrite H13; Ringvec. rewrite H13; Simplscal; auto. Qed. Lemma alignes_distance_negatif_colineaire : forall (k : R) (A B C : PO), A <> B -> A <> C -> cons_AV (vec A B) (vec A C) = image_angle pi -> distance A C = k * distance A B -> vec A C = mult_PP (- k) (vec A B). intros. elim angle_pi_negatif_colineaire with (A := A) (B := B) (C := C); [ intros k0 H3; elim H3; intros H4 H5; try clear H3; try exact H5 | auto | auto | auto ]. replace k with (- k0). replace (- - k0) with k0; try ring; auto. cut (distance A C = - k0 * distance A B); intros; auto. apply Rmult_eq_reg_l with (distance A B); auto with geo. replace (distance A B * -k0) with (distance A C) by (rewrite H3 in |- *; ring). rewrite H2 in |- *; ring. replace (- k0) with (Rabs k0); auto with geo. apply Rabs_left; auto with real. Qed. Hint Resolve plus_angle_zero: geo. HighSchoolGeometry/applications_cocyclicite.v0000644000076500007650000004662712073525614021474 0ustar coqcoq00000000000000(* This program is free software; you can redistribute it and/or *) (* modify it under the terms of the GNU Lesser General Public License *) (* as published by the Free Software Foundation; either version 2.1 *) (* of the License, or (at your option) any later version. *) (* *) (* This program is distributed in the hope that it will be useful, *) (* but WITHOUT ANY WARRANTY; without even the implied warranty of *) (* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *) (* GNU General Public License for more details. *) (* *) (* You should have received a copy of the GNU Lesser General Public *) (* License along with this program; if not, write to the Free *) (* Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA *) (* 02110-1301 USA *) Require Export cocyclicite. Set Implicit Arguments. Unset Strict Implicit. Lemma cocycliques_ordre_cycle : forall A B C D : PO, sont_cocycliques A B C D -> sont_cocycliques B C D A. unfold sont_cocycliques, circonscrit, isocele in |- *; intros. elim H; intros O; intros. elim H0; intros. exists O. elim H1; intros. elim H2; intros; clear H H0 H1 H2. split; [ idtac | split; [ idtac | try assumption ] ]. split; [ try assumption | idtac ]. rewrite <- H5; auto. rewrite <- H5; auto. rewrite <- H3; auto. rewrite <- H5; auto. Qed. Lemma cocycliques_ordre_cycle2 : forall A B C D : PO, sont_cocycliques A B C D -> sont_cocycliques B C A D. unfold sont_cocycliques, circonscrit, isocele in |- *; intros. elim H; intros O H0; elim H0; intros H1 H2; elim H2; intros H3 H4; try clear H2 H0 H; try exact H3. elim H1; intros H H0; try clear H1; try exact H0. exists O. split; [ split; auto | idtac ]. rewrite <- H3; auto. split; [ idtac | try assumption ]. rewrite <- H; auto. rewrite <- H; auto. Qed. Lemma cocycliques_ordre_permute : forall A B C D : PO, sont_cocycliques A B C D -> sont_cocycliques A C B D. unfold sont_cocycliques, circonscrit, isocele in |- *; intros. elim H; intros O; intros. elim H0; intros. exists O. elim H1; intros. elim H2; intros; clear H H0 H1 H2. split; [ idtac | split; try assumption ]. split; try assumption. Qed. Hint Resolve cocycliques_ordre_cycle cocycliques_ordre_cycle2 cocycliques_ordre_permute: geo. Lemma circonscrit_trans : forall O A B C D : PO, circonscrit O A B C -> circonscrit O A B D -> circonscrit O A C D. unfold circonscrit, isocele in |- *; intros. elim H0; clear H0; intros. elim H; clear H; intros. split; auto. Qed. Lemma cocyclicite2 : forall A B C D : PO, D <> C -> triangle A B C -> triangle A B D -> sont_cocycliques A B C D -> double_AV (cons_AV (vec B C) (vec B A)) = double_AV (cons_AV (vec D C) (vec D A)) :>AV. intros. deroule_triangle A B C. deroule_triangle A B D. elim H2. intros O; intros. elim H11; intros. deroule_circonscrit A B D O. deroule_circonscrit A B C O. rewrite (angle_inscrit (O:=O) (A:=B) (B:=C) (C:=A)); auto. rewrite (angle_inscrit (O:=O) (A:=D) (B:=C) (C:=A)); auto. apply circonscrit_permute; apply circonscrit_permute. apply circonscrit_trans with B; auto. apply circonscrit_permute; apply circonscrit_permute; auto. Qed. Lemma cocyclicite3 : forall A B C D : PO, D <> C -> triangle A B C -> triangle A B D -> sont_cocycliques A B C D -> double_AV (cons_AV (vec B D) (vec B A)) = double_AV (cons_AV (vec C D) (vec C A)) :>AV. intros. deroule_triangle A B C. deroule_triangle A B D. elim H2. intros O; intros. elim H11; intros. deroule_circonscrit A B D O. deroule_circonscrit A B C O. rewrite (angle_inscrit (O:=O) (A:=B) (B:=D) (C:=A)); auto. rewrite (angle_inscrit (O:=O) (A:=C) (B:=D) (C:=A)); auto. apply circonscrit_permute; apply circonscrit_permute. apply circonscrit_trans with B; auto. apply circonscrit_permute; apply circonscrit_permute; auto. Qed. Lemma circonscrit_ordre_permute : forall O A B C : PO, circonscrit O A B C -> circonscrit O B A C. unfold circonscrit, isocele in |- *; intros. elim H; clear H; intros. split; auto. rewrite <- H; auto. Qed. Lemma cocyclicite4 : forall A B C D : PO, D <> C -> triangle A B C -> triangle A B D -> sont_cocycliques A B C D -> double_AV (cons_AV (vec A B) (vec A C)) = double_AV (cons_AV (vec D B) (vec D C)) :>AV. intros. deroule_triangle A B C. deroule_triangle A B D. elim H2. intros O; intros. elim H11; intros. deroule_circonscrit A B D O. deroule_circonscrit A B C O. rewrite (angle_inscrit (O:=O) (A:=A) (B:=B) (C:=C)); auto. rewrite (angle_inscrit (O:=O) (A:=D) (B:=B) (C:=C)); auto. apply circonscrit_permute. apply circonscrit_trans with A; auto. apply circonscrit_ordre_permute; auto. apply circonscrit_ordre_permute; auto. Qed. Lemma cocyclicite5 : forall A B C D : PO, D <> C -> triangle A B C -> triangle A B D -> sont_cocycliques A B C D -> double_AV (cons_AV (vec A B) (vec A D)) = double_AV (cons_AV (vec C B) (vec C D)) :>AV. intros. deroule_triangle A B C. deroule_triangle A B D. elim H2. intros O; intros. elim H11; intros. deroule_circonscrit A B D O. deroule_circonscrit A B C O. rewrite (angle_inscrit (O:=O) (A:=A) (B:=B) (C:=D)); auto. rewrite (angle_inscrit (O:=O) (A:=C) (B:=B) (C:=D)); auto. apply circonscrit_permute. apply circonscrit_trans with A; auto. apply circonscrit_ordre_permute; auto. apply circonscrit_ordre_permute; auto. Qed. Lemma cocyclicite6 : forall A B C D : PO, triangle A B C -> triangle A B D -> sont_cocycliques A B C D -> double_AV (cons_AV (vec A C) (vec A D)) = double_AV (cons_AV (vec B C) (vec B D)) :>AV. intros. deroule_triangle A B C. deroule_triangle A B D. elim H1. intros O; intros. elim H10; intros. deroule_circonscrit A B D O. deroule_circonscrit A B C O. rewrite (angle_inscrit (O:=O) (A:=A) (B:=C) (C:=D)); auto. rewrite (angle_inscrit (O:=O) (A:=B) (B:=C) (C:=D)); auto. apply circonscrit_trans with A; auto. apply circonscrit_ordre_permute; auto. apply circonscrit_ordre_permute; auto. apply circonscrit_trans with B; auto. Qed. Lemma centre_circonscrit_rectangle_milieu : forall A B C C' O : PO, triangle A B C -> C' = milieu A B -> circonscrit O A B C -> orthogonal (vec C A) (vec C B) -> O = C'. intros. deroule_triangle A B C. deroule_circonscrit A B C O. rewrite H0. cut (cons_AV (vec O A) (vec O B) = image_angle pi); intros. cut (alignes O A B); intros. apply alignes_mediatrice_milieu; auto with geo. unfold mediatrice in |- *. elim H1; auto. apply alignes_angle; auto. unfold double_AV in |- *. rewrite H10. repeat rewrite <- add_mes_compatible. replace (pi + pi) with deuxpi; auto. rewrite pi_plus_pi; auto. rewrite <- (angle_inscrit (O:=O) (A:=C) (B:=A) (C:=B)); auto. apply orthogonal_angles; auto. apply circonscrit_permute; auto. Qed. Lemma orthogonal_diametre_cercle : forall A B C A' O D : PO, triangle A B C -> circonscrit O A B C -> O = milieu A A' -> orthogonal (vec D A) (vec D A') -> sont_cocycliques A B C D. intros. discrimine D A. discrimine D A'. generalize H0; unfold sont_cocycliques, circonscrit, isocele in |- *; intros. exists O. split; [ try assumption | idtac ]. elim H5; intros H6 H7; try clear H5; try exact H6. split; [ try assumption | idtac ]. apply milieu_distance; auto. cut (circonscrit O A A' D); intros. generalize H0; generalize H5. unfold sont_cocycliques, circonscrit, isocele in |- *; intros. exists O. split; [ try assumption | idtac ]. elim H7; intros H8 H9; try clear H7; try exact H9. elim H6; intros H7 H10; try clear H6; try exact H10. split; auto. cut (triangle D A A'); intros. elim existence_cercle_circonscrit with (A := A) (B := A') (C := D); [ intros I H7 | auto with geo ]. cut (I = O); intros. rewrite <- H6; auto with geo. generalize (centre_circonscrit_rectangle_milieu (A:=A) (B:=A') (C:=D)); intros H8; apply H8; auto with geo. unfold triangle in |- *. apply orthogonal_non_alignes; auto. Qed. Theorem Miquel : forall A B C D E F M : PO, A <> C -> A <> F -> B <> E -> B <> C -> alignes A D F -> alignes A E C -> alignes B D E -> alignes B F C -> triangle A E D -> triangle A E M -> triangle B D M -> triangle B F M -> sont_cocycliques A C F M -> sont_cocycliques A E D M -> sont_cocycliques E C B M /\ sont_cocycliques D F B M. intros. deroule_triangle A E D. deroule_triangle A E M. deroule_triangle B D M. deroule_triangle B F M. cut (triangle A C M); intros. cut (triangle A C F); intros. cut (triangle B E M); intros. cut (triangle B C M); intros. deroule_triangle A C M. deroule_triangle A C F. deroule_triangle B E M. deroule_triangle B C M. split; [ try assumption | idtac ]. apply cocycliques_ordre_cycle; apply cocycliques_ordre_cycle. apply reciproque_cocyclicite; auto with geo. replace (double_AV (cons_AV (vec E B) (vec E M))) with (double_AV (cons_AV (vec E D) (vec E M))). replace (double_AV (cons_AV (vec E D) (vec E M))) with (double_AV (cons_AV (vec A D) (vec A M))). replace (double_AV (cons_AV (vec A D) (vec A M))) with (double_AV (cons_AV (vec A F) (vec A M))). replace (double_AV (cons_AV (vec C B) (vec C M))) with (double_AV (cons_AV (vec C F) (vec C M))). apply cocyclicite6; auto with geo. apply alignement_et_angles; auto with geo. apply alignement_et_angles; auto with geo. apply cocyclicite6; auto with geo. apply alignement_et_angles; auto with geo. apply cocycliques_ordre_cycle; apply cocycliques_ordre_cycle. apply reciproque_cocyclicite; auto with geo. replace (double_AV (cons_AV (vec D B) (vec D M))) with (double_AV (cons_AV (vec D E) (vec D M))). replace (double_AV (cons_AV (vec D E) (vec D M))) with (double_AV (cons_AV (vec A E) (vec A M))). replace (double_AV (cons_AV (vec A E) (vec A M))) with (double_AV (cons_AV (vec A C) (vec A M))). replace (double_AV (cons_AV (vec F B) (vec F M))) with (double_AV (cons_AV (vec F C) (vec F M))). apply cocyclicite5; auto with geo. apply alignement_et_angles; auto with geo. apply alignement_et_angles; auto with geo. apply cocyclicite5; auto with geo. apply alignement_et_angles; auto with geo. apply alignement_triangle with (3 := H10); auto with geo. apply alignement_triangle with (3 := H9); auto with geo. apply alignement_triangle with (3 := H7); auto with geo. apply alignement_triangle with (3 := H8); auto with geo. Qed. Lemma triangles_meme_hypotenuse : forall A B C D : PO, A <> B -> B <> C -> A <> D -> C <> D -> orthogonal (vec C A) (vec C B) -> orthogonal (vec D A) (vec D B) -> double_AV (cons_AV (vec B C) (vec B A)) = double_AV (cons_AV (vec D C) (vec D A)) :>AV. intros. discrimine A C. rewrite <- angle_nul; auto. rewrite <- angle_nul; auto. discrimine B D. generalize (orthogonal_non_alignes (A:=C) (B:=A) (C:=B)); intros. generalize (orthogonal_non_alignes (A:=D) (B:=A) (C:=B)); intros. lapply (orthogonal_angles (A:=C) (B:=A) (C:=C) (D:=B)); auto; intros. lapply (orthogonal_angles (A:=D) (B:=A) (C:=D) (D:=B)); auto; intros. cut (triangle A B C); intros. cut (triangle A B D); intros. apply cocyclicite2; auto. apply reciproque_cocyclicite; auto. rewrite H9; auto; rewrite H10; auto. apply triangle_ordre_cycle; unfold triangle in |- *; auto. apply triangle_ordre_cycle; unfold triangle in |- *; auto. Qed. Lemma triangle_ortho_cote : forall A B C M P Q R : PO, triangle A B C -> P = projete_orthogonal B C M -> Q = projete_orthogonal A C M -> ~ alignes A C M -> ~ alignes B C M -> ~ alignes M P Q. intros. deroule_triangle A B C. elim (def_projete_orthogonal2 (A:=B) (B:=C) (C:=M) (H:=P)); auto; intros. elim (def_projete_orthogonal2 (A:=A) (B:=C) (C:=M) (H:=Q)); auto; intros. lapply (projete_non_axe (A:=B) (B:=C) (M:=M) (H:=P)); auto; intros. lapply (projete_non_axe (A:=A) (B:=C) (M:=M) (H:=Q)); auto; intros. apply angle_non_alignes; auto. replace (double_AV (cons_AV (vec M P) (vec M Q))) with (double_AV (cons_AV (vec C B) (vec C A))). apply non_alignes_angle; auto with geo. rewrite (angles_droites_orthogonales (A:=C) (B:=B) (C:=C) (D:=A) (E:=M) (F:=P) (G:=M) (I:=Q)); auto with geo. Qed. Lemma triangle_ortho_cote2 : forall A B C M P Q : PO, triangle A B C -> P = projete_orthogonal B C M -> Q = projete_orthogonal A B M -> ~ alignes A B M -> ~ alignes B C M -> ~ alignes M P Q. intros. deroule_triangle A B C. elim (def_projete_orthogonal2 (A:=B) (B:=C) (C:=M) (H:=P)); auto; intros. elim (def_projete_orthogonal2 (A:=A) (B:=B) (C:=M) (H:=Q)); auto; intros. lapply (projete_non_axe (A:=B) (B:=C) (M:=M) (H:=P)); auto; intros. lapply (projete_non_axe (A:=A) (B:=B) (M:=M) (H:=Q)); auto; intros. apply angle_non_alignes; auto. replace (double_AV (cons_AV (vec M P) (vec M Q))) with (double_AV (cons_AV (vec B C) (vec B A))). apply non_alignes_angle; auto with geo. rewrite (angles_droites_orthogonales (A:=B) (B:=C) (C:=B) (D:=A) (E:=M) (F:=P) (G:=M) (I:=Q)); auto with geo. Qed. Lemma projete_ortho_cote : forall A B C M P Q R : PO, triangle A B C -> triangle B C M -> triangle A B M -> triangle A C M -> P = projete_orthogonal B C M -> Q = projete_orthogonal A C M -> R = projete_orthogonal A B M -> double_AV (cons_AV (vec P Q) (vec P R)) = plus (double_AV (cons_AV (vec C A) (vec C M))) (double_AV (cons_AV (vec B M) (vec B A))) :>AV. intros. deroule_triangle A B C. deroule_triangle B C M. cut (M <> P); intros. elim (def_projete_orthogonal2 (A:=B) (B:=C) (C:=M) (H:=P)); auto; intros. elim (def_projete_orthogonal2 (A:=A) (B:=C) (C:=M) (H:=Q)); auto; intros. elim (def_projete_orthogonal2 (A:=A) (B:=B) (C:=M) (H:=R)); auto; intros. cut (P <> R); intros. cut (P <> Q); intros. replace (double_AV (cons_AV (vec P Q) (vec P R))) with (plus (double_AV (cons_AV (vec P Q) (vec P M))) (double_AV (cons_AV (vec P M) (vec P R)))). replace (double_AV (cons_AV (vec P Q) (vec P M))) with (double_AV (cons_AV (vec C A) (vec C M))). replace (double_AV (cons_AV (vec P M) (vec P R))) with (double_AV (cons_AV (vec B M) (vec B A))); auto. discrimine R B. rewrite (orthogonal_angles (A:=P) (B:=M) (C:=P) (D:=B)); auto. pattern B at 1 in |- *. rewrite <- H23. apply orthogonal_angles; auto with geo. red in |- *; intros; apply H10; rewrite <- H23; auto with geo. red in |- *; intros; apply H21; rewrite H23; auto with geo. apply orthogonal_alignement2 with C; auto with geo. replace (double_AV (cons_AV (vec B M) (vec B A))) with (double_AV (cons_AV (vec B M) (vec B R))). rewrite <- (def_opp (A:=P) (B:=R) (C:=P) (D:=M)); auto. rewrite double_opp; auto. rewrite <- (triangles_meme_hypotenuse (A:=M) (B:=B) (C:=R) (D:=P)); auto. rewrite <- double_opp; auto. rewrite def_opp; auto. apply orthogonal_alignement with A; auto. apply orthogonal_alignement2 with C; auto. apply alignement_et_angles; auto with geo. discrimine Q C. rewrite (orthogonal_angles (A:=P) (B:=C) (C:=P) (D:=M)); auto. pattern C at 2 in |- *. rewrite <- H23. apply orthogonal_angles; auto with geo. red in |- *; intros; apply H10; rewrite <- H23; auto with geo. red in |- *; intros; apply H22; rewrite H23; auto. apply ortho_sym. apply orthogonal_alignement with B; auto. replace (double_AV (cons_AV (vec C A) (vec C M))) with (double_AV (cons_AV (vec C Q) (vec C M))). rewrite <- (triangles_meme_hypotenuse (A:=M) (B:=C) (C:=Q) (D:=P)); auto. apply orthogonal_alignement with A; auto. apply orthogonal_alignement with B; auto. apply alignement_et_angles; auto with geo. rewrite double_Chasles; auto. apply non_alignes_distincts2 with M. deroule_triangle A C M. apply (triangle_ortho_cote (A:=A) (B:=B) (C:=C) (M:=M) (P:=P) (Q:=Q)); auto. apply non_alignes_distincts2 with M. deroule_triangle A B M. apply (triangle_ortho_cote2 (A:=A) (B:=B) (C:=C) (M:=M) (P:=P) (Q:=R)); auto. apply projete_non_axe with (2 := H3); auto. Qed. Theorem droite_Simson : forall A B C M P Q R : PO, triangle A B C -> triangle B C M -> triangle A B M -> triangle A C M -> P = projete_orthogonal B C M -> Q = projete_orthogonal A C M -> R = projete_orthogonal A B M -> (sont_cocycliques A B C M <-> alignes P Q R). unfold iff in |- *; intros. lapply (projete_ortho_cote (A:=A) (B:=B) (C:=C) (M:=M) (P:=P) (Q:=Q) (R:=R)); auto; intros. deroule_triangle A B C. deroule_triangle B C M. cut (M <> P); intros. elim (def_projete_orthogonal2 (A:=B) (B:=C) (C:=M) (H:=P)); auto; intros. elim (def_projete_orthogonal2 (A:=A) (B:=C) (C:=M) (H:=Q)); auto; intros. elim (def_projete_orthogonal2 (A:=A) (B:=B) (C:=M) (H:=R)); auto; intros. cut (P <> R); intros. cut (P <> Q); intros. split; intros. apply alignes_angle; auto. rewrite H6; auto. cut (double_AV (cons_AV (vec C A) (vec C M)) = double_AV (cons_AV (vec B A) (vec B M))); intros. rewrite H25; auto. rewrite double_Chasles; auto. unfold double_AV in |- *. rewrite Chasles; auto. rewrite <- angle_nul; auto. lapply (cocyclicite3 (A:=A) (B:=B) (C:=C) (D:=M)); auto; intros. rewrite <- def_opp; auto. rewrite <- (def_opp (A:=B) (B:=M) (C:=B) (D:=A)); auto. rewrite double_opp; auto. rewrite double_opp; auto. rewrite H25; auto. lapply (angle_alignes (A:=P) (B:=Q) (C:=R)); auto; intros. cut (sont_cocycliques A M C B); intros. generalize H26; unfold sont_cocycliques, circonscrit, isocele in |- *; intros. elim H27; intros. elim H28; intros. elim H30; intros. elim H29; intros. exists x; auto. apply reciproque_cocyclicite; auto with geo. replace (double_AV (cons_AV (vec C A) (vec C M))) with (plus (double_AV (cons_AV (vec P Q) (vec P R))) (opp (double_AV (cons_AV (vec B M) (vec B A))))). replace (opp (double_AV (cons_AV (vec B M) (vec B A)))) with (double_AV (cons_AV (vec B A) (vec B M))). rewrite H25; auto. rewrite zero_plus_double; auto. rewrite <- double_opp; auto. rewrite def_opp; auto. rewrite H6; auto. replace (opp (double_AV (cons_AV (vec B M) (vec B A)))) with (double_AV (cons_AV (vec B A) (vec B M))). replace (plus (plus (double_AV (cons_AV (vec C A) (vec C M))) (double_AV (cons_AV (vec B M) (vec B A)))) (double_AV (cons_AV (vec B A) (vec B M)))) with (plus (double_AV (cons_AV (vec C A) (vec C M))) (plus (double_AV (cons_AV (vec B M) (vec B A))) (double_AV (cons_AV (vec B A) (vec B M))))). rewrite double_Chasles; auto. rewrite <- angle_nul; auto. rewrite (angle_nul (A:=C) (B:=M)); auto. rewrite double_Chasles; auto. unfold double_AV in |- *. mesure C A C M. mesure B M B A. mesure B A B M. replace (x + x + (x0 + x0 + (x1 + x1))) with (x + x + (x0 + x0) + (x1 + x1)); auto. ring. rewrite <- double_opp; auto. rewrite def_opp; auto. apply non_alignes_distincts2 with M. deroule_triangle A C M. apply (triangle_ortho_cote (A:=A) (B:=B) (C:=C) (M:=M) (P:=P) (Q:=Q)); auto. apply non_alignes_distincts2 with M. deroule_triangle A B M. apply (triangle_ortho_cote2 (A:=A) (B:=B) (C:=C) (M:=M) (P:=P) (Q:=R)); auto. apply projete_non_axe with (2 := H3); auto. Qed. Require Export orthocentre. Require Export reflexion_plane. Lemma orthocentre_double : forall A B C H : PO, H <> B :>PO -> H <> C :>PO -> triangle A B C -> H = orthocentre A B C :>PO -> double_AV (cons_AV (vec H C) (vec H B)) = double_AV (cons_AV (vec A B) (vec A C)) :>AV. intros. elim orthocentre_def2 with (A := A) (B := B) (C := C) (H := H); [ intros | auto ]. elim H4; intros H6 H7; try clear H4; try exact H7. deroule_triangle A B C. apply angles_droites_orthogonales; auto with geo. Qed. Theorem symetrique_orthocentre : forall A B C H H' : PO, triangle A B C -> triangle B C H -> H = orthocentre A B C :>PO -> H' = reflexion B C H :>PO -> sont_cocycliques A B C H'. intros. deroule_triangle A B C. deroule_triangle B C H. lapply (orthocentre_double (A:=A) (B:=B) (C:=C) (H:=H)); intros. apply cocycliques_ordre_cycle; apply cocycliques_ordre_cycle; apply cocycliques_ordre_cycle. apply reciproque_cocyclicite; auto with geo. unfold triangle in |- *. apply non_axe_image_non_axe with H; auto. rewrite <- H12; auto. unfold double_AV in |- *. rewrite (reflexion_inverse_angle (A:=B) (B:=C) (M:=H) (M':=H')); auto. rewrite def_opp; auto. auto. Qed.HighSchoolGeometry/barycentre.v0000644000076500007650000004367112117747636016577 0ustar coqcoq00000000000000(* This program is free software; you can redistribute it and/or *) (* modify it under the terms of the GNU Lesser General Public License *) (* as published by the Free Software Foundation; either version 2.1 *) (* of the License, or (at your option) any later version. *) (* *) (* This program is distributed in the hope that it will be useful, *) (* but WITHOUT ANY WARRANTY; without even the implied warranty of *) (* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *) (* GNU General Public License for more details. *) (* *) (* You should have received a copy of the GNU Lesser General Public *) (* License along with this program; if not, write to the Free *) (* Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA *) (* 02110-1301 USA *) Require Export alignement. Set Implicit Arguments. Unset Strict Implicit. Parameter barycentre : PP -> PP -> PO. Axiom add_PP_barycentre : forall (a b : R) (A B : PO), a + b <> 0 -> add_PP (cons a A) (cons b B) = cons (a + b) (barycentre (cons a A) (cons b B)). Lemma permute_barycentre : forall (a b : R) (A B : PO), a + b <> 0 -> barycentre (cons a A) (cons b B) = barycentre (cons b B) (cons a A). intros a b A B H; try assumption. apply conversion_PP with (a := a + b) (b := b + a); try ring; auto. repeat rewrite <- add_PP_barycentre; auto. RingPP. unfold not in |- *; intros H1; apply H; auto; rewrite <- H1; ring; auto. Qed. Lemma barycentre_zero : forall (a : R) (A B : PO), a <> 0 -> barycentre (cons a A) (cons 0 B) = A. intros a A B H; try assumption. apply conversion_PP with (a := a + 0) (b := a); try ring; auto. repeat rewrite <- add_PP_barycentre; auto. RingPP. unfold not in |- *; intros H1; apply H; auto; rewrite <- H1; ring; auto. replace (a + 0) with a; try ring; auto. Qed. Lemma bary_assoc : forall (a b c : R) (A B C : PO), a + b <> 0 -> b + c <> 0 -> a + (b + c) <> 0 -> barycentre (cons a A) (cons (b + c) (barycentre (cons b B) (cons c C))) = barycentre (cons (a + b) (barycentre (cons a A) (cons b B))) (cons c C). intros a b c A B C H H0 H1; try assumption. apply conversion_PP with (a := a + (b + c)) (b := a + b + c); try ring; auto. repeat rewrite <- add_PP_barycentre; auto. Ringvec. unfold not in |- *; intros H2; apply H1; auto; rewrite <- H2; ring; auto. Qed. Lemma homogene_barycentre : forall (a b k : R) (A B : PO), a + b <> 0 -> k <> 0 -> barycentre (cons (k * a) A) (cons (k * b) B) = barycentre (cons a A) (cons b B). intros a b k A B H H0; try assumption. apply conversion_PP with (a := k * a + k * b) (b := k * (a + b)); try ring; auto. repeat rewrite <- add_PP_barycentre; auto. rewrite distrib_mult_cons. rewrite <- def_mult_PP. repeat rewrite <- add_PP_barycentre; auto. replace (k * a + k * b) with (k * (a + b)); try ring. auto with *. replace (k * a + k * b) with (k * (a + b)); try ring. auto with *. Qed. Lemma def_vecteur_bary : forall (a b : R) (A B G : PO), a + b <> 0 -> G = barycentre (cons a A) (cons b B) -> add_PP (mult_PP a (vec G A)) (mult_PP b (vec G B)) = zero. intros. cut (zero = mult_PP (a + b) (vec G G)); intros; auto. rewrite H1. apply add_PP_vecteur; auto. rewrite (add_PP_barycentre (a:=a) (b:=b) A B); auto. rewrite <- H0; auto. Ringvec. Qed. Lemma def_vecteur_bary_rec : forall (a b : R) (A B G : PO), a + b <> 0 -> add_PP (mult_PP a (vec G A)) (mult_PP b (vec G B)) = zero -> G = barycentre (cons a A) (cons b B). unfold vec in |- *; intros. apply conversion_PP with (a := a + b) (b := a + b); auto. rewrite <- (add_PP_barycentre (a:=a) (b:=b) A B); auto. replace (cons (a + b) G) with (add_PP (cons (a + b) G) zero). rewrite <- H0. RingPP. RingPP. Qed. Lemma prop_vecteur_bary : forall (a b : R) (A B G M : PO), a + b <> 0 -> G = barycentre (cons a A) (cons b B) -> add_PP (mult_PP a (vec M A)) (mult_PP b (vec M B)) = mult_PP (a + b) (vec M G). intros. apply add_PP_vecteur; auto. rewrite (add_PP_barycentre (a:=a) (b:=b) A B); auto. rewrite <- H0; auto. Qed. Lemma prop_vecteur_bary_rec : forall (a b : R) (A B G M : PO), a + b <> 0 -> add_PP (mult_PP a (vec M A)) (mult_PP b (vec M B)) = mult_PP (a + b) (vec M G) -> G = barycentre (cons a A) (cons b B). unfold vec in |- *; intros. apply conversion_PP with (a := a + b) (b := a + b); auto. rewrite <- (add_PP_barycentre (a:=a) (b:=b) A B); auto. cut (add_PP (cons (- (a + b)) M) (cons (a + b) G) = add_PP (mult_PP a (add_PP (cons (-1) M) (cons 1 A))) (mult_PP b (add_PP (cons (-1) M) (cons 1 B)))); intros. RingPP2 H1. RingPP. rewrite H0. RingPP. Qed. Hint Resolve add_PP_barycentre: geo. Lemma barycentre_alignes : forall (a b : R) (A B : PO), a + b <> 0 -> alignes A B (barycentre (cons a A) (cons b B)). intros a b A B H; try assumption. apply add_PP_alignes with (a := a) (b := b); auto with geo. Qed. Lemma colineaire_barycentre : forall (k : R) (A B C : PO), vec A C = mult_PP k (vec A B) -> C = barycentre (cons (1 + - k) A) (cons k B). unfold vec in |- *; intros. elim cons_inj with (a := 1) (b := 1 + - k + k) (A := C) (B := barycentre (cons (1 + - k) A) (cons k B)); intros; auto with *. repeat rewrite <- add_PP_barycentre; auto. RingPP2 H. RingPP. replace (1 + - k + k) with 1; try ring; auto with *. Qed. Lemma alignes_barycentre : forall A B C : PO, A <> B -> alignes A B C -> exists k : R, C = barycentre (cons k A) (cons (1 + - k) B). unfold alignes, alignes1 in |- *; intros. elim H0; [ intros H1; tauto | intros H1; elim H1; [ intros k H2; try clear H1 H0; try exact H2 ] ]. exists k; auto. apply conversion_PP with (a := 1) (b := k + (1 + - k)); try ring; auto with *. rewrite H2; auto. repeat rewrite <- add_PP_barycentre; auto. replace (k + (1 + - k)) with 1; try ring; auto with *. Qed. Hint Resolve barycentre_alignes prop_vecteur_bary def_vecteur_bary_rec def_vecteur_bary homogene_barycentre barycentre_zero: geo. Lemma existence_representant_vecteur : forall A B C : PO, ex (fun D : PO => vec A D = vec B C :>PP). unfold vec in |- *; intros. exists (barycentre (cons (-1) B) (cons 2 (barycentre (cons 1 A) (cons 1 C)))). pattern 1 at 2 in |- *. RReplace 1 (-1 + 2). repeat rewrite <- add_PP_barycentre; auto. RingPP. discrR. discrR. Qed. Lemma existence_representant_mult_vecteur : forall (A B C : PO) (k : R), ex (fun D : PO => vec A D = mult_PP k (vec B C) :>PP). intros. elim (classic (k = -1)); intros. rewrite H. elim existence_representant_vecteur with (A := A) (B := C) (C := B); intros D H0; try clear existence_representant_vecteur; try exact H0. exists D. rewrite H0; Ringvec. unfold vec in |- *. exists (barycentre (cons (- k) B) (cons (1 + k) (barycentre (cons 1 A) (cons k C)))). pattern 1 at 2 in |- *. RReplace 1 (- k + (1 + k)). repeat rewrite <- add_PP_barycentre; auto. RingPP. unfold not in |- *; intros; apply H. RReplace k (1 + k + -1). rewrite H0. ring. RReplace (- k + (1 + k)) 1. auto with *. Qed. Lemma existence_representant_som_vecteur : forall A B C D : PO, ex (fun E : PO => vec A E = add_PP (vec A B) (vec C D) :>PP). intros. unfold vec in |- *. exists (barycentre (cons (-1) C) (cons 2 (barycentre (cons 1 B) (cons 1 D)))). pattern 1 at 2 in |- *. RReplace 1 (-1 + 2). repeat rewrite <- add_PP_barycentre; auto. RingPP. discrR. RReplace (-1 + 2) 1. discrR. Qed. Lemma existence_representant_comb_lin_vecteur : forall (A B C D : PO) (a b : R), ex (fun E : PO => vec A E = add_PP (mult_PP a (vec A B)) (mult_PP b (vec C D)) :>PP). intros. elim existence_representant_mult_vecteur with (A := A) (B := A) (C := B) (k := a); intros B' H; try clear existence_representant_mult_vecteur; rewrite <- H. elim existence_representant_mult_vecteur with (A := C) (B := C) (C := D) (k := b); intros C' H0; try clear existence_representant_mult_vecteur; rewrite <- H0. elim existence_representant_som_vecteur with (A := A) (B := B') (C := C) (D := C'); intros E H1; try clear existence_representant_som_vecteur; rewrite <- H1. exists E; auto. Qed. Lemma distinct_mult_vecteur : forall (A B C D : PO) (a : R), A <> B :>PO -> a <> 0 :>R -> vec C D = mult_PP a (vec A B) :>PP -> C <> D :>PO. intros. elim existence_representant_mult_vecteur with (A := A) (B := A) (C := B) (k := a); intros E H2; try clear existence_representant_mult_vecteur; try exact H2. cut (A <> E); intros. apply distinct_egalite_vecteur with (1 := H3); auto. rewrite H1; auto. apply distinct_produit_vecteur with (3 := H2); auto. Qed. Lemma unicite_coor_bar : forall (k k' : R) (A B I : PO), A <> B -> cons 1 I = add_PP (cons k A) (cons (1 + - k) B) -> cons 1 I = add_PP (cons k' A) (cons (1 + - k') B) -> k = k'. intros. elim produit_vecteur_nul with (a := k + - k') (A := A) (B := B); [ intros H2; try clear produit_vecteur_nul; try exact H2 | intros H2; try clear produit_vecteur_nul | try clear produit_vecteur_nul ]. RReplace k (k + - k' + k'). rewrite H2. ring. absurd (A = B); auto. VReplace (mult_PP (k + - k') (vec A B)) (add_PP (add_PP (cons k' A) (cons (1 + - k') B)) (add_PP (cons (- k) A) (cons (-1 + k) B))). rewrite <- H1. rewrite H0. RingPP. Qed. Lemma unicite_coef_bar : forall (x x0 : R) (A B : PO), A <> B -> 1 + x <> 0 -> 1 + x0 <> 0 -> barycentre (cons 1 A) (cons x B) = barycentre (cons 1 A) (cons x0 B) -> x = x0. intros. cut (barycentre (cons (/ (1 + x) * 1) A) (cons (/ (1 + x) * x) B) = barycentre (cons (/ (1 + x0) * 1) A) (cons (/ (1 + x0) * x0) B)); intros. cut (1 + x = 1 + x0); intros. RReplace x (-1 + (1 + x)). rewrite H4. ring. cut (/ (1 + x) = / (1 + x0)); intros. replace (1 + x) with (/ / (1 + x)). rewrite H4. auto with *. auto with *. replace (/ (1 + x)) with (/ (1 + x) * 1). replace (/ (1 + x0)) with (/ (1 + x0) * 1). apply (unicite_coor_bar (k:=/ (1 + x) * 1) (k':=/ (1 + x0) * 1) (A:=A) (B:=B) (I:=barycentre (cons (/ (1 + x) * 1) A) (cons (/ (1 + x) * x) B))); auto. pattern 1 at 1 in |- *. replace 1 with (/ (1 + x) * 1 + / (1 + x) * x). rewrite <- add_PP_barycentre; auto. replace (1 + - (/ (1 + x) * 1)) with (/ (1 + x) * x); auto. auto with *. pattern 1 at 2 in |- *. replace 1 with (/ (1 + x) * (1 + x)); auto. ring. auto with *. replace (/ (1 + x) * 1 + / (1 + x) * x) with 1; auto. auto with *. pattern 1 at 1 in |- *. replace 1 with (/ (1 + x) * (1 + x)); auto. ring. auto with *. replace (/ (1 + x) * 1 + / (1 + x) * x) with (/ (1 + x) * (1 + x)); auto. auto with *. auto with *. rewrite H3. pattern 1 at 1 in |- *. replace 1 with (/ (1 + x0) * 1 + / (1 + x0) * x0). rewrite <- add_PP_barycentre; auto. replace (1 + - (/ (1 + x0) * 1)) with (/ (1 + x0) * x0); auto. pattern 1 at 2 in |- *. replace 1 with (/ (1 + x0) * (1 + x0)); auto. ring. auto with *. replace (/ (1 + x0) * 1 + / (1 + x0) * x0) with 1; auto. auto with *. pattern 1 at 1 in |- *. replace 1 with (/ (1 + x0) * (1 + x0)); auto. ring. auto with *. replace (/ (1 + x0) * 1 + / (1 + x0) * x0) with (/ (1 + x0) * (1 + x0)); auto. auto with *. auto with *. auto with *. ring. rewrite homogene_barycentre. rewrite homogene_barycentre; auto. auto with *. try exact H0. auto with *. Qed. Lemma unicite_coor_bar_aux : forall (A B C I : PO) (x y x' y' : R), x <> x' :>R \/ y <> y' :>R -> cons 1 I = add_PP (add_PP (cons x A) (cons y B)) (cons (1 + - (x + y)) C) :>PP -> cons 1 I = add_PP (add_PP (cons x' A) (cons y' B)) (cons (1 + - (x' + y')) C) :>PP -> alignes A B C. intros. assert (vec C I = add_PP (mult_PP x (vec C A)) (mult_PP y (vec C B))). unfold vec in |- *. rewrite H0; Ringvec. assert (vec C I = add_PP (mult_PP x' (vec C A)) (mult_PP y' (vec C B))). unfold vec in |- *. rewrite H1; Ringvec. assert (add_PP (mult_PP (x + - x') (vec C A)) (mult_PP (y + - y') (vec C B)) = zero). VReplace zero (add_PP (vec C I) (mult_PP (-1) (vec C I))). pattern (vec C I) at 1 in |- *; rewrite H2; rewrite H3; Ringvec. assert (mult_PP (x + - x') (vec C A) = mult_PP (y' + - y) (vec C B)). VReplace (mult_PP (y' + - y) (vec C B)) (add_PP (mult_PP (y' + - y) (vec C B)) zero). rewrite <- H4; Ringvec. elim H; [ intros H6; try clear H; try exact H6 | intros H6; try clear H ]. assert (x + - x' <> 0). contrapose H6. RReplace x' (x' + 0). rewrite <- H; ring. assert (alignes C B A); auto with geo. apply colineaire_alignes with (/ (x + - x') * (y' + - y)). VReplace (mult_PP (/ (x + - x') * (y' + - y)) (vec C B)) (mult_PP (/ (x + - x')) (mult_PP (y' + - y) (vec C B))). rewrite <- H5; Fieldvec (x + - x'). assert (y' + - y <> 0). contrapose H6. RReplace y (y + 0). rewrite <- H; ring. assert (alignes C A B); auto with geo. apply colineaire_alignes with (/ (y' + - y) * (x + - x')). VReplace (mult_PP (/ (y' + - y) * (x + - x')) (vec C A)) (mult_PP (/ (y' + - y)) (mult_PP (x + - x') (vec C A))). rewrite H5; Fieldvec (y' + - y). Qed. Lemma unicite_coor_bar2 : forall (A B C I : PO) (x y x' y' : R), ~ alignes A B C -> cons 1 I = add_PP (add_PP (cons x A) (cons y B)) (cons (1 + - (x + y)) C) :>PP -> cons 1 I = add_PP (add_PP (cons x' A) (cons y' B)) (cons (1 + - (x' + y')) C) :>PP -> x = x' :>R /\ y = y' :>R. intros. assert (~ x <> x' /\ ~ y <> y'). apply not_or_and; auto. contrapose H. apply (unicite_coor_bar_aux (A:=A) (B:=B) (C:=C) (I:=I) (x:=x) (y:=y) (x':=x') (y':=y')); auto. elim H2; [ intros H3 H4; try clear H2; try exact H3 ]. split; (apply NNPP; auto). Qed. Lemma parallelogramme_non_concours : forall A B A1 B1 S : PO, ~ alignes A A1 B -> alignes A A1 S -> alignes B B1 S -> add_PP (cons 1 A) (cons (-1) A1) <> add_PP (cons 1 B) (cons (-1) B1). intros. contrapose H. assert (vec A1 A = vec B1 B). unfold vec in |- *. RingPP1 H2. RingPP. halignes H1 ipattern:k. assert (A1 = A); auto with geo. apply vecteur_nul_conf. rewrite H3; rewrite H1; Ringvec. halignes H0 ipattern:k0. apply colineaire_alignes with (k0 + - k). VReplace (vec A B) (add_PP (vec A S) (mult_PP (-1) (vec B S))). rewrite H5; rewrite H4. VReplace (vec B B1) (mult_PP (-1) (vec B1 B)). rewrite <- H3. Ringvec. Qed. Lemma concours_unique : forall A B A1 B1 I J : PO, ~ alignes A A1 B -> B1 <> B -> alignes A A1 I -> alignes B1 B I -> alignes A A1 J -> alignes B1 B J -> I = J. intros A B A1 B1 I J H. unfold alignes in |- *; intros H50 H0 H1 H2 H3. elim H3; clear H3; [ intros; tauto | unfold alignes1 in |- *; intros ]. elim H1; clear H1; [ intros; tauto | unfold alignes1 in |- *; intros ]. deroule_triangle A A1 B. elim H2; clear H2; [ intros; tauto | unfold alignes1 in |- *; intros ]. elim H0; clear H0 H5 H4; [ intros; tauto; clear H6 | unfold alignes1 in |- *; intros ]. elim H3; intros k0 H4; try clear H3; try exact H4. elim H2; intros k1 H3; try clear H2; try exact H3. elim H1; intros k2 H2; try clear H1; try exact H2. elim H0; intros k3 H1; try clear H0; try exact H1. elim (classic (k0 + - k2 = 0)); intros. cut (k0 = k2); intros. rewrite H5 in H4. apply conversion_PP with (a := 1) (b := 1); auto. rewrite H4; auto. auto with *. replace k0 with (k2 + (k0 + - k2)); auto. rewrite H0; ring. ring. cut (cons (k0 + - k2) B = add_PP (cons (k0 * k3 + - (k2 * k1)) A) (cons (k0 + - k2 + - (k0 * k3 + - (k2 * k1))) A1)); intros. assert (~ alignes1 A A1 B); auto with geo. absurd (ex (fun k0 : R => cons 1 B = add_PP (cons k0 A) (cons (1 + - k0) A1))); auto. exists (/ (k0 + - k2) * (k0 * k3 + - (k2 * k1))). apply mult_PP_regulier with (k0 + - k2); auto. pattern 1 at 2 in |- *. replace 1 with ((k0 + - k2) * / (k0 + - k2)); auto. rewrite <- distrib_mult_cons. rewrite def_mult_PP. replace ((k0 + - k2) * (/ (k0 + - k2) * (k0 * k3 + - (k2 * k1)))) with (k0 * k3 + - (k2 * k1)); auto. replace ((k0 + - k2) * 1) with (k0 + - k2); auto. replace ((k0 + - k2) * / (k0 + - k2) + - (/ (k0 + - k2) * (k0 * k3 + - (k2 * k1)))) with (/ (k0 + - k2) * (k0 + - k2 + - (k0 * k3 + - (k2 * k1)))); auto. replace ((k0 + - k2) * (/ (k0 + - k2) * (k0 + - k2 + - (k0 * k3 + - (k2 * k1))))) with (1 * (k0 + - k2 + - (k0 * k3 + - (k2 * k1)))); auto. rewrite H5. RingPP. replace 1 with ((k0 + - k2) * / (k0 + - k2)); auto. ring. auto with *. ring. ring. replace ((k0 + - k2) * (/ (k0 + - k2) * (k0 * k3 + - (k2 * k1)))) with ((k0 + - k2) * / (k0 + - k2) * (k0 * k3 + - (k2 * k1))). replace ((k0 + - k2) * / (k0 + - k2)) with 1. ring. auto with *. ring. auto with *. cut (add_PP (cons (k0 * k2) B1) (cons (k0 * (1 + - k2)) B) = add_PP (cons (k0 * k3) A) (cons (k0 * (1 + - k3)) A1)); intros. cut (add_PP (cons (k2 * k0) B1) (cons (k2 * (1 + - k0)) B) = add_PP (cons (k2 * k1) A) (cons (k2 * (1 + - k1)) A1)); intros. replace (cons (k0 + - k2) B) with (add_PP (cons (k0 * (1 + - k2)) B) (cons (- (k2 * (1 + - k0))) B)). replace (cons (k0 * k3 + - (k2 * k1)) A) with (add_PP (cons (k0 * k3) A) (cons (- (k2 * k1)) A)). replace (cons (k0 + - k2 + - (k0 * k3 + - (k2 * k1))) A1) with (add_PP (cons (k0 * (1 + - k3)) A1) (cons (- (k2 * (1 + - k1))) A1)). RingPP2 H5. cut (add_PP (cons (- (k2 * k0)) B1) (cons (- (k2 * (1 + - k0))) B) = add_PP (cons (- (k2 * k1)) A) (cons (- (k2 * (1 + - k1))) A1)); intros. RingPP2 H8. RingPP. replace (add_PP (cons (- (k2 * k0)) B1) (cons (- (k2 * (1 + - k0))) B)) with (mult_PP (-1) (add_PP (cons (k2 * k0) B1) (cons (k2 * (1 + - k0)) B))). rewrite H7. RingPP. RingPP. RingPP. RingPP. RingPP. rewrite distrib_mult_cons. rewrite distrib_mult_cons. rewrite <- H4. rewrite H3; auto. rewrite distrib_mult_cons. rewrite distrib_mult_cons. rewrite <- H2. rewrite H1; auto. Qed. Lemma couple_colineaires_parallelogramme : forall (A B C D : PO) (k k' : R), A <> B -> ~ alignes A B C -> vec C D = mult_PP k (vec A B) -> vec B D = mult_PP k' (vec A C) -> vec B D = vec A C. unfold vec in |- *; intros. cut (cons 1 D = add_PP (add_PP (cons (- k') A) (cons 1 B)) (cons (1 + - (- k' + 1)) C)); intros. cut (cons 1 D = add_PP (add_PP (cons (- k) A) (cons k B)) (cons (1 + - (- k + k)) C)); intros. cut (k = k' /\ k = 1); intros. elim H5; intros H6 H7; try clear H5; try exact H7. rewrite <- H6 in H2; rewrite H7 in H2. rewrite H2; Ringvec. cut (- k = - k' /\ k = 1); intros. elim H5; intros H6 H7; try clear H5; try exact H7. split; [ idtac | try assumption ]. replace k with (- - k). rewrite H6; ring. ring. apply (unicite_coor_bar2 (A:=A) (B:=B) (C:=C) (I:=D)); auto. RingPP2 H1. RingPP. RingPP2 H2. RingPP. Qed.HighSchoolGeometry/cercle.v0000644000076500007650000001724612073525613015663 0ustar coqcoq00000000000000(* This program is free software; you can redistribute it and/or *) (* modify it under the terms of the GNU Lesser General Public License *) (* as published by the Free Software Foundation; either version 2.1 *) (* of the License, or (at your option) any later version. *) (* *) (* This program is distributed in the hope that it will be useful, *) (* but WITHOUT ANY WARRANTY; without even the implied warranty of *) (* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *) (* GNU General Public License for more details. *) (* *) (* You should have received a copy of the GNU Lesser General Public *) (* License along with this program; if not, write to the Free *) (* Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA *) (* 02110-1301 USA *) Require Export isocele. Set Implicit Arguments. Unset Strict Implicit. Definition cercle (O : PO) (r : R) (M : PO) : Prop := distance O M = r. Lemma cercle_isocele : forall (O A B : PO) (r : R), cercle O r A -> cercle O r B -> isocele O A B. unfold cercle, isocele in |- *; intros. rewrite H; rewrite H0; auto. Qed. Lemma existence_rayon : forall O A : PO, cercle O (distance O A) A. unfold cercle in |- *; intros; auto. Qed. Lemma isocele_cercle : forall O A B : PO, isocele O A B -> cercle O (distance O A) B. unfold cercle, isocele in |- *; intros; auto. Qed. Definition circonscrit (O A B C : PO) : Prop := isocele O A B /\ isocele O A C. Lemma circonscrit_isocele : forall O A B C : PO, circonscrit O A B C -> isocele O B C. unfold circonscrit, isocele in |- *; intros; auto. elim H; intros; auto. rewrite <- H0; rewrite <- H1; auto. Qed. Lemma circonscrit_permute : forall O A B C : PO, circonscrit O B C A -> circonscrit O A B C. unfold circonscrit in |- *; intros. elim H; intros; split; auto with geo. lapply (circonscrit_isocele (O:=O) (A:=B) (B:=C) (C:=A)); auto with geo. Qed. Lemma circonscrit_distinct1 : forall O A B C : PO, O <> A -> circonscrit O A B C -> O <> B. unfold circonscrit, isocele in |- *; intros. elim H0; [ intros H1 H2; try clear H0; try exact H2 ]. apply isometrie_distinct with (2 := H1); auto. Qed. Lemma circonscrit_distinct2 : forall O A B C : PO, O <> A -> circonscrit O A B C -> O <> C. unfold circonscrit, isocele in |- *; intros. elim H0; [ intros H1 H2; try clear H0; try exact H2 ]. apply isometrie_distinct with (2 := H2); auto. Qed. Lemma circonscrit_distinct3 : forall O A B C : PO, O <> B -> circonscrit O A B C -> O <> A. intros. assert (circonscrit O B C A). apply circonscrit_permute. apply circonscrit_permute; auto. apply circonscrit_distinct2 with (2 := H1); auto. Qed. Definition cercle_rayon (O A M : PO) := isocele O A M. Definition tangente_cercle (O A T M : PO) := cercle_rayon O A T /\ orthogonal (vec T M) (vec T O). Definition cercle_diametre (A B M : PO) := exists O : PO, circonscrit O A B M /\ O = milieu A B. Definition sont_cocycliques (A B C D : PO) := ex (fun O : PO => circonscrit O A B C /\ circonscrit O A B D). Ltac hcercle H := generalize H; unfold cercle_diametre, tangente_cercle, cercle_rayon, cercle, sont_cocycliques, circonscrit, isocele in |- *; intros; repeat applatit_and; try split; auto with geo. Ltac icercle := unfold cercle_diametre, tangente_cercle, cercle_rayon, cercle, sont_cocycliques, circonscrit, isocele in |- *; intros; repeat applatit_and; try split; auto with geo. Lemma cercle_diametre_permute : forall A B C : PO, cercle_diametre A B C -> cercle_diametre B A C. icercle. elim H; [ intros O H0; elim H0; [ intros H1 H2; elim H1; [ intros H3 H4; try clear H1 H0 H; try exact H4 ] ] ]. exists O; split; auto with geo. split; [ auto | idtac ]. rewrite <- H3; auto. Qed. Hint Immediate cercle_diametre_permute: geo. Lemma cercle_diametre_trivial : forall A B : PO, cercle_diametre A B A. icercle. discrimine A B. exists B; split; auto with geo. soit_milieu A B ipattern:M. exists M. split; auto. split; auto with geo. Qed. Lemma cercle_diametre_trivial2 : forall A B : PO, cercle_diametre A B B. icercle. discrimine A B. exists B; split; auto with geo. soit_milieu A B ipattern:M. exists M. split; auto. split; auto with geo. Qed. Hint Resolve cercle_diametre_trivial2 cercle_diametre_trivial: geo. Lemma circonscrit_diametre : forall A B C D O : PO, circonscrit O A B C -> O = milieu A D -> cercle_diametre A D B. icercle. exists O. split; [ split; [ auto with geo | try assumption ] | try assumption ]. Qed. Lemma cercle_trivial : forall A B C D O : PO, circonscrit O A B C -> O = milieu A D -> sont_cocycliques A B C D. icercle. exists O. split; [ split; [ try assumption | try assumption ] | try assumption ]. split; [ try assumption | auto with geo ]. Qed. Lemma cercle_diametre_degenere : forall A B M : PO, A = B -> cercle_diametre A B M -> A = M. intros A B M H; try assumption. rewrite H; icercle. elim H0; [ intros O' H1; elim H1; [ intros H2 H3; elim H2; [ intros H4 H5; try clear H2 H1 H0; try exact H5 ] ] ]. assert (O' = B). rewrite (milieu_trivial B); auto. rewrite <- H0. apply distance_refl1. rewrite <- H5; rewrite <- H0; auto with geo. Qed. Require Export dilatations. Lemma existence_rayon_diametre : forall A B O : PO, cercle_rayon O A B -> exists C : PO, cercle_diametre A C B. unfold cercle_rayon, isocele in |- *; intros. symetrique O A ipattern:M. exists M. icercle. exists O. auto with geo. Qed. Lemma existence_point_cercle : forall O A : PO, exists C, cercle_rayon O A C. Proof. intros. exists A. unfold cercle_rayon. unfold isocele. auto with geo. Qed. Lemma alignes_diametre : forall A B A' : PO, alignes A A' B -> cercle_diametre A A' B -> B = A \/ B = A'. unfold cercle_diametre in |- *; intros. elim H0; [ intros O H1; elim H1; [ intros H2 H3; try clear H1 H0; try exact H3 ] ]. hcercle H2. discrimine A A'. assert (O = A). rewrite H3; rewrite <- H0; rewrite <- milieu_trivial; auto. rewrite <- H0. right; try assumption. rewrite <- H5. symmetry in |- *. assert (distance O B = 0); auto with geo. rewrite <- H4; rewrite <- H5; auto with geo. halignes H ipattern:k. elim (classic (k = 0)); intros. left; symmetry in |- *. apply (produit_zero_conf H5); auto. discrimine O A. left; symmetry in |- *. assert (distance O B = 0); auto with geo. rewrite <- H4; rewrite <- H7; auto with geo. right; try assumption. assert (vec A B = mult_PP (2 * k) (vec A O)). rewrite H5. rewrite (milieu_vecteur_double H3); auto. Ringvec. assert (k = 1). assert (vec O B = mult_PP (1 + - (2 * k)) (vec O A)). VReplace (vec O B) (add_PP (vec A B) (vec O A)). rewrite H8; Ringvec. assert (Rsqr (1 + - (2 * k)) = 1). assert (Rsqr (distance O A) = Rsqr (1 + - (2 * k)) * Rsqr (distance O A)). pattern (distance O A) at 1 in |- *. rewrite H4. unfold Rsqr in |- *; repeat rewrite <- carre_scalaire_distance. rewrite H9. Simplscal. apply Rmult_eq_reg_l with (Rsqr (distance O A)). pattern (Rsqr (distance O A)) at 2 in |- *; rewrite H10 in |- *; ring. unfold Rsqr in |- *; apply Rmult_integral_contrapositive. split; auto with geo. assert (Rsqr (1 + - (2 * k)) + - Rsqr 1 = 0). rewrite H10; unfold Rsqr in |- *; ring. assert (2 * (1 + - k) * - (2 * k) = 0). RReplace (- (2 * k)) (1 + - (2 * k) + -1). RReplace (2 * (1 + - k)) (1 + - (2 * k) + 1). rewrite <- H11; unfold Rsqr in |- *; ring. assert (1 + - k = 0). apply Rmult_eq_reg_l with (- (2 * k)); auto with real. RReplace (- (2 * k) * 0) 0. apply Rmult_eq_reg_l with 2; auto with real. RReplace (2 * 0) 0. rewrite <- H12; ring. RReplace k (k + 0). rewrite <- H13; ring. apply egalite_vecteur_point with A. rewrite H5; rewrite H9; Ringvec. Qed. HighSchoolGeometry/cocyclicite.v0000644000076500007650000005264712073525613016724 0ustar coqcoq00000000000000(* This program is free software; you can redistribute it and/or *) (* modify it under the terms of the GNU Lesser General Public License *) (* as published by the Free Software Foundation; either version 2.1 *) (* of the License, or (at your option) any later version. *) (* *) (* This program is distributed in the hope that it will be useful, *) (* but WITHOUT ANY WARRANTY; without even the implied warranty of *) (* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *) (* GNU General Public License for more details. *) (* *) (* You should have received a copy of the GNU Lesser General Public *) (* License along with this program; if not, write to the Free *) (* Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA *) (* 02110-1301 USA *) Require Export cercle. Set Implicit Arguments. Unset Strict Implicit. Theorem angle_inscrit : forall O A B C : PO, A <> B -> A <> C -> O <> B -> circonscrit O A B C -> double_AV (cons_AV (vec A B) (vec A C)) = cons_AV (vec O B) (vec O C). unfold double_AV in |- *; intros O A B C H H0 H2 H4. cut (O <> A); intros. 2: apply circonscrit_distinct3 with (2 := H4); auto. cut (O <> C); intros. 2: apply circonscrit_distinct2 with (2 := H4); auto. generalize (circonscrit_isocele (O:=O) (A:=A) (B:=B) (C:=C)); intros. lapply (circonscrit_isocele (O:=O) (A:=A) (B:=B) (C:=C)); auto; intros. unfold circonscrit in H4. elim H4; clear H4; intros. replace (cons_AV (vec O B) (vec O C)) with (plus (cons_AV (vec O B) (vec O A)) (cons_AV (vec O A) (vec O C))). generalize (somme_triangle (A:=O) (B:=B) (C:=A)); intros. replace (cons_AV (vec O B) (vec O A)) with (plus (image_angle pi) (opp (plus (cons_AV (vec B A) (vec B O)) (cons_AV (vec A O) (vec A B))))). generalize (somme_triangle (A:=O) (B:=A) (C:=C)); intros. replace (cons_AV (vec O A) (vec O C)) with (plus (image_angle pi) (opp (plus (cons_AV (vec A C) (vec A O)) (cons_AV (vec C O) (vec C A))))). replace (opp (plus (cons_AV (vec B A) (vec B O)) (cons_AV (vec A O) (vec A B)))) with (plus (opp (cons_AV (vec B A) (vec B O))) (opp (cons_AV (vec A O) (vec A B)))). replace (opp (plus (cons_AV (vec A C) (vec A O)) (cons_AV (vec C O) (vec C A)))) with (plus (opp (cons_AV (vec A C) (vec A O))) (opp (cons_AV (vec C O) (vec C A)))). replace (cons_AV (vec A B) (vec A C)) with (plus (cons_AV (vec A B) (vec A O)) (cons_AV (vec A O) (vec A C))). rewrite def_opp; auto. rewrite def_opp; auto. rewrite def_opp; auto. rewrite def_opp; auto. generalize (isocele_angles_base (A:=O) (B:=A) (C:=B)); auto; intros. rewrite <- H10; auto. generalize (isocele_angles_base (A:=O) (B:=C) (C:=A)); auto with geo; intros. rewrite <- H11; auto with geo. mesure A B A O. mesure C A C O. replace (pi + (x + x) + (pi + (x0 + x0))) with (pi + pi + (x + x + (x0 + x0))). replace (pi + pi) with deuxpi; auto. symmetry in |- *. rewrite add_mes_compatible; rewrite pi_plus_pi; rewrite <- add_mes_compatible. replace (0 + (x + x + (x0 + x0))) with (x + x0 + (x + x0)); auto. ring. ring. rewrite Chasles; auto. rewrite <- opp_plus_plus_opp; auto. rewrite <- opp_plus_plus_opp; auto. rewrite <- H9; auto. rewrite opp_plus_plus_opp; auto. mesure A C A O. mesure C O C A. mesure O A O C. replace (x1 + (x + x0) + (- x + - x0)) with x1; auto. ring. rewrite <- H8; auto. rewrite opp_plus_plus_opp; auto. mesure B A B O. mesure A O A B. mesure O B O A. replace (x1 + (x + x0) + (- x + - x0)) with x1; auto. ring. rewrite Chasles; auto. Qed. Theorem angle_inscrit2 : forall O A B C : PO, A <> C -> B <> C -> O <> B -> circonscrit O A B C -> double_AV (cons_AV (vec C A) (vec C B)) = cons_AV (vec O A) (vec O B). intros O A B C H H0 H1 H2; try assumption. cut (O <> A); intros. 2: apply circonscrit_distinct3 with (2 := H2); auto. apply angle_inscrit; auto. hcercle H2. rewrite <- H6; auto. Qed. Lemma circonscrit_triangle_non_point : forall O A B C : PO, triangle A B C -> circonscrit O A B C -> O <> A /\ O <> B /\ O <> C. intros. cut (O <> A); intros. split; [ try assumption | idtac ]. split; [ try assumption | idtac ]. apply circonscrit_distinct1 with (2 := H0); auto. apply circonscrit_distinct2 with (2 := H0); auto. hcercle H0. deroule_triangle A B C. red in |- *; intros. apply H6. rewrite <- H7. assert (distance O B = 0); auto with geo. rewrite <- H2. rewrite <- H7; auto with geo. Qed. Theorem cocyclicite : forall A B C D : PO, triangle A B C -> triangle A B D -> sont_cocycliques A B C D -> double_AV (cons_AV (vec C A) (vec C B)) = double_AV (cons_AV (vec D A) (vec D B)). unfold sont_cocycliques in |- *; intros. deroule_triangle A B C. deroule_triangle A B D. elim H1; (clear H1; (intros O; intros)). elim H1; (clear H1; intros). lapply (circonscrit_triangle_non_point (O:=O) (A:=A) (B:=B) (C:=C)); auto; intros. lapply (circonscrit_triangle_non_point (O:=O) (A:=A) (B:=B) (C:=D)); auto; intros. elim H12; (clear H12; intros). elim H13; (clear H13; intros). elim H11; (clear H11; intros). elim H15; (clear H15; intros). lapply (angle_inscrit2 (O:=O) (A:=A) (B:=B) (C:=C)); auto; intros. lapply (angle_inscrit2 (O:=O) (A:=A) (B:=B) (C:=D)); auto; intros. rewrite H18; auto. try exact H1. try exact H10. Qed. Theorem existence_cercle_circonscrit : forall A B C : PO, triangle A B C -> ex (fun O : PO => circonscrit O A B C). intros. deroule_triangle A B C. soit_mediatrice A B ipattern:M ipattern:K. soit_mediatrice B C ipattern:J ipattern:L. lapply (mediatrices_triangle_concours (A:=A) (B:=B) (C:=C) (I:=M) (J:=J) (K:=K) (L:=L)); auto; intros. elim (def_concours2 (A:=M) (B:=K) (C:=J) (D:=L)); auto; intros. exists x. apply circonscrit_permute. unfold circonscrit in |- *. elim H19; clear H19; intros. split; apply mediatrice_isocele. discrimine J x. apply milieu_mediatrice; auto. apply orthogonale_segment_milieu_mediatrice with J; auto. apply ortho_sym; auto. apply paralleles_orthogonal with (A := J) (B := L); auto. apply alignes_paralleles; auto. apply mediatrice_orthogonale_segment; auto. apply milieu_mediatrice; auto. discrimine M x. apply mediatrice_permute. apply milieu_mediatrice; auto. apply mediatrice_permute. apply orthogonale_segment_milieu_mediatrice with M; auto. apply ortho_sym; auto. apply paralleles_orthogonal with (A := M) (B := K); auto. apply alignes_paralleles; auto. apply mediatrice_orthogonale_segment; auto. apply milieu_mediatrice; auto. Qed. Lemma existence_cercle_circonscrit_diametre : forall A B C : PO, triangle A B C -> exists O : PO, (exists D : PO, circonscrit O A B C /\ cercle_diametre A D C /\ sont_cocycliques A B C D). intros. elim existence_cercle_circonscrit with (A := A) (B := B) (C := C); [ unfold circonscrit, isocele in |- *; intros O H0; try exact H0 | auto ]. exists O. symetrique O A ipattern:D. exists D. split; [ try assumption | idtac ]. applatit_and. icercle. exists O. icercle. exists O. icercle. Qed. Lemma cocycliques_trivial : forall A B C : PO, triangle A B C -> sont_cocycliques A B C A. icercle. elim existence_cercle_circonscrit with (A := A) (B := B) (C := C); [ unfold sont_cocycliques, circonscrit, isocele in |- *; intros O H0; try exact H0 | auto ]. exists O. split; [ try assumption | idtac ]. split; [ idtac | auto ]. elim H0; intros H1 H2; try clear H0; try exact H1. Qed. Hint Resolve cocycliques_trivial: geo. (* soit_circonscrit construit le centre du cercle circonscrit du triangle ABC et ne marche que si on a (triangle A B C) dans les hypotheses*) Ltac soit_circonscrit A B C O := elim (existence_cercle_circonscrit (A:=A) (B:=B) (C:=C)); [ intros O; intros; generalize (circonscrit_triangle_non_point (O:=O) (A:=A) (B:=B) (C:=C)); intros toto; elim toto; clear toto; [ intros; applatit_and | auto | auto ] | auto ]. (* deroule_circonscrit ne marche que si on a (cisrconscrit O A B C) dans les hypothèses*) Ltac deroule_circonscrit A B C O := elim (circonscrit_triangle_non_point (O:=O) (A:=A) (B:=B) (C:=C)); try assumption; intro; intros toto; elim toto; clear toto; intros. Lemma triangle_intersection_mediatrices : forall A B C B' C' O : PO, triangle A B C -> C' <> O -> B' <> O -> C' = milieu A B -> B' = milieu A C -> circonscrit O A B C -> ~ alignes C' O B'. unfold circonscrit, isocele in |- *; intros. deroule_triangle A B C. cut (~ paralleles (droite C' O) (droite B' O)); intros. red in |- *; intros; apply H9. rewrite droite_permute; auto. rewrite (droite_permute (A:=B') (B:=O)); auto. apply alignes_paralleles; auto with geo. apply angle_non_paralleles; auto. elim H4; intros H10 H11; try clear H4; try exact H11. rewrite (angles_droites_orthogonales (A:=A) (B:=C) (C:=A) (D:=B) (E:=B') (F:=O) (G:=C') (I:=O)); auto with geo. apply ortho_sym. apply mediatrice_orthogonale_segment; auto. apply milieu_mediatrice; auto. apply ortho_sym. apply mediatrice_orthogonale_segment; auto. apply milieu_mediatrice; auto. Qed. Lemma milieu_centrecirconscrit_orthogonal_segment : forall A B C A' O : PO, A' = milieu B C -> circonscrit O A B C -> orthogonal (vec O A') (vec B C). unfold circonscrit, isocele in |- *; intros. elim H0; intros H1 H2; try clear H0; try exact H2. discrimine O A'. apply ortho_sym. replace (vec A' A') with zero; [ idtac | Ringvec ]. auto with geo. discrimine B C. replace (vec C C) with zero; [ auto with geo | Ringvec ]. apply mediatrice_orthogonale_segment; auto. unfold mediatrice in |- *. rewrite <- H1; auto. apply milieu_mediatrice; auto. Qed. Axiom angles_orthogonal : forall A B C D : PO, A <> B -> C <> D -> double_AV (cons_AV (vec A B) (vec C D)) = image_angle pi -> orthogonal (vec A B) (vec C D). Theorem tangente : forall A B O T : PO, A <> B -> O <> A -> O <> B -> A <> T -> isocele O A B -> orthogonal (vec A T) (vec O A) -> double_AV (cons_AV (vec A T) (vec A B)) = cons_AV (vec O A) (vec O B). intros A B O T H H0 H1 H2 H3 H4; try assumption. lapply (isocele_angles_base (A:=O) (B:=A) (C:=B)); auto; intros. lapply (orthogonal_angles (A:=A) (B:=T) (C:=O) (D:=A)); auto; intros. lapply (somme_triangle (A:=O) (B:=A) (C:=B)); auto; intros. replace (cons_AV (vec O A) (vec O B)) with (plus (image_angle pi) (opp (plus (cons_AV (vec A B) (vec A O)) (cons_AV (vec B O) (vec B A))))). replace (cons_AV (vec A T) (vec A B)) with (plus (cons_AV (vec A T) (vec O A)) (cons_AV (vec O A) (vec A B))). unfold double_AV in |- *. rewrite <- H5; auto. replace (plus (plus (cons_AV (vec A T) (vec O A)) (cons_AV (vec O A) (vec A B))) (plus (cons_AV (vec A T) (vec O A)) (cons_AV (vec O A) (vec A B)))) with (plus (plus (cons_AV (vec A T) (vec O A)) (cons_AV (vec A T) (vec O A))) (plus (cons_AV (vec O A) (vec A B)) (cons_AV (vec O A) (vec A B)))). replace (plus (cons_AV (vec A T) (vec O A)) (cons_AV (vec A T) (vec O A))) with (double_AV (cons_AV (vec A T) (vec O A))); auto. rewrite H6; auto. rewrite opp_plus_plus_opp; auto. replace (cons_AV (vec O A) (vec A B)) with (plus (cons_AV (vec O A) (vec A O)) (cons_AV (vec A O) (vec A B))); auto. rewrite <- angle_plat; auto. rewrite def_opp; auto. mesure A O A B. replace (pi + (pi + x + (pi + x))) with (pi + (x + x) + (pi + pi)). rewrite add_mes_compatible. replace (pi + pi) with deuxpi; auto. rewrite pi_plus_pi. repeat rewrite <- add_mes_compatible. replace (pi + (x + x) + 0) with (pi + (x + x)); auto. ring. ring. rewrite Chasles; auto. mesure A T O A. mesure O A A B. replace (x + x + (x0 + x0)) with (x + x0 + (x + x0)); auto. ring. rewrite Chasles; auto. rewrite <- H7; auto. rewrite opp_plus_plus_opp; auto. rewrite <- H5; auto. mesure A B A O. mesure O A O B. replace (x0 + (x + x) + (- x + - x)) with x0; auto. ring. Qed. Theorem tangente_reciproque : forall A B O T T' : PO, A <> B -> O <> A -> O <> B -> A <> T' -> isocele O A B -> orthogonal (vec A T) (vec O A) -> double_AV (cons_AV (vec A T') (vec A B)) = cons_AV (vec O A) (vec O B) -> alignes A T T'. intros A B O T T' H H0 H1 H3 H4 H5 H6; try assumption. discrimine A T. apply alignes_angle; auto. unfold double_AV in |- *. replace (cons_AV (vec A T) (vec A T')) with (plus (cons_AV (vec A T) (vec A B)) (cons_AV (vec A B) (vec A T'))); auto. replace (plus (plus (cons_AV (vec A T) (vec A B)) (cons_AV (vec A B) (vec A T'))) (plus (cons_AV (vec A T) (vec A B)) (cons_AV (vec A B) (vec A T')))) with (plus (plus (cons_AV (vec A T) (vec A B)) (cons_AV (vec A T) (vec A B))) (plus (cons_AV (vec A B) (vec A T')) (cons_AV (vec A B) (vec A T')))); auto. replace (plus (cons_AV (vec A B) (vec A T')) (cons_AV (vec A B) (vec A T'))) with (cons_AV (vec O B) (vec O A)); auto. rewrite <- (def_opp (A:=O) (B:=A) (C:=O) (D:=B)); auto. rewrite <- (tangente (A:=A) (B:=B) (O:=O) (T:=T)); auto. unfold double_AV in |- *. rewrite opp_plus_plus_opp; auto. mesure A T A B. replace (x + x + (- x + - x)) with 0; auto. ring. rewrite <- (def_opp (A:=O) (B:=A) (C:=O) (D:=B)); auto. rewrite <- H6. unfold double_AV in |- *. rewrite opp_plus_plus_opp; auto. rewrite def_opp; auto. mesure A T A B. mesure A B A T'. replace (x + x + (x0 + x0)) with (x + x0 + (x + x0)); auto. ring. rewrite Chasles; auto. Qed. Theorem unicite_circonscrit_triangle : forall A B C O O1 : PO, triangle A B C -> circonscrit O A B C -> circonscrit O1 A B C -> O = O1. intros. deroule_triangle A B C. soit_mediatrice A B ipattern:M ipattern:K. soit_mediatrice B C ipattern:J ipattern:L. lapply (mediatrices_triangle_concours (A:=A) (B:=B) (C:=C) (I:=M) (J:=J) (K:=K) (L:=L)); auto; intros. cut (M <> J); intros. generalize H1; unfold circonscrit in |- *; intros. generalize H0; unfold circonscrit in |- *; intros. lapply (circonscrit_isocele (O:=O) (A:=A) (B:=B) (C:=C)); auto; intros. lapply (circonscrit_isocele (O:=O1) (A:=A) (B:=B) (C:=C)); auto; intros. elim H22; (clear H22; intros). elim H23; (clear H23; intros). lapply (milieu_mediatrice (A:=A) (B:=B) (M:=M)); auto; intros. lapply (milieu_mediatrice (A:=B) (B:=C) (M:=J)); auto; intros. lapply (mediatrice_droite (A:=A) (B:=B) (I:=M) (J:=K) (K:=O)); auto; intros. lapply (mediatrice_droite (A:=B) (B:=C) (I:=J) (J:=L) (K:=O)); auto; intros. lapply (mediatrice_droite (A:=A) (B:=B) (I:=M) (J:=K) (K:=O1)); auto; intros. lapply (mediatrice_droite (A:=B) (B:=C) (I:=J) (J:=L) (K:=O1)); auto; intros. cut (double_AV (cons_AV (vec M K) (vec J L)) = double_AV (cons_AV (vec B A) (vec B C))). intros H101. elim (classic (alignes J M L)); intros. apply (concours_unique (A:=M) (B:=J) (A1:=K) (B1:=M) (I:=O) (J:=O1)). red in |- *; intros; apply H2. cut (double_AV (cons_AV (vec M K) (vec M J)) = double_AV (cons_AV (vec B A) (vec B C))); intros. apply permute_alignes; auto. apply alignes_angle; auto. rewrite <- H36. apply angle_alignes; auto. rewrite <- H101. halignes H34 ipattern:x. absurd (J = M); auto. cut (vec J L = mult_PP (- x) (vec M J)); intros. cut (vec M K = mult_PP 1 (vec M K)); intros. apply angles_et_colinearite with (5 := H38) (6 := H37); auto. Ringvec. rewrite H36. Ringvec. auto. apply H30; auto. discrimine O M. discrimine O J. apply alignes_ordre_cycle; auto. apply alignes_ordre_cycle; auto. apply alignes_trans with (B := L); auto with geo. apply H32; auto. discrimine O1 M. discrimine O1 J. apply alignes_ordre_cycle; auto. apply alignes_ordre_cycle; auto. apply alignes_trans with (B := L); auto with geo. apply (concours_unique (A:=J) (B:=M) (A1:=L) (B1:=K) (I:=O) (J:=O1)); auto. red in |- *; intros; apply H34. apply alignes_ordre_permute; auto. discrimine O M. discrimine O K. apply alignes_ordre_cycle; auto with geo. discrimine O1 M. discrimine O1 K. apply alignes_ordre_cycle; auto with geo. apply angles_droites_orthogonales; auto. cut (orthogonal (vec M K) (vec A B)); intros; auto with geo. apply mediatrice_orthogonale_segment; auto. apply ortho_sym; auto. apply mediatrice_orthogonale_segment; auto. apply deux_milieux_distincts with (2 := H11) (3 := H18); auto. Qed. Lemma circonscrit_mediatrice : forall O A B C : PO, circonscrit O A B C -> mediatrice A B O /\ mediatrice B C O /\ mediatrice A C O. unfold circonscrit, isocele, mediatrice in |- *; intros; auto. elim H; intros; auto. split; [ assumption | split; [ idtac | try assumption ] ]. rewrite <- H0; auto. Qed. Require Export rotation_plane. Theorem reciproque_cocyclicite : forall A B C D : PO, triangle A B C -> triangle A B D -> double_AV (cons_AV (vec C A) (vec C B)) = double_AV (cons_AV (vec D A) (vec D B)) -> sont_cocycliques A B C D. unfold sont_cocycliques in |- *; intros. deroule_triangle A B C. deroule_triangle A B D. soit_circonscrit A B C ipattern:O2. soit_circonscrit A B D ipattern:O1. mesure C A C B. lapply (angle_inscrit2 (O:=O2) (A:=A) (B:=B) (C:=C)); auto; intros. lapply (angle_inscrit2 (O:=O1) (A:=A) (B:=B) (C:=D)); auto; intros. exists O2. split; [ try assumption | idtac ]. unfold circonscrit in |- *. split; [ try assumption | idtac ]. elim H10; auto. cut (double_AV (cons_AV (vec C A) (vec C B)) <> image_angle 0); [ intros H50 | idtac ]. cut (O2 = O1); intros. rewrite H21. elim H12; auto. soit_mediatrice A B ipattern:M ipattern:J. elim (circonscrit_mediatrice (O:=O2) (A:=A) (B:=B) (C:=C)); try assumption; intros H60 H61. elim H61; clear H61; intros H61 H62. elim (circonscrit_mediatrice (O:=O1) (A:=A) (B:=B) (C:=D)); try assumption; intros H70 H71. elim H71; clear H71; intros H71 H72. lapply (mediatrice_droite (A:=A) (B:=B) (I:=M) (J:=J) (K:=O2)); auto; intros. lapply (mediatrice_droite (A:=A) (B:=B) (I:=M) (J:=J) (K:=O1)); auto; intros. elim (existence_rotation_Ia A M (pisurdeux + - x)); intros K; intros. cut (A <> K); intros. cut (alignes A K O2); intros. cut (alignes A K O1); intros. elim (classic (alignes A K M)); intros. apply (concours_unique (A:=M) (B:=A) (A1:=J) (B1:=K) (I:=O2) (J:=O1)); auto. apply orthogonal_non_alignes; auto. lapply (mediatrice_orthogonale_segment (A:=A) (B:=B) (M:=M) (N:=J)); auto; intros. elim (orthogonal_segment_milieu (A:=A) (B:=B) (C:=M) (D:=J) (I:=M)); auto; intros. auto with geo. apply ortho_sym. apply H35; auto. apply milieu_mediatrice; auto. apply permute_alignes; auto. apply permute_alignes; auto. apply (concours_unique (A:=A) (B:=M) (A1:=K) (B1:=J) (I:=O2) (J:=O1)); auto. assert (alignes M J O2); auto with geo. assert (alignes M J O1); auto with geo. discrimine K O1. apply alignes_angle; [ auto | auto | idtac ]. unfold double_AV in |- *. replace (cons_AV (vec A K) (vec A O1)) with (plus (cons_AV (vec A K) (vec A M)) (cons_AV (vec A M) (vec A O1))). generalize (somme_triangle (A:=O1) (B:=A) (C:=B)); intros. generalize (isocele_angles_base (A:=O1) (B:=A) (C:=B)); auto; intros. generalize (angles_milieu (A:=O1) (B:=A) (C:=B) (I:=M)); auto; intros. rewrite <- H36; auto. replace (plus (plus (cons_AV (vec A K) (vec A M)) (cons_AV (vec A B) (vec A O1))) (plus (cons_AV (vec A K) (vec A M)) (cons_AV (vec A B) (vec A O1)))) with (plus (plus (cons_AV (vec A K) (vec A M)) (cons_AV (vec A K) (vec A M))) (plus (cons_AV (vec A B) (vec A O1)) (cons_AV (vec A B) (vec A O1)))). replace (plus (cons_AV (vec A B) (vec A O1)) (cons_AV (vec A B) (vec A O1))) with (plus (image_angle pi) (opp (cons_AV (vec O1 A) (vec O1 B)))). rewrite def_opp; auto. rewrite <- (mes_oppx (A:=O1) (B:=A) (C:=O1) (D:=B) (x:=x + x)); auto. rewrite <- (mes_oppx (A:=A) (B:=M) (C:=A) (D:=K) (x:=pisurdeux + - x)); auto. repeat rewrite <- add_mes_compatible. replace pi with (pisurdeux + pisurdeux); auto. replace (- (pisurdeux + - x) + - (pisurdeux + - x) + (pisurdeux + pisurdeux + - (x + x))) with 0; auto. ring. elim (rotation_def (I:=A) (A:=M) (B:=K) (a:=pisurdeux + - x)); auto. rewrite <- H20; auto. rewrite <- H1; unfold double_AV in |- *. rewrite <- H16. rewrite add_mes_compatible; auto. rewrite <- H34; auto. rewrite <- H35; auto. mesure A B A O1. mesure O1 A O1 B. replace (x1 + (x0 + x0) + - x1) with (x0 + x0); auto. ring. mesure A K A M. mesure A B A O1. replace (x0 + x0 + (x1 + x1)) with (x0 + x1 + (x0 + x1)); auto. ring. rewrite Chasles; auto. discrimine K O2. apply alignes_angle; [ auto | auto | idtac ]. unfold double_AV in |- *. replace (cons_AV (vec A K) (vec A O2)) with (plus (cons_AV (vec A K) (vec A M)) (cons_AV (vec A M) (vec A O2))). generalize (somme_triangle (A:=O2) (B:=A) (C:=B)); intros. generalize (isocele_angles_base (A:=O2) (B:=A) (C:=B)); auto; intros. generalize (angles_milieu (A:=O2) (B:=A) (C:=B) (I:=M)); auto; intros. rewrite <- H35; auto. replace (plus (plus (cons_AV (vec A K) (vec A M)) (cons_AV (vec A B) (vec A O2))) (plus (cons_AV (vec A K) (vec A M)) (cons_AV (vec A B) (vec A O2)))) with (plus (plus (cons_AV (vec A K) (vec A M)) (cons_AV (vec A K) (vec A M))) (plus (cons_AV (vec A B) (vec A O2)) (cons_AV (vec A B) (vec A O2)))). replace (plus (cons_AV (vec A B) (vec A O2)) (cons_AV (vec A B) (vec A O2))) with (plus (image_angle pi) (opp (cons_AV (vec O2 A) (vec O2 B)))). rewrite def_opp; auto. rewrite <- (mes_oppx (A:=O2) (B:=A) (C:=O2) (D:=B) (x:=x + x)); auto. rewrite <- (mes_oppx (A:=A) (B:=M) (C:=A) (D:=K) (x:=pisurdeux + - x)); auto. repeat rewrite <- add_mes_compatible. replace pi with (pisurdeux + pisurdeux); auto. replace (- (pisurdeux + - x) + - (pisurdeux + - x) + (pisurdeux + pisurdeux + - (x + x))) with 0; auto. ring. elim (rotation_def (I:=A) (A:=M) (B:=K) (a:=pisurdeux + - x)); auto. rewrite <- H19; auto. unfold double_AV in |- *. rewrite <- H16. rewrite add_mes_compatible; auto. rewrite <- H33; auto. rewrite <- H34; auto. mesure A B A O2. mesure O2 A O2 B. replace (x1 + (x0 + x0) + - x1) with (x0 + x0); auto. ring. mesure A K A M. mesure A B A O2. replace (x0 + x0 + (x1 + x1)) with (x0 + x1 + (x0 + x1)); auto. ring. rewrite Chasles; auto. apply image_distinct_centre with (2 := H30); auto. red in |- *; intros; apply H2. apply alignes_ordre_cycle; auto. apply alignes_angle; auto. Qed.HighSchoolGeometry/complements_cercle.v0000755000076500007650000001752112073525611020266 0ustar coqcoq00000000000000(* This program is free software; you can redistribute it and/or *) (* modify it under the terms of the GNU Lesser General Public License *) (* as published by the Free Software Foundation; either version 2.1 *) (* of the License, or (at your option) any later version. *) (* *) (* This program is distributed in the hope that it will be useful, *) (* but WITHOUT ANY WARRANTY; without even the implied warranty of *) (* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *) (* GNU General Public License for more details. *) (* *) (* You should have received a copy of the GNU Lesser General Public *) (* License along with this program; if not, write to the Free *) (* Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA *) (* 02110-1301 USA *) Require Export cocyclicite. Set Implicit Arguments. Unset Strict Implicit. Lemma triangle_rectangle_demi_cercle : forall A B C : PO, triangle A B C -> orthogonal (vec A B) (vec A C) -> ex (fun O : PO => circonscrit O A B C /\ cons_AV (vec O B) (vec O C) = image_angle pi). intros; deroule_triangle A ipattern:B ipattern:C. soit_circonscrit A B C ipattern:D. exists D. split; [ try assumption | idtac ]. rewrite <- (angle_inscrit (O:=D) (A:=A) (B:=B) (C:=C)); auto. apply orthogonal_angles; auto. Qed. Lemma triangle_demi_cercle_rectangle : forall A B C O : PO, triangle A B C -> circonscrit O A B C -> cons_AV (vec O B) (vec O C) = image_angle pi -> orthogonal (vec A B) (vec A C). intros; deroule_triangle A ipattern:B ipattern:C. deroule_circonscrit A B C O. apply angles_orthogonal; auto. rewrite (angle_inscrit (O:=O) (A:=A) (B:=B) (C:=C)); auto. Qed. Lemma triangle_diametre : forall A B C O : PO, triangle A B C -> O = milieu B C -> circonscrit O A B C -> orthogonal (vec A B) (vec A C). intros. apply triangle_demi_cercle_rectangle with O; auto. deroule_circonscrit A B C O. replace (cons_AV (vec O B) (vec O C)) with (plus (cons_AV (vec O B) (vec O A)) (cons_AV (vec O A) (vec O C))). deroule_triangle A B C. rewrite (milieu_angles (A:=B) (B:=C) (M:=O) (N:=A)); auto. rewrite <- (def_opp (A:=O) (B:=A) (C:=O) (D:=C)); auto. mesure O A O C. RReplace (- x + pi + x) pi; auto. rewrite Chasles; auto. Qed. Lemma triangle_rectangle_cercle_diametre : forall A B C : PO, A <> B -> A <> C -> orthogonal (vec A B) (vec A C) -> cercle_diametre B C A. icercle. assert (triangle A B C). unfold triangle in |- *. apply orthogonal_non_alignes; auto. elim triangle_rectangle_demi_cercle with (A := A) (B := B) (C := C); [ intros O' H3; elim H3; [ intros H4 H5; try clear H3; try exact H5 ] | auto | auto ]. exists O'. hcercle H4. split; [ idtac | auto ]. rewrite <- H6; auto. assert (vec O' C = mult_PP (-1) (vec O' B)). deroule_circonscrit A B C O'. apply (alignes_distance_negatif_colineaire (k:=1) (A:=O') (B:=B) (C:=C)); auto. rewrite <- H6; rewrite <- H7; ring. apply egalite_vecteur_milieu. rewrite H3; Ringvec. Qed. Lemma ligne_niveau_MAMB_O : forall A B M : PO, scalaire (vec M A) (vec M B) = 0 -> cercle_diametre A B M. intros. discrimine M A. discrimine M B. apply triangle_rectangle_cercle_diametre; auto with geo. Qed. Theorem caracterisation_cercle_diametre : forall A B M : PO, cercle_diametre A B M <-> scalaire (vec M A) (vec M B) = 0. red in |- *; try split; intros. hcercle H. elim H0; [ intros O H1; elim H1; [ intros H2 H3; try clear H1 H0; try exact H3 ] ]. discrimine A B. assert (A = M). apply cercle_diametre_degenere with B; auto. rewrite <- H1; rewrite H0. VReplace (vec B B) (mult_PP 0 (vec B B)). Simplscal. elim (classic (alignes A B M)); intros. elim alignes_diametre with (A := A) (B := M) (A' := B); intros; auto. rewrite H4. VReplace (vec A A) (mult_PP 0 (vec B B)). Simplscal. rewrite H4. VReplace (vec B B) (mult_PP 0 (vec B B)). Simplscal. assert (triangle A B M); (unfold triangle in |- *; auto). assert (orthogonal (vec M A) (vec M B)). apply (triangle_diametre (A:=M) (B:=A) (C:=B) (O:=O)); auto with geo. icercle. rewrite <- H6; auto. apply def_orthogonal; auto with geo. apply ligne_niveau_MAMB_O; auto. Qed. Lemma ligne_niveau_MAMB_k : forall (A B I M : PO) (k : R), k + Rsqr (distance I A) >= 0 -> I = milieu A B -> scalaire (vec M A) (vec M B) = k -> cercle I (sqrt (k + Rsqr (distance I A))) M. intros A B I M k H H0; try assumption. rewrite (scalaire_difference_carre (A:=A) (B:=B) (I:=I) M); auto. icercle. assert (Rsqr (distance I M) = k + Rsqr (distance I A)). rewrite <- distance_sym; rewrite <- H1; ring. apply Rsqr_inj; auto with geo real. rewrite Rsqr_sqrt; auto with real. Qed. Lemma homothetie_cercle_diametre : forall (k : R) (I A A' B B' M M' : PO), k <> 0 :>R -> A' = homothetie k I A :>PO -> B' = homothetie k I B :>PO -> M' = homothetie k I M :>PO -> cercle_diametre A B M -> cercle_diametre A' B' M'. icercle. elim H3; [ intros O H4; elim H4; [ intros H5 H6; elim H5; [ intros H7 H8; try clear H5 H4 H3; try exact H8 ] ] ]. elim existence_homothetique with (k := k) (I := I) (A := O); [ intros O' H3; try clear existence_homothetique; try exact H3 ]. exists O'; (split; auto). generalize (homothetie_bipoint (k:=k) (I:=I) (A:=O) (B:=A) (A':=O') (B':=A')); intros. generalize (homothetie_bipoint (k:=k) (I:=I) (A:=O) (B:=M) (A':=O') (B':=M')); intros. generalize (homothetie_bipoint (k:=k) (I:=I) (A:=O) (B:=B) (A':=O') (B':=B')); intros. split; apply carre_scalaire_egalite_distance. rewrite H4; auto. rewrite H9; auto. Simplscal. repeat rewrite carre_scalaire_distance; auto. rewrite H7; ring. rewrite H4; auto. rewrite H5; auto. Simplscal. repeat rewrite carre_scalaire_distance; auto. rewrite H8; ring. rewrite H3. rewrite (homothetie_milieu (k:=k) (I:=I) (A:=A) (A':=A') (B:=B) (B':=B') (M:=O) (N:=milieu A' B')); auto. Qed. Definition diametre_circonscrit (A A' B C : PO) := exists O : PO, O = milieu A A' /\ circonscrit O A B C. Lemma cocyclicite_cercle_diametre : forall A B C D A' : PO, triangle A B C -> sont_cocycliques A B C D -> diametre_circonscrit A A' B C -> diametre_circonscrit A A' C D. unfold sont_cocycliques, diametre_circonscrit in |- *; intros. elim H0; [ intros O1 H3; elim H3; [ intros H4 H5; try clear H3 H0; try exact H5 ] ]. elim H1; [ intros O H0; elim H0; [ intros H2 H3; try clear H0 H1; try exact H3 ] ]. assert (O1 = O). apply (unicite_circonscrit_triangle H H4 H3); auto. rewrite H0 in H5; clear H4 H0. exists O. split; [ try assumption | idtac ]. hcercle H3. hcercle H5. Qed. Lemma diametre_circonscrit_centre : forall A B C A' O : PO, triangle A B C -> circonscrit O A B C -> diametre_circonscrit A A' B C -> cercle_diametre A A' B. unfold sont_cocycliques, diametre_circonscrit in |- *; intros. elim H1; [ intros O1 H2; elim H2; [ intros H3 H4; try clear H2 H1; try exact H4 ] ]. assert (O1 = O). apply (unicite_circonscrit_triangle H H4 H0); auto. rewrite H1 in H3; clear H4 H1. apply circonscrit_diametre with (C := C) (O := O); auto. Qed. Lemma changement_diametre : forall A B C D C' O : PO, triangle A B C -> circonscrit O A B C -> O = milieu C C' -> sont_cocycliques A B C D -> cercle_diametre C C' D. unfold cercle_diametre, sont_cocycliques in |- *; intros. elim H2; [ intros O1 H3; elim H3; [ intros H4 H5; try clear H3 H2; try exact H5 ] ]. assert (O1 = O). apply (unicite_circonscrit_triangle H H4 H0); auto. rewrite H2 in H5; clear H4 H2. hcercle H5; hcercle H0. exists O. icercle. icercle. rewrite <- H7; auto. Qed. Lemma cocycliques_existence_diametre : forall A B C D : PO, sont_cocycliques A B C D -> exists A' : PO, diametre_circonscrit A A' B C. intros. generalize H; unfold sont_cocycliques, diametre_circonscrit in |- *; intros. elim H0; [ intros O H1; elim H1; [ intros H2 H3; try clear H1 H0; try exact H3 ] ]. symetrique O A ipattern:A'. exists A'; exists O. tauto. Qed.HighSchoolGeometry/complexes.v0000644000076500007650000001676712117747636016446 0ustar coqcoq00000000000000(* This program is free software; you can redistribute it and/or *) (* modify it under the terms of the GNU Lesser General Public License *) (* as published by the Free Software Foundation; either version 2.1 *) (* of the License, or (at your option) any later version. *) (* *) (* This program is distributed in the hope that it will be useful, *) (* but WITHOUT ANY WARRANTY; without even the implied warranty of *) (* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *) (* GNU General Public License for more details. *) (* *) (* You should have received a copy of the GNU Lesser General Public *) (* License along with this program; if not, write to the Free *) (* Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA *) (* 02110-1301 USA *) Require Export trigo. Set Implicit Arguments. Unset Strict Implicit. Parameters (O : PO) (I : PO) (J : PO). Hypothesis OIJ : repere_orthonormal_direct O I J. Hint Resolve OIJ: geo. Lemma OIJ_repere_ortho : repere_orthonormal O I J. auto with geo. Qed. Lemma OIJ_repere : repere O I J. auto with geo. Qed. Lemma OI_distincts : O <> I. elim OIJ; intros. auto with geo. elim H0; intros; auto with geo. Qed. Lemma OJ_distincts : O <> J. elim OIJ; intros. elim H0; intros; auto with geo. Qed. Hint Resolve OIJ_repere_ortho OIJ_repere OI_distincts OJ_distincts: geo. Lemma IJ_distincts : I <> J. cut (repere_orthonormal O I J); intros; auto with geo. elim H; intros. apply non_alignes_distincts2 with O; auto. apply orthogonal_non_alignes; auto with geo. Qed. Hint Resolve IJ_distincts: geo. Parameter C : Type. Parameter affixe : PO -> C. Parameter image : C -> PO. Parameter affixe_vec : PP -> C. Parameter image_vec : C -> PP. Axiom affixe_image : forall (z : C) (M : PO), M = image z -> z = affixe M. Axiom image_affixe : forall (z : C) (M : PO), z = affixe M -> M = image z. Axiom existence_image_complexe : forall z : C, exists M : PO, M = image z. Axiom existence_affixe_point : forall M : PO, exists z : C, z = affixe M. Axiom affixe_point_vecteur : forall (z : C) (M : PO), z = affixe M -> z = affixe_vec (vec O M). Axiom affixe_vecteur_point : forall (z : C) (M : PO), z = affixe_vec (vec O M) -> z = affixe M. Axiom image_point_vecteur : forall (z : C) (M : PO), M = image z -> vec O M = image_vec z. Axiom image_vecteur_point : forall (z : C) (M : PO), vec O M = image_vec z -> M = image z. Hint Resolve image_affixe affixe_image affixe_point_vecteur affixe_vecteur_point image_point_vecteur image_vecteur_point: geo. Lemma affixe_image_vecteur : forall (z : C) (M : PO), vec O M = image_vec z -> z = affixe_vec (vec O M). intros; eauto with geo. Qed. Lemma image_affixe_vecteur : forall (z : C) (M : PO), z = affixe_vec (vec O M) -> vec O M = image_vec z. intros; eauto with geo. Qed. Lemma existence_image_vecteur_complexe : forall z : C, exists M : PO, vec O M = image_vec z. intros. elim existence_image_complexe with (z := z); intros M H; try clear existence_image_complexe; try exact H. exists M; eauto with geo. Qed. Lemma existence_affixe_vecteur_point : forall M : PO, exists z : C, z = affixe_vec (vec O M). intros. elim existence_affixe_point with (M := M); intros z H; try clear existence_affixe_point; try exact H. exists z; eauto with geo. Qed. Parameter cons_cart : R -> R -> C. Axiom cart_point_complexe : forall (z : C) (a b : R) (M : PO), vec O M = add_PP (mult_PP a (vec O I)) (mult_PP b (vec O J)) :>PP -> z = affixe M -> z = cons_cart a b. Axiom complexe_cart_point : forall (z : C) (a b : R) (M : PO), z = cons_cart a b -> z = affixe M -> vec O M = add_PP (mult_PP a (vec O I)) (mult_PP b (vec O J)) :>PP. Hint Resolve abscisse_def ordonnee_def cart_def cart_point_complexe complexe_cart_point: geo. Lemma cart_point_complexe2 : forall (z : C) (a b : R) (M : PO), vec O M = add_PP (mult_PP a (vec O I)) (mult_PP b (vec O J)) :>PP -> M = image z -> z = cons_cart a b. intros. eauto with geo. Qed. Lemma complexe_cart_point2 : forall (z : C) (a b : R) (M : PO), z = cons_cart a b -> M = image z -> vec O M = add_PP (mult_PP a (vec O I)) (mult_PP b (vec O J)) :>PP. intros. eauto with geo. Qed. Hint Resolve cart_point_complexe2 complexe_cart_point2: geo. Lemma existence_parties_relles_imaginaires : forall z : C, exists a : R, (exists b : R, z = cons_cart a b). intros. elim existence_image_complexe with (z := z); intros M H1; try clear existence_image_complexe; try exact H1. elim existence_coordonnees with (O := O) (I := I) (J := J) (M := M); [ intros x H2; elim H2; intros y H3 | auto with geo ]. exists x; exists y. apply (cart_point_complexe (z:=z) (a:=x) (b:=y) (M:=M)); auto with geo. Qed. Lemma unicite_parties_relles_imaginaires : forall (z : C) (a b a' b' : R), z = cons_cart a b -> z = cons_cart a' b' -> a = a' /\ b = b'. intros. elim existence_image_complexe with (z := z); intros M H1; try clear existence_image_complexe; try exact H1. apply (unicite_coordonnees (O:=O) (I:=I) (J:=J) (M:=M)); auto with geo. apply complexe_cart_point with z; auto with geo. apply complexe_cart_point with z; auto with geo. Qed. Lemma egalite_point_image : forall (z z' : C) (M M' : PO), z = affixe M -> z' = affixe M' -> M = M' -> z = z'. intros. elim existence_parties_relles_imaginaires with (z := z); intros a H2; elim H2; intros b H3; try clear H2; try exact H3. elim existence_parties_relles_imaginaires with (z := z'); intros a' H2; elim H2; intros b' H4; try clear H2; try exact H4. generalize (complexe_cart_point (z:=z) (a:=a) (b:=b)); intros H2. cut (vec O M = add_PP (mult_PP a (vec O I)) (mult_PP b (vec O J))); intros; auto. cut (vec O M = add_PP (mult_PP a' (vec O I)) (mult_PP b' (vec O J))); intros. elim unicite_composantes_vecteur with (a1 := a) (a2 := b) (b1 := a') (b2 := b') (O := O) (I := I) (J := J) (A := O) (B := M); [ intros H7 H8; try clear unicite_composantes_vecteur; try exact H8 | auto with geo | auto | auto ]. rewrite H3; rewrite H4; rewrite H7; rewrite H8; auto. rewrite H1. apply complexe_cart_point with z'; auto. Qed. Lemma egalite_affixe_point : forall (z z' : C) (M M' : PO), z = affixe M -> z' = affixe M' -> z = z' -> M = M'. intros. elim existence_parties_relles_imaginaires with (z := z); intros a H2; elim H2; intros b H3; try clear H2; try exact H3. elim existence_parties_relles_imaginaires with (z := z'); intros a' H2; elim H2; intros b' H4; try clear H2; try exact H4. generalize (complexe_cart_point (z:=z) (a:=a) (b:=b)); intros H2. cut (vec O M = add_PP (mult_PP a (vec O I)) (mult_PP b (vec O J))); intros; auto. cut (vec O M' = add_PP (mult_PP a' (vec O I)) (mult_PP b' (vec O J))); intros. apply vecteur_nul_conf. replace (vec M M') with (add_PP (vec O M') (mult_PP (-1) (vec O M))); [ idtac | Ringvec ]. elim unicite_parties_relles_imaginaires with (z := z) (a := a) (b := b) (a' := a') (b' := b'); [ intros; try exact H8 | auto | auto ]. rewrite H5; rewrite H6; rewrite H7; rewrite H8. Ringvec. rewrite H1; auto. apply complexe_cart_point with z'; auto. Qed. Lemma egalite_affixe : forall z z' : C, image z = image z' -> z = z'. intros. elim existence_image_complexe with (z := z); intros M H0; try exact H0. elim existence_image_complexe with (z := z'); intros M'; intros. apply egalite_point_image with (M := M) (M' := M'); auto with geo. rewrite H0; rewrite H1; auto. Qed.HighSchoolGeometry/complexes_analytique.v0000755000076500007650000001541312073525613020656 0ustar coqcoq00000000000000(* This program is free software; you can redistribute it and/or *) (* modify it under the terms of the GNU Lesser General Public License *) (* as published by the Free Software Foundation; either version 2.1 *) (* of the License, or (at your option) any later version. *) (* *) (* This program is distributed in the hope that it will be useful, *) (* but WITHOUT ANY WARRANTY; without even the implied warranty of *) (* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *) (* GNU General Public License for more details. *) (* *) (* You should have received a copy of the GNU Lesser General Public *) (* License along with this program; if not, write to the Free *) (* Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA *) (* 02110-1301 USA *) Require Export complexes_inversion. Set Implicit Arguments. Unset Strict Implicit. Lemma translation_analytique : forall A M M' : PO, M' = translation O A M :>PO -> abscisse M' = abscisse M + abscisse A /\ ordonnee M' = ordonnee M + ordonnee A. intros. paffixe M ipattern:z. paffixe A ipattern:a. paffixe M' ipattern:z'. assert (z' = Cplus z a). apply rec_complexe_translation with (4 := H); auto. generalize H0 H1 H2. repeat rewrite <- coordonnees_affixe; intros. apply unicite_parties_relles_imaginaires with z'; auto. rewrite H3; rewrite H4; rewrite H5; rewrite Cplus_algebrique; auto. Qed. Lemma homothetie_analytique : forall (k : R) (J M M' : PO), M' = homothetie k J M :>PO -> abscisse M' + - abscisse J = k * (abscisse M + - abscisse J) /\ ordonnee M' + - ordonnee J = k * (ordonnee M + - ordonnee J). intros. paffixe M ipattern:z. paffixe J ipattern:j. paffixe M' ipattern:z'. assert (Cplus z' (Copp j) = Cmult (Rinj k) (Cplus z (Copp j))). apply rec_complexe_homothetie with (4 := H); auto. generalize H0 H1 H2. repeat rewrite <- coordonnees_affixe; intros. apply unicite_parties_relles_imaginaires with (Cplus z' (Copp j)); auto. rewrite H6; rewrite H5. rewrite Copp_algebrique; rewrite Cplus_algebrique; auto. rewrite H3; rewrite H4; rewrite H5. rewrite Copp_algebrique; rewrite Cplus_algebrique. unfold Rinj in |- *; rewrite Cmult_algebrique. RReplace (k * (abscisse M + - abscisse J) + - (0 * (ordonnee M + - ordonnee J))) (k * (abscisse M + - abscisse J)). RReplace (0 * (abscisse M + - abscisse J) + k * (ordonnee M + - ordonnee J)) (k * (ordonnee M + - ordonnee J)). auto. Qed. Lemma rotation_analytique : forall (a : R) (J M M' : PO), M' = rotation J a M -> abscisse M' + - abscisse J = cos a * (abscisse M + - abscisse J) + - (sin a * (ordonnee M + - ordonnee J)) /\ ordonnee M' + - ordonnee J = sin a * (abscisse M + - abscisse J) + cos a * (ordonnee M + - ordonnee J). intros. assert (cons_pol 1 a = cons_cart (cos a) (sin a)). elim existence_parties_relles_imaginaires with (z := cons_pol 1 a); [ intros a0 H0; elim H0; [ intros b H1; try clear H0 existence_parties_relles_imaginaires; try exact H1 ] ]. assert (a0 = 1 * cos a /\ b = 1 * sin a). apply passage_polaire_algebrique with (cons_pol 1 a); auto with geo. elim H2; [ intros H3 H4; try clear H2; try exact H4 ]. rewrite H1; rewrite H4; rewrite H3. RReplace (1 * cos a) (cos a). RReplace (1 * sin a) (sin a). auto. paffixe M ipattern:z. paffixe J ipattern:j. paffixe M' ipattern:z'. assert (Cplus z' (Copp j) = Cmult (cons_pol 1 a) (Cplus z (Copp j))). apply rotation_complexe with (4 := H); auto. generalize H3 H1 H2. repeat rewrite <- coordonnees_affixe; intros. apply unicite_parties_relles_imaginaires with (Cplus z' (Copp j)); auto. rewrite H7; rewrite H5. rewrite Copp_algebrique; rewrite Cplus_algebrique; auto. rewrite H4; rewrite H6; rewrite H7. rewrite Copp_algebrique; rewrite Cplus_algebrique. rewrite H0; rewrite Cmult_algebrique. auto. Qed. Lemma similitude_analytique : forall (k a : R) (J M M' : PO), k > 0 -> M' = similitude J k a M -> abscisse M' + - abscisse J = k * (cos a * (abscisse M + - abscisse J) + - (sin a * (ordonnee M + - ordonnee J))) /\ ordonnee M' + - ordonnee J = k * (sin a * (abscisse M + - abscisse J) + cos a * (ordonnee M + - ordonnee J)). intros. assert (k <> 0); auto with real. assert (cons_pol k a = cons_cart (k * cos a) (k * sin a)). elim existence_parties_relles_imaginaires with (z := cons_pol k a); [ intros a0 H2; elim H2; [ intros b H3 ] ]. assert (a0 = k * cos a /\ b = k * sin a). apply passage_polaire_algebrique with (cons_pol k a); auto with geo. elim H4; [ intros H5 H6; try clear H4; try exact H6 ]. rewrite H3; rewrite H5; rewrite H6. auto. paffixe M ipattern:z. paffixe J ipattern:j. paffixe M' ipattern:z'. assert (Cplus z' (Copp j) = Cmult (cons_pol k a) (Cplus z (Copp j))). apply similitude_complexe with (5 := H0); auto. generalize H3 H4 H5. repeat rewrite <- coordonnees_affixe; intros. apply unicite_parties_relles_imaginaires with (Cplus z' (Copp j)); auto. rewrite H9; rewrite H8. rewrite Copp_algebrique; rewrite Cplus_algebrique; auto. rewrite H6; rewrite H7; rewrite H8. rewrite Copp_algebrique; rewrite Cplus_algebrique. rewrite H2; rewrite Cmult_algebrique. RReplace (k * cos a * (abscisse M + - abscisse J) + - (k * sin a * (ordonnee M + - ordonnee J))) (k * (cos a * (abscisse M + - abscisse J) + - (sin a * (ordonnee M + - ordonnee J)))). RReplace (k * sin a * (abscisse M + - abscisse J) + k * cos a * (ordonnee M + - ordonnee J)) (k * (sin a * (abscisse M + - abscisse J) + cos a * (ordonnee M + - ordonnee J))). auto. Qed. Lemma inversion_pole_origine_analytique : forall (k : R) (M M' : PO), O <> M :>PO -> k <> 0 -> M' = inversion O k M :>PO -> abscisse M' = k * abscisse M / (Rsqr (abscisse M) + Rsqr (ordonnee M)) /\ ordonnee M' = k * ordonnee M / (Rsqr (abscisse M) + Rsqr (ordonnee M)). intros. paffixe M ipattern:z. paffixe M' ipattern:z'. assert (z <> zeroC). apply points_distincts_non_zeroC with (1 := H); auto with geo. assert (module z <> 0); auto with geo. assert (Rsqr (module z) <> 0). unfold Rsqr in |- *; auto with real. generalize H3 H2. repeat rewrite <- coordonnees_affixe; intros. assert (z' = Cmult (Rinj k) (Cinv (Conj z))). apply inversion_pole_origine_complexe with (5 := H1); auto with geo. apply unicite_parties_relles_imaginaires with z'; auto. rewrite H9. rewrite Conj_Cinv; auto. rewrite <- Rinj_Cinv; auto. ring_simplify. rewrite <- Rinj_Cmult. rewrite (carre_module H8). rewrite H8. rewrite Cmult_Rinj_algebrique. unfold Rdiv in |- *. replace (k * / (Rsqr (abscisse M) + Rsqr (ordonnee M)) * abscisse M) with (k * abscisse M * / (Rsqr (abscisse M) + Rsqr (ordonnee M))) by ring. replace (k * / (Rsqr (abscisse M) + Rsqr (ordonnee M)) * ordonnee M) with(k * ordonnee M * / (Rsqr (abscisse M) + Rsqr (ordonnee M))) by ring. auto. Qed. HighSchoolGeometry/complexes_conjugaison.v0000644000076500007650000002536212117747636021034 0ustar coqcoq00000000000000(* This program is free software; you can redistribute it and/or *) (* modify it under the terms of the GNU Lesser General Public License *) (* as published by the Free Software Foundation; either version 2.1 *) (* of the License, or (at your option) any later version. *) (* *) (* This program is distributed in the hope that it will be useful, *) (* but WITHOUT ANY WARRANTY; without even the implied warranty of *) (* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *) (* GNU General Public License for more details. *) (* *) (* You should have received a copy of the GNU Lesser General Public *) (* License along with this program; if not, write to the Free *) (* Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA *) (* 02110-1301 USA *) Require Export complexes_dilatations. Require Export reflexion_plane. Set Implicit Arguments. Unset Strict Implicit. Parameter Conj : C -> C. Axiom Conj_def : forall (z : C) (x y : R), z = cons_cart x y -> Conj z = cons_cart x (- y). Lemma Conj_algebrique : forall x y : R, Conj (cons_cart x y) = cons_cart x (- y). intros. rewrite (Conj_def (z:=cons_cart x y) (x:=x) (y:=y)); auto. Qed. Hint Resolve Conj_algebrique: geo. Lemma Conj_Conj : forall z : C, Conj (Conj z) = z. intros. elim existence_parties_relles_imaginaires with (z := z); intros x H; elim H; intros y H0; try clear H; try exact H0. rewrite H0. repeat rewrite Conj_algebrique. replace (- - y) with y; [ auto | ring ]. Qed. Lemma Conj_somme : forall z1 z2 : C, Conj (Cplus z1 z2) = Cplus (Conj z1) (Conj z2). intros. elim existence_parties_relles_imaginaires with (z := z1); intros x1 H; elim H; intros y1 H0; try clear H; try exact H0. elim existence_parties_relles_imaginaires with (z := z2); intros x2 H; elim H; intros y2 H1; try clear H; try exact H1. rewrite H1; rewrite H0. rewrite Cplus_algebrique. repeat rewrite Conj_algebrique. rewrite Cplus_algebrique. replace (- (y1 + y2)) with (- y1 + - y2); [ auto | ring ]. Qed. Lemma Conj_produit : forall z1 z2 : C, Conj (Cmult z1 z2) = Cmult (Conj z1) (Conj z2). intros. elim existence_parties_relles_imaginaires with (z := z1); intros x1 H; elim H; intros y1 H0; try clear H; try exact H0. elim existence_parties_relles_imaginaires with (z := z2); intros x2 H; elim H; intros y2 H1; try clear H; try exact H1. rewrite H1; rewrite H0. rewrite Cmult_algebrique. repeat rewrite Conj_algebrique. rewrite Cmult_algebrique. replace (- y1 * - y2) with (y1 * y2); [ idtac | ring ]. replace (- y1 * x2 + x1 * - y2) with (- (y1 * x2 + x1 * y2)); [ auto | ring ]. Qed. Lemma Conj_zeroC : Conj zeroC = zeroC. unfold zeroC in |- *. repeat rewrite Conj_algebrique. replace (-0) with 0; [ auto | ring ]. Qed. Lemma Conj_oneC : Conj oneC = oneC. unfold oneC in |- *. repeat rewrite Conj_algebrique. replace (-0) with 0; [ auto | ring ]. Qed. Lemma Conj_reel : forall x : R, Conj (Rinj x) = Rinj x. unfold Rinj in |- *; intros. repeat rewrite Conj_algebrique. replace (-0) with 0; [ auto | ring ]. Qed. Hint Resolve Conj_zeroC Conj_oneC Conj_reel: geo. Lemma Conj_i : Conj i = Copp i. unfold i in |- *. repeat rewrite Conj_algebrique; repeat rewrite Copp_algebrique. replace (-0) with 0; [ auto | ring ]. Qed. Lemma non_zero_Conj : forall z : C, z <> zeroC -> Conj z <> zeroC. intros. red in |- *; intros; apply H. rewrite <- (Conj_Conj z). rewrite H0; auto with geo. Qed. Hint Resolve non_zero_Conj Conj_produit Conj_somme: geo. Lemma Conj_Cinv : forall z : C, z <> zeroC -> Conj (Cinv z) = Cinv (Conj z). intros. cut (Cmult z (Cinv z) = oneC); (intros; auto with geo). cut (Cmult (Conj z) (Conj (Cinv z)) = oneC); intros. cut (Cinv (Conj z) = Conj (Cinv z)); intros. 2: apply Cinv_def2; auto with geo. rewrite <- H2; auto with geo. rewrite <- Conj_produit; rewrite H0; auto with geo. Qed. Hint Resolve Conj_Cinv: geo. Lemma Conj_Cdiv : forall z z' : C, z' <> zeroC -> Conj (Cdiv z z') = Cdiv (Conj z) (Conj z'). intros. rewrite Cdiv_def; auto; rewrite Conj_produit; rewrite Conj_Cinv; auto. rewrite <- Cdiv_def; auto with geo. Qed. Lemma module_Conj : forall z : C, module (Conj z) = module z. intros. elim existence_parties_relles_imaginaires with (z := z); intros x H; elim H; intros y H0; try clear H; try exact H0. cut (Conj z = cons_cart x (- y)); intros. rewrite (passage_algebrique_module H); rewrite (passage_algebrique_module H0). replace (Rsqr (- y)) with (Rsqr y); [ auto | unfold Rsqr in |- *; ring ]. apply Conj_def; auto. Qed. Lemma argument_Conj : forall (z : C) (a : R), z <> zeroC -> argument z = image_angle a -> argument (Conj z) = image_angle (- a). intros. elim existence_parties_relles_imaginaires with (z := z); intros x H1; elim H1; intros y H2; try clear H1; try exact H2. cut (Conj z = cons_cart x (- y)); intros. 2: apply Conj_def; auto. elim existence_module with (z := z); intros r H3; try clear existence_module; try exact H3. elim passage_algebrique_argument with (z := z) (r := r) (x := x) (y := y) (a := a); [ try intros; try exact H5 | auto with geo | auto with geo | auto with geo ]. cut (module (Conj z) = r); intros. elim existence_argument with (z := Conj z); [ intros b H7; try clear existence_argument; try exact H7 | auto with geo ]. elim passage_algebrique_argument with (z := Conj z) (r := r) (x := x) (y := - y) (a := b); [ try intros | auto with geo | auto with geo | auto with geo ]. rewrite H7. apply egalite_angle_trigo. rewrite H9; rewrite sin_impaire; rewrite H5; ring. rewrite H8; rewrite cos_paire; rewrite H4; ring. rewrite module_Conj; auto. Qed. Lemma forme_polaire_Conj : forall (z : C) (r a : R), z <> zeroC -> z = cons_pol r a -> Conj z = cons_pol r (- a). intros. apply forme_polaire_def; auto with geo. rewrite module_Conj; auto. eauto with geo. apply argument_Conj; auto with geo. eauto with geo. Qed. Lemma argument_Conj2 : forall z : C, z <> zeroC -> argument (Conj z) = opp (argument z). intros. elim existence_argument with (z := z); [ intros a H7; try clear existence_argument; try exact H7 | auto with geo ]. rewrite (argument_Conj (z:=z) (a:=a)); auto with geo. rewrite H7; auto with geo. Qed. Theorem reflexion_conjugaison : forall (z z' : C) (M M' : PO), z = affixe M -> z' = affixe M' -> M' = reflexion O I M -> z' = Conj z. intros z z' M M' H H0; try assumption. discrimine O M. cut (M <> I). intros H20. rewrite <- reflexion_axe; auto with geo. cut (z = zeroC); intros. rewrite H0; rewrite H3; rewrite <- H1; rewrite H2; auto. symmetry in |- *; rewrite <- affixe_origine; auto with geo. rewrite H; rewrite <- H1; auto with geo. rewrite <- H1; auto with geo. discrimine I M. rewrite <- reflexion_axe; auto with geo. cut (z = oneC); intros. rewrite H0; rewrite H4; rewrite <- H; rewrite H3; auto with geo. unfold oneC in |- *. apply cart_point_complexe with I. Ringvec. rewrite H; rewrite <- H2; auto. intros. cut (distance O M = distance O M'); intros. 2: apply (reflexion_isometrie (A:=O) (B:=I)); auto with geo. cut (cons_AV (vec O I) (vec O M') = opp (cons_AV (vec O I) (vec O M))); intros. 2: apply (reflexion_anti_deplacement (A:=O) (B:=I)); auto with geo. cut (O <> M'); intros. cut (z <> zeroC); intros. cut (z' <> zeroC); intros. apply egalite_forme_polaire; auto with geo. rewrite module_Conj. rewrite (module_def2 H); rewrite (module_def2 H0); auto. rewrite argument_Conj2; auto. rewrite (argument_def2 (M:=M) (z:=z)); auto with geo. rewrite (argument_def2 (M:=M') (z:=z')); auto with geo. eauto with geo. eauto with geo. apply isometrie_distinct with (2 := H4); auto with geo. Qed. Lemma composantes_projete_orthogonal : forall (a b : R) (M H : PO), H = projete_orthogonal O I M -> vec O M = add_PP (mult_PP a (vec O I)) (mult_PP b (vec O J)) -> vec O H = mult_PP a (vec O I). intros. elim def_projete_orthogonal2 with (A := O) (B := I) (C := M) (H := H); [ intros | auto with geo | auto ]. halignes H2 ipattern:k. absurd (O = I); auto with geo. cut (vec H M = add_PP (mult_PP (a + - k) (vec O I)) (mult_PP b (vec O J))); intros. cut (scalaire (vec O I) (vec H M) = a + - k); intros. replace a with k; auto. replace a with (k + (a + - k)); [ idtac | ring ]. cut (scalaire (vec O I) (vec H M) = 0); intros; auto with geo. rewrite <- H6; rewrite H7; ring. elim existence_representant_vecteur with (A := O) (B := H) (C := M); intros D H6; try clear existence_representant_vecteur; rewrite <- H6. rewrite (scalaire_coordonnees (O:=O) (I:=I) (J:=J) (M:=I) (N:=D) (x:=1) (y:=0) (x':=a + - k) (y':=b)); auto with geo. ring. Ringvec. rewrite H6; auto with geo. replace (vec H M) with (add_PP (vec O M) (mult_PP (-1) (vec O H))); [ idtac | Ringvec ]. rewrite H1; rewrite H4; Ringvec. Qed. Lemma affixe_projete_orthogonal : forall (z : C) (a b : R) (M H : PO), H = projete_orthogonal O I M -> z = affixe M -> z = cons_cart a b -> Rinj a = affixe H. unfold Rinj in |- *; intros. cut (vec O H = mult_PP a (vec O I)); intros. symmetry in |- *. apply (cart_point_complexe (z:=affixe H) (a:=a) (b:=0) (M:=H)); auto. rewrite H3; Ringvec. apply (composantes_projete_orthogonal (a:=a) (b:=b) (M:=M) (H:=H)); auto. eauto with geo. Qed. Theorem conjugaison_reflexion : forall (z : C) (M M' : PO), z = affixe M -> Conj z = affixe M' -> M' = reflexion O I M. intros z M M'; try assumption. discrimine O M. cut (M <> I); intros. rewrite <- reflexion_axe; auto with geo. cut (z = zeroC); intros. apply egalite_affixe_point with (1 := H2) (2 := H1); auto. rewrite H3; auto with geo. rewrite H1; rewrite <- H; auto with geo. rewrite <- H; auto with geo. elim (classic (alignes O I M)); intros. rewrite <- reflexion_axe; auto with geo. apply egalite_affixe_point with (1 := H2) (2 := H1); auto. halignes H0 ipattern:k. absurd (O = I); auto with geo. cut (z = cons_cart k 0); intros. 2: apply cart_point_complexe with M; auto. rewrite H4; rewrite Conj_algebrique. replace (-0) with 0; [ auto | ring ]. rewrite H3; Ringvec. elim existence_projete_orthogonal with (A := O) (B := I) (C := M); [ intros N H4; try clear existence_projete_orthogonal; try exact H4 | auto with geo ]. apply reflexion_def2 with N; auto with geo. elim existence_parties_relles_imaginaires with (z := z); intros a H6; elim H6; intros b H7; try clear H6 existence_parties_relles_imaginaires; try exact H7. cut (Rinj a = affixe N); intros. apply produit_reel_affixe_vecteur with (z := Cplus (Rinj a) (Copp z)) (z' := Cplus (Conj z) (Copp z)); auto with geo. unfold Rinj in |- *. rewrite H7; rewrite Conj_algebrique. rewrite Copp_algebrique; repeat rewrite Cplus_algebrique. rewrite Cmult_algebrique. replace (2 * (a + - a) + - (0 * (0 + - b))) with (a + - a); [ auto | ring ]. replace (0 * (a + - a) + 2 * (0 + - b)) with (- b + - b); [ auto | ring ]. apply (affixe_projete_orthogonal (z:=z) (a:=a) (b:=b) (M:=M) (H:=N)); auto. Qed.HighSchoolGeometry/complexes_dilatations.v0000644000076500007650000003547712073525615021030 0ustar coqcoq00000000000000(* This program is free software; you can redistribute it and/or *) (* modify it under the terms of the GNU Lesser General Public License *) (* as published by the Free Software Foundation; either version 2.1 *) (* of the License, or (at your option) any later version. *) (* *) (* This program is distributed in the hope that it will be useful, *) (* but WITHOUT ANY WARRANTY; without even the implied warranty of *) (* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *) (* GNU General Public License for more details. *) (* *) (* You should have received a copy of the GNU Lesser General Public *) (* License along with this program; if not, write to the Free *) (* Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA *) (* 02110-1301 USA *) Require Export dilatations. Require Export operations_complexes. Set Implicit Arguments. Unset Strict Implicit. Lemma angle_argument : forall (z z' : C) (M M' : PO), O <> M :>PO -> O <> M' :>PO -> z = affixe M :>C -> z' = affixe M' :>C -> cons_AV (vec O M) (vec O M') = plus (argument z') (opp (argument z)) :>AV. intros. rewrite (argument_def2 (M:=M) (z:=z)); auto. rewrite (argument_def2 (M:=M') (z:=z')); auto. rewrite Chasles_diff; auto with geo. Qed. Hint Resolve angle_argument: geo. Lemma egalite_vecteur_OM_image : forall (z z' : C) (M M' : PO), z = affixe_vec (vec O M) :>C -> z' = affixe_vec (vec O M') :>C -> vec O M = vec O M' :>PP -> z = z' :>C. intros. apply egalite_point_image with (M := M) (M' := M'); eauto with geo. apply vecteur_nul_conf. replace (vec M M') with (add_PP (vec O M') (mult_PP (-1) (vec O M))); [ idtac | Ringvec ]. rewrite H1; Ringvec. Qed. Lemma egalite_vecteur_image : forall (z z' : C) (A B A' B' : PO), z = affixe_vec (vec A B) :>C -> z' = affixe_vec (vec A' B') :>C -> vec A B = vec A' B' :>PP -> z = z' :>C. intros. elim existence_representant_vecteur with (A := O) (B := A) (C := B); intros D H2; intros; try exact H2. elim existence_representant_vecteur with (A := O) (B := A') (C := B'); intros D'; intros; try exact H2. apply egalite_vecteur_OM_image with (M := D) (M' := D'). rewrite H2; auto. rewrite H3; auto. rewrite H2; rewrite H3; auto. Qed. Lemma egalite_affixe_vecteur_OM : forall (z z' : C) (M M' : PO), z = affixe_vec (vec O M) :>C -> z' = affixe_vec (vec O M') :>C -> z = z' :>C -> vec O M = vec O M' :>PP. intros. replace M' with M; auto. apply egalite_affixe_point with (3 := H1); auto with geo. Qed. Lemma egalite_affixe_vecteur : forall (z z' : C) (A B A' B' : PO), z = affixe_vec (vec A B) :>C -> z' = affixe_vec (vec A' B') :>C -> z = z' :>C -> vec A B = vec A' B' :>PP. intros. elim existence_representant_vecteur with (A := O) (B := A) (C := B); intros D H2; intros; try exact H2. elim existence_representant_vecteur with (A := O) (B := A') (C := B'); intros D'; intros; try exact H2. rewrite <- H2; rewrite <- H3. apply egalite_affixe_vecteur_OM with (z := z) (z' := z'); auto. rewrite H2; auto. rewrite H3; auto. Qed. Hint Resolve affixe_vec_AB: geo. Lemma complexe_translation : forall (a z z' : C) (A M M' : PO), z = affixe M -> z' = affixe M' -> a = affixe A -> z' = Cplus z a -> M' = translation O A M :>PO. intros. apply rec_translation_vecteur. apply (egalite_affixe_vecteur (z:=a) (z':=Cplus z' (Copp z)) (A:=O) (B:=A) (A':=M) (B':=M')); auto with geo. rewrite H2. ring. Qed. Lemma rec_complexe_translation : forall (a z z' : C) (A M M' : PO), z = affixe M -> z' = affixe M' -> a = affixe A -> M' = translation O A M :>PO -> z' = Cplus z a. intros. cut (Cplus z' (Copp z) = a); intros. rewrite <- H3; ring. apply (egalite_vecteur_image (z:=Cplus z' (Copp z)) (z':=a) (A:=M) (B:=M') (A':=O) (B':=A)); auto with geo. symmetry in |- *; apply translation_vecteur; auto. Qed. Ltac paffixe M z := elim (existence_affixe_point M); intros z; intros. Lemma argument_affixe_produit_positif_vecteur_OM : forall (k : R) (M M' : PO) (z z' : C), O <> M :>PO -> k > 0 -> vec O M' = mult_PP k (vec O M) :>PP -> z = affixe_vec (vec O M) :>C -> z' = affixe_vec (vec O M') :>C -> argument z' = argument z :>AV. intros. cut (O <> M'); intros. rewrite (argument_def2 (M:=M) (z:=z)); auto with geo. rewrite (argument_def2 (M:=M') (z:=z')); auto with geo. apply angle_produit_positif_r with k; auto with geo. apply distinct_produit_vecteur with (3 := H1); auto. auto with real. Qed. Lemma argument_affixe_produit_negatif_vecteur_OM : forall (k : R) (M M' : PO) (z z' : C), O <> M :>PO -> k < 0 -> vec O M' = mult_PP k (vec O M) :>PP -> z = affixe_vec (vec O M) :>C -> z' = affixe_vec (vec O M') :>C -> argument z' = plus (argument z) (image_angle pi) :>AV. intros. cut (O <> M'); intros. rewrite (argument_def2 (M:=M) (z:=z)); auto with geo. rewrite (argument_def2 (M:=M') (z:=z')); auto with geo. apply angle_produit_negatif_r with k; auto with geo. apply distinct_produit_vecteur with (3 := H1); auto. auto with real. Qed. Lemma argument_affixe_produit_positif_vecteur : forall (k : R) (A B A' B' : PO) (z z' : C), A <> B :>PO -> k > 0 -> vec A' B' = mult_PP k (vec A B) :>PP -> z = affixe_vec (vec A B) :>C -> z' = affixe_vec (vec A' B') :>C -> argument z' = argument z :>AV. intros k A B A' B' z z' H H0; try assumption. elim existence_representant_vecteur with (A := O) (B := A) (C := B); intros M; intros H1. elim existence_representant_vecteur with (A := O) (B := A') (C := B'); intros M'; intros H2. rewrite <- H2; rewrite <- H1; intros. apply (argument_affixe_produit_positif_vecteur_OM (k:=k) (M:=M) (M':=M') (z:=z) (z':=z')); auto. apply distinct_egalite_vecteur with (2 := H1); auto. Qed. Lemma argument_affixe_produit_negatif_vecteur : forall (k : R) (A B A' B' : PO) (z z' : C), A <> B :>PO -> k < 0 -> vec A' B' = mult_PP k (vec A B) :>PP -> z = affixe_vec (vec A B) :>C -> z' = affixe_vec (vec A' B') :>C -> argument z' = plus (argument z) (image_angle pi) :>AV. intros k A B A' B' z z' H H0; try assumption. elim existence_representant_vecteur with (A := O) (B := A) (C := B); intros M; intros H1. elim existence_representant_vecteur with (A := O) (B := A') (C := B'); intros M'; intros H2. rewrite <- H2; rewrite <- H1; intros. apply (argument_affixe_produit_negatif_vecteur_OM (k:=k) (M:=M) (M':=M') (z:=z) (z':=z')); auto. apply distinct_egalite_vecteur with (2 := H1); auto. Qed. Lemma module_affixe_produit_vecteur_OM : forall (k : R) (M M' : PO) (z z' : C), vec O M' = mult_PP k (vec O M) :>PP -> z = affixe_vec (vec O M) :>C -> z' = affixe_vec (vec O M') :>C -> module z' = Rabs k * module z. intros. rewrite (module_def2 (z:=z) (M:=M)); auto with geo. rewrite (module_def2 (z:=z') (M:=M')); auto with geo. Qed. Lemma module_affixe_produit_vecteur : forall (k : R) (A B A' B' : PO) (z z' : C), vec A' B' = mult_PP k (vec A B) :>PP -> z = affixe_vec (vec A B) :>C -> z' = affixe_vec (vec A' B') :>C -> module z' = Rabs k * module z. intros k A B A' B' z z'; try assumption. elim existence_representant_vecteur with (A := O) (B := A) (C := B); intros M; intros H1. elim existence_representant_vecteur with (A := O) (B := A') (C := B'); intros M'; intros H2. rewrite <- H2; rewrite <- H1; intros. apply (module_affixe_produit_vecteur_OM (k:=k) (M:=M) (M':=M') (z:=z) (z':=z')); auto. Qed. Lemma egalite_point_zeroC : forall (z : C) (A B : PO), A = B -> z = affixe_vec (vec A B) :>C -> z = zeroC :>C. intros z A B H; try assumption. elim existence_representant_vecteur with (A := O) (B := A) (C := B); intros M H1. rewrite <- H1; intros. cut (O = M); intros; auto. rewrite <- H2 in H0. rewrite affixe_origine; auto with geo. apply vecteur_nul_conf. rewrite H1; rewrite H; Ringvec. Qed. Lemma points_distincts_non_zeroC : forall (z : C) (A B : PO), A <> B :>PO -> z = affixe_vec (vec A B) :>C -> z <> zeroC :>C. intros z A B H; try assumption. elim existence_representant_vecteur with (A := O) (B := A) (C := B); intros M H1. rewrite <- H1; intros. cut (O <> M); intros. apply nonorigine_image_nonzero with M; auto with geo. red in |- *; intros; apply H. apply vecteur_nul_conf. rewrite <- H1; rewrite H2; Ringvec. Qed. Theorem produit_vecteur_image : forall (k : R) (z z' : C) (A B A' B' : PO), z = affixe_vec (vec A B) :>C -> z' = affixe_vec (vec A' B') :>C -> vec A' B' = mult_PP k (vec A B) :>PP -> z' = Cmult (Rinj k) z :>C. intros. cut (module z' = Rabs k * module z); intros. 2: apply (module_affixe_produit_vecteur (k:=k) (A:=A) (B:=B) (A':=A') (B':=B') (z:=z) (z':=z')); auto. discrimine A B. rewrite (egalite_point_zeroC (z:=z) (A:=A) (B:=B)); auto with geo. rewrite (egalite_point_zeroC (z:=z') (A:=A') (B:=B')); auto with geo. apply vecteur_nul_conf. rewrite H1; rewrite H3; Ringvec. elim (classic (k = 0)); intros. rewrite (egalite_point_zeroC (z:=z') (A:=A') (B:=B')); auto with geo. rewrite H4; rewrite Rinj_zero; ring. apply vecteur_nul_conf. rewrite H1; rewrite H4; Ringvec. cut (A' <> B'); intros. cut (k > 0 \/ k < 0); intros. elim H6; [ intros H7; try clear H6 | intros H7; try clear H6; try exact H7 ]. cut (argument z' = argument z); intros. 2: apply (argument_affixe_produit_positif_vecteur (k:=k) (A:=A) (B:=B) (A':=A') (B':=B') (z:=z) (z':=z')); auto with geo. apply egalite_forme_polaire. apply points_distincts_non_zeroC with (1 := H5); auto. apply nonzero_produit; auto with geo. apply points_distincts_non_zeroC with (1 := H3); auto with geo. rewrite H2; rewrite Cmult_module; rewrite module_reel; auto. rewrite H6; rewrite Cmult_argument; auto with geo. rewrite argument_reel_pos; auto. rewrite plus_commutative; symmetry in |- *; rewrite plus_angle_zero; auto. apply points_distincts_non_zeroC with (1 := H3); auto with geo. cut (argument z' = plus (argument z) (image_angle pi)); intros. 2: apply (argument_affixe_produit_negatif_vecteur (k:=k) (A:=A) (B:=B) (A':=A') (B':=B') (z:=z) (z':=z')); auto with geo. apply egalite_forme_polaire. apply points_distincts_non_zeroC with (1 := H5); auto. apply nonzero_produit; auto with geo. apply points_distincts_non_zeroC with (1 := H3); auto with geo. rewrite H2; rewrite Cmult_module; rewrite module_reel; auto. rewrite H6; rewrite Cmult_argument; auto with geo. rewrite argument_reel_neg; auto. rewrite plus_commutative; auto. apply points_distincts_non_zeroC with (1 := H3); auto with geo. elim Rtotal_order with (r1 := k) (r2 := 0); [ intros H6; try clear total_order | intros H6; (elim H6; [ intros H7; try clear H6 total_order | intros H7; try clear H6 total_order; try exact H7 ]) ]. right; try assumption. absurd (k = 0); auto. left; try assumption. apply distinct_mult_vecteur with (3 := H1); auto. Qed. Theorem produit_reel_affixe_vecteur_OM : forall (k : R) (z z' : C) (M M' : PO), z = affixe_vec (vec O M) :>C -> z' = affixe_vec (vec O M') :>C -> z' = Cmult (Rinj k) z :>C -> vec O M' = mult_PP k (vec O M) :>PP. intros. cut (module z' = module (Rinj k) * module z); intros. discrimine O M. cut (z = zeroC); intros. replace M with M'. Ringvec. apply (egalite_affixe_point (z:=z') (z':=z) (M:=M') (M':=M)); auto with geo. rewrite H1; rewrite H4; ring. apply (egalite_point_image (z:=z) (z':=zeroC) (M:=M) (M':=O)); auto with geo. cut (z <> zeroC); [ idtac | eauto with geo ]. intros H20. elim Rtotal_order with (r1 := k) (r2 := 0); [ intros H6; try clear total_order | intros H6; (elim H6; [ intros H7; try clear H6 | intros H7; try clear H6; try exact H7 ]) ]. rewrite module_reel_neg in H2; auto with real. cut (k <> 0); intros; [ idtac | auto with real ]. cut (z' <> zeroC); intros. cut (O <> M'); intros. cut (cons_AV (vec O M) (vec O M') = image_angle pi); intros. rewrite (alignes_distance_negatif_colineaire (k:=- k) (A:=O) (B:=M) (C:=M')); auto with geo. replace (- - k) with k; try ring; auto. rewrite <- (module_def2 (z:=z) (M:=M)); auto with geo. rewrite <- (module_def2 (z:=z') (M:=M')); auto with geo. rewrite (angle_argument (z:=z) (z':=z') (M:=M) (M':=M')); auto with geo. rewrite H1; rewrite Cmult_argument; auto with geo. rewrite argument_reel_neg; auto with geo. elim existence_argument with (z := z); [ intros; try clear existence_argument | auto with geo ]. rewrite H8; rewrite <- mes_opp; repeat rewrite <- add_mes_compatible. replace (pi + x + - x) with pi; [ auto | ring ]. apply image_nonzero_nonorigine with z'; auto with geo. apply nonzero_module. rewrite H2. apply Rmult_integral_contrapositive. split; auto with real geo. cut (z' = zeroC); intros. replace M' with O. rewrite H7; Ringvec. apply (egalite_affixe_point (z:=zeroC) (z':=z') (M:=O) (M':=M')); auto with geo. apply module_nul_zeroC. rewrite H2; rewrite H7. replace (Rinj 0) with zeroC; auto with geo. rewrite module_zeroC; ring. rewrite module_reel_pos in H2; auto with real. cut (k <> 0); intros; [ idtac | auto with real ]. cut (z' <> zeroC); intros. cut (O <> M'); intros. cut (cons_AV (vec O M) (vec O M') = image_angle 0); intros. rewrite (alignes_distance_positif_colineaire (k:=k) (A:=O) (B:=M) (C:=M')); auto with geo. rewrite <- (module_def2 (z:=z) (M:=M)); auto with geo. rewrite <- (module_def2 (z:=z') (M:=M')); auto with geo. rewrite (angle_argument (z:=z) (z':=z') (M:=M) (M':=M')); auto with geo. rewrite H1; rewrite Cmult_argument; auto with geo. rewrite argument_reel_pos; auto with geo. elim existence_argument with (z := z); [ intros; try clear existence_argument | auto with geo ]. rewrite H8; rewrite <- mes_opp; repeat rewrite <- add_mes_compatible. replace (0 + x + - x) with 0; [ auto | ring ]. apply image_nonzero_nonorigine with z'; auto with geo. apply nonzero_module. rewrite H2. apply Rmult_integral_contrapositive. split; auto with real geo. rewrite H1; rewrite Cmult_module; auto. Qed. Theorem produit_reel_affixe_vecteur : forall (k : R) (z z' : C) (A B A' B' : PO), z = affixe_vec (vec A B) :>C -> z' = affixe_vec (vec A' B') :>C -> z' = Cmult (Rinj k) z :>C -> vec A' B' = mult_PP k (vec A B) :>PP. intros k z z' A B A' B'; try assumption. elim existence_representant_vecteur with (A := O) (B := A) (C := B); intros M; intros H1. elim existence_representant_vecteur with (A := O) (B := A') (C := B'); intros M'; intros H2. rewrite <- H2; rewrite <- H1; intros. apply (produit_reel_affixe_vecteur_OM (k:=k) (z:=z) (z':=z') (M:=M) (M':=M')); auto. Qed. Theorem complexe_homothetie : forall (k : R) (j z z' : C) (J M M' : PO), z = affixe M -> z' = affixe M' -> j = affixe J -> Cplus z' (Copp j) = Cmult (Rinj k) (Cplus z (Copp j)) -> M' = homothetie k J M :>PO. intros. apply vecteur_homothetie. apply produit_reel_affixe_vecteur with (3 := H2); auto with geo. Qed. Theorem rec_complexe_homothetie : forall (k : R) (j z z' : C) (J M M' : PO), z = affixe M -> z' = affixe M' -> j = affixe J -> M' = homothetie k J M :>PO -> Cplus z' (Copp j) = Cmult (Rinj k) (Cplus z (Copp j)). intros. cut (vec J M' = mult_PP k (vec J M)); intros. 2: apply homothetie_vecteur; auto. apply produit_vecteur_image with (3 := H3); auto with geo. Qed.HighSchoolGeometry/complexes_exercice.v0000644000076500007650000001315312073525614020266 0ustar coqcoq00000000000000(* This program is free software; you can redistribute it and/or *) (* modify it under the terms of the GNU Lesser General Public License *) (* as published by the Free Software Foundation; either version 2.1 *) (* of the License, or (at your option) any later version. *) (* *) (* This program is distributed in the hope that it will be useful, *) (* but WITHOUT ANY WARRANTY; without even the implied warranty of *) (* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *) (* GNU General Public License for more details. *) (* *) (* You should have received a copy of the GNU Lesser General Public *) (* License along with this program; if not, write to the Free *) (* Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA *) (* 02110-1301 USA *) Require Export complexes_similitudes. Set Implicit Arguments. Unset Strict Implicit. Definition isocele_rectangle_direct (A B C : PO) := A <> B /\ isocele A B C /\ cons_AV (vec A B) (vec A C) = image_angle pisurdeux. Lemma iso_rec_dir_distinct : forall A B C : PO, isocele_rectangle_direct A B C -> A <> C. unfold isocele_rectangle_direct, isocele in |- *; intros. elim H; [ intros H0 H1; elim H1; [ intros H2 H3; try clear H1 H; try exact H2 ] ]. apply isometrie_distinct with (2 := H2); auto. Qed. Hint Resolve iso_rec_dir_distinct: geo. Lemma iso_rec_dir_complexe : forall (a b c : C) (A B C : PO), a = affixe A -> b = affixe B -> c = affixe C -> isocele_rectangle_direct A B C -> Cplus c (Copp a) = Cmult i (Cplus b (Copp a)). unfold isocele_rectangle_direct, isocele in |- *; intros. elim H2; [ intros H3 H4; elim H4; [ intros H5 H6; try clear H4 H2; try exact H6 ] ]. rewrite forme_polaire_i. apply rotation_complexe with (J := A) (M := B) (M' := C); auto. apply rotation_def2; auto. Qed. Lemma complexe_iso_rec_dir : forall (a b c : C) (A B C : PO), a = affixe A -> b = affixe B -> c = affixe C -> A <> B -> Cplus c (Copp a) = Cmult i (Cplus b (Copp a)) -> isocele_rectangle_direct A B C. unfold isocele_rectangle_direct, isocele in |- *; intros. cut (distance A B = distance A C); intros. cut (A <> C); intros. split; [ try assumption | idtac ]. split; [ try assumption | idtac ]. cut (Cplus b (Copp a) <> zeroC); intros. cut (Cplus c (Copp a) <> zeroC); intros. rewrite (angle_vecteurs_arguments (A:=A) (B:=B) (A':=A) (B':=C) (z:=Cplus b (Copp a)) (z':=Cplus c (Copp a))); auto with geo. rewrite H3; rewrite forme_polaire_i; rewrite Cmult_argument; auto. rewrite argument_module_un. elim existence_argument with (z := Cplus b (Copp a)); [ intros; try clear existence_argument | auto ]. rewrite H8; repeat rewrite <- mes_opp. repeat rewrite <- add_mes_compatible. replace (pisurdeux + x + - x) with pisurdeux; [ auto | ring ]. auto with geo. apply diff_nonzero with (3 := H5); auto. apply diff_nonzero with (3 := H2); auto. apply isometrie_distinct with (2 := H4); auto. rewrite <- (module_difference H H0). rewrite <- (module_difference H H1). rewrite H3; rewrite forme_polaire_i; rewrite Cmult_module; rewrite complexe_polaire_module; ring. Qed. Lemma deux_iso_rec_dir_complexe : forall (a b c d e : C) (A B C D E : PO), a = affixe A -> b = affixe B -> c = affixe C -> d = affixe D -> e = affixe E -> isocele_rectangle_direct A B C -> isocele_rectangle_direct A D E -> Cplus e (Copp c) = Cmult i (Cplus d (Copp b)). intros. generalize (iso_rec_dir_complexe (a:=a) (b:=b) (c:=c) (A:=A) (B:=B) (C0:=C)); intros H11. generalize (iso_rec_dir_complexe (a:=a) (b:=d) (c:=e) (A:=A) (B:=D) (C0:=E)); intros H12. replace (Cplus e (Copp c)) with (Cplus (Cplus e (Copp a)) (Copp (Cplus c (Copp a)))); [ idtac | ring ]. rewrite H12; auto. rewrite H11; auto. replace (Cplus d (Copp b)) with (Cplus (Cplus d (Copp a)) (Copp (Cplus b (Copp a)))); ring. Qed. Theorem deux_isocele_rectangle_direct : forall A B C D E : PO, B <> D :>PO -> isocele_rectangle_direct A B C -> isocele_rectangle_direct A D E -> distance B D = distance C E /\ cons_AV (vec B D) (vec C E) = image_angle pisurdeux. intros. elim existence_affixe_point with (M := A); intros a; intros. elim existence_affixe_point with (M := B); intros b; intros. elim existence_affixe_point with (M := C); intros c; intros. elim existence_affixe_point with (M := D); intros d; intros. elim existence_affixe_point with (M := E); intros e; intros. cut (Cplus e (Copp c) = Cmult i (Cplus d (Copp b))); intros. cut (distance B D = distance C E); intros. cut (C <> E); intros. split; [ try assumption | idtac ]. cut (Cplus d (Copp b) <> zeroC); intros. cut (Cplus e (Copp c) <> zeroC); intros. rewrite (angle_vecteurs_arguments (A:=B) (B:=D) (A':=C) (B':=E) (z:=Cplus d (Copp b)) (z':=Cplus e (Copp c))); auto with geo. rewrite H7; rewrite forme_polaire_i; rewrite Cmult_argument; auto. rewrite argument_module_un. elim existence_argument with (z := Cplus d (Copp b)); [ intros; try clear existence_argument | auto ]. rewrite H12; repeat rewrite <- mes_opp. repeat rewrite <- add_mes_compatible. replace (pisurdeux + x + - x) with pisurdeux; [ auto | ring ]. auto with geo. apply diff_nonzero with (3 := H9); auto. apply diff_nonzero with (3 := H); auto. apply isometrie_distinct with (2 := H8); auto. rewrite <- (module_difference H3 H5). rewrite <- (module_difference H4 H6). rewrite H7; rewrite forme_polaire_i; rewrite Cmult_module; rewrite complexe_polaire_module; ring. apply (deux_iso_rec_dir_complexe (a:=a) (b:=b) (c:=c) (d:=d) (e:=e) (A:=A) (B:=B) (C0:=C) (D:=D) (E:=E)); auto. Qed.HighSchoolGeometry/complexes_inversion.v0000755000076500007650000004003112073525612020507 0ustar coqcoq00000000000000(* This program is free software; you can redistribute it and/or *) (* modify it under the terms of the GNU Lesser General Public License *) (* as published by the Free Software Foundation; either version 2.1 *) (* of the License, or (at your option) any later version. *) (* *) (* This program is distributed in the hope that it will be useful, *) (* but WITHOUT ANY WARRANTY; without even the implied warranty of *) (* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *) (* GNU General Public License for more details. *) (* *) (* You should have received a copy of the GNU Lesser General Public *) (* License along with this program; if not, write to the Free *) (* Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA *) (* 02110-1301 USA *) Require Export inversion. Require Export complexes_conjugaison. Require Export complexes_similitudes. Set Implicit Arguments. Unset Strict Implicit. (* a mettre plus haut dans les complexes*) Lemma Rinj_opp : forall k : R, Rinj (- k) = Copp (Rinj k). unfold Rinj in |- *; intros. rewrite Copp_algebrique. RReplace (-0) 0; auto. Qed. Lemma Conj_Copp : forall z : C, Conj (Copp z) = Copp (Conj z). intros. elim existence_parties_relles_imaginaires with (z := z); intros x1 H; elim H; intros y1 H0; try clear H; try exact H0. rewrite H0. rewrite Copp_algebrique. repeat rewrite Conj_algebrique. rewrite Copp_algebrique; auto. Qed. Lemma Copp_Cmult : forall z : C, Copp z = Cmult (Rinj (-1)) z. intros. replace (Rinj (-1)) with (Copp oneC). ring. unfold oneC, Rinj in |- *. rewrite Copp_algebrique; auto. RReplace (-0) 0; auto. Qed. Lemma Copp_non_zeroC : forall z : C, z <> zeroC -> Copp z <> zeroC. intros. rewrite Copp_Cmult. apply nonzero_produit; auto with geo. Qed. Hint Resolve Copp_non_zeroC nonzero_produit: geo. Lemma Cinv_Copp : forall z : C, z <> zeroC -> Cinv (Copp z) = Copp (Cinv z). intros. assert (Copp z <> zeroC); auto with geo. assert (Cmult (Copp z) (Copp (Cinv z)) = oneC). 2: apply Cinv_def2; auto. ring_simplify. apply Cinv_def; auto. Qed. Lemma carre_module : forall (z : C) (x y : R), z = cons_cart x y -> Rsqr (module z) = Rsqr x + Rsqr y. intros. rewrite (passage_algebrique_module H). rewrite Rsqr_sqrt; auto. assert (0 <= Rsqr x); auto with real. assert (0 <= Rsqr y); auto with real. fourier. Qed. Lemma produit_Conj_module : forall z : C, Cmult z (Conj z) = Rinj (Rsqr (module z)). intros. elim existence_parties_relles_imaginaires with (z := z); intros x H; elim H; intros y H0; try clear H; try exact H0. pattern z at 1 2 in |- *. rewrite H0. rewrite Conj_algebrique. rewrite (passage_algebrique_module H0). rewrite Cmult_algebrique. RReplace (y * x + x * - y) 0. rewrite Rsqr_sqrt. unfold Rsqr, Rinj in |- *. RReplace (x * x + - (y * - y)) (x * x + y * y); auto. assert (0 <= Rsqr x); auto with real. assert (0 <= Rsqr y); auto with real. fourier. Qed. Lemma Rinj_Cmult : forall x y : R, Rinj (x * y) = Cmult (Rinj x) (Rinj y). intros. unfold Rinj, oneC in |- *. rewrite Cmult_algebrique. RReplace (x * y + - (0 * 0)) (x * y). RReplace (0 * y + x * 0) 0; auto. Qed. Lemma Rinj_Cinv : forall k : R, k <> 0 -> Rinj (/ k) = Cinv (Rinj k). intros. assert (Rinj k <> zeroC); auto with geo. assert (Cmult (Rinj k) (Rinj (/ k)) = oneC). 2: symmetry in |- *; apply Cinv_def2; auto. unfold Rinj, oneC in |- *. rewrite Cmult_algebrique. replace (0 * / k + k * 0) with 0 by (field;auto). replace (k * / k + - (0 * 0)) with 1 by (field;auto). auto. Qed. Lemma Cinv_Cmult : forall z z' : C, z <> zeroC -> z' <> zeroC -> Cinv (Cmult z z') = Cmult (Cinv z) (Cinv z'). intros. assert (Cmult z z' <> zeroC); [ auto with geo | idtac ]. assert (Cmult (Cmult z z') (Cmult (Cinv z) (Cinv z')) = oneC). replace (Cmult (Cmult z z') (Cmult (Cinv z) (Cinv z'))) with (Cmult (Cmult z (Cinv z)) (Cmult z' (Cinv z'))); [ idtac | ring ]. rewrite Cinv_def; auto. rewrite Cinv_def; auto. ring. apply Cinv_def2; auto. Qed. Lemma Cinv_Conj : forall z : C, z <> zeroC -> Cinv z = Cmult (Cinv (Rinj (Rsqr (module z)))) (Conj z). intros. assert (module z <> 0); auto with geo. assert (Rsqr (module z) <> 0). unfold Rsqr in |- *; auto with real. assert (Rinj (Rsqr (module z)) <> zeroC); auto with geo. assert (Cmult z (Cmult (Cinv (Rinj (Rsqr (module z)))) (Conj z)) = oneC). 2: apply Cinv_def2; auto. replace (Cmult z (Cmult (Cinv (Rinj (Rsqr (module z)))) (Conj z))) with (Cmult (Cinv (Rinj (Rsqr (module z)))) (Cmult z (Conj z))). rewrite produit_Conj_module. apply Cinv_l; auto. ring. Qed. Lemma Conj_Cinv : forall z : C, z <> zeroC -> Cinv (Conj z) = Cmult (Cinv (Rinj (Rsqr (module z)))) z. intros. assert (Conj z <> zeroC); auto with geo. rewrite Cinv_Conj; auto. rewrite Conj_Conj; rewrite module_Conj; auto. Qed. Lemma Cmult_Rinj_algebrique : forall x y k : R, Cmult (Rinj k) (cons_cart x y) = cons_cart (k * x) (k * y). unfold Rinj in |- *; intros. rewrite Cmult_algebrique. replace (k * x + - (0 * y)) with (k * x) by ring. replace (0 * x + k * y) with (k * y) by ring. auto. Qed. Lemma Cinv_algebrique : forall (z : C) (x y : R), z <> zeroC -> z = cons_cart x y -> Cinv z = cons_cart (x / (Rsqr x + Rsqr y)) (- y / (Rsqr x + Rsqr y)). intros. assert (module z <> 0); auto with geo. assert (Rsqr (module z) <> 0). unfold Rsqr in |- *; auto with real. rewrite Cinv_Conj; auto. rewrite (Conj_def H0); auto. rewrite <- Rinj_Cinv; auto. rewrite Cmult_Rinj_algebrique. rewrite (carre_module H0); auto. unfold Rdiv in |- *. RReplace (/ (Rsqr x + Rsqr y) * x) (x * / (Rsqr x + Rsqr y)). RReplace (/ (Rsqr x + Rsqr y) * - y) (- y * / (Rsqr x + Rsqr y)); auto. Qed. (* partie concernant l'inversion *) Lemma inversion_origine_module : forall (k : R) (z z' : C) (M M' : PO), k <> 0 -> O <> M -> z = affixe_vec (vec O M) -> z' = affixe_vec (vec O M') -> M' = inversion O k M :>PO -> module z' = Rabs k * / module z. intros. assert (vec O M' = mult_PP (/ Rsqr (distance O M) * k) (vec O M)). apply inversion_pole_vecteur; auto. assert (module z <> 0). apply module_non_zero. apply points_distincts_non_zeroC with (1 := H0); auto with geo. RReplace (/ module z) (1 * / module z). RReplace 1 (/ module z * module z). RReplace (/ module z * module z * / module z) (/ module z * / module z * module z). replace (/ module z * / module z) with (/ Rsqr (module z)). pattern (module z) at 1 in |- *. rewrite (module_def2 (z:=z) (M:=M)); auto with geo. RReplace (Rabs k * (/ Rsqr (distance O M) * module z)) (/ Rsqr (distance O M) * Rabs k * module z). replace (/ Rsqr (distance O M) * Rabs k) with (Rabs (/ Rsqr (distance O M) * k)). apply (module_affixe_produit_vecteur_OM (k:=/ Rsqr (distance O M) * k) (M:=M) (M':=M') (z:=z) (z':=z')); auto with geo. rewrite Rabs_mult. rewrite <- (module_def2 (z:=z) (M:=M)); auto with geo. unfold Rsqr in |- *. rewrite Rabs_Rinv; auto with real. rewrite Rabs_right; auto with geo real. unfold Rsqr in |- *. rewrite Rinv_mult_distr; auto with real. Qed. Lemma aux_positif : forall (k : R) (M : PO), O <> M :>PO -> k > 0 -> / Rsqr (distance O M) * k > 0. intros. apply Rmult_gt_0_compat; auto. apply Rgt_inv; auto. unfold Rsqr in |- *. assert (distance O M > 0). assert (distance O M >= 0); auto with geo. elim H1; intros; auto. absurd (distance O M = 0); auto with geo. apply Rmult_gt_0_compat; auto. Qed. Lemma aux_negatif : forall (k : R) (M : PO), O <> M :>PO -> k < 0 -> / Rsqr (distance O M) * k < 0. intros. RReplace (/ Rsqr (distance O M) * k) (- (/ Rsqr (distance O M) * - k)). apply Ropp_lt_gt_0_contravar. apply aux_positif; auto with real. Qed. Lemma argument_affixe_inversion_pole_positif : forall (k : R) (M M' : PO) (z z' : C), O <> M :>PO -> k > 0 -> z = affixe_vec (vec O M) :>C -> z' = affixe_vec (vec O M') :>C -> M' = inversion O k M :>PO -> argument z' = argument z :>AV. intros. assert (vec O M' = mult_PP (/ Rsqr (distance O M) * k) (vec O M)). apply inversion_pole_vecteur; auto. auto with real. apply argument_affixe_produit_positif_vecteur_OM with (3 := H4); auto. apply aux_positif; auto. Qed. Lemma argument_affixe_inversion_pole_negatif : forall (k : R) (M M' : PO) (z z' : C), O <> M :>PO -> k < 0 -> z = affixe_vec (vec O M) :>C -> z' = affixe_vec (vec O M') :>C -> M' = inversion O k M :>PO -> argument z' = plus (argument z) (image_angle pi) :>AV. intros. assert (vec O M' = mult_PP (/ Rsqr (distance O M) * k) (vec O M)). apply inversion_pole_vecteur; auto. auto with real. apply argument_affixe_produit_negatif_vecteur_OM with (3 := H4); auto. apply aux_negatif; auto. Qed. Lemma argument_affixe_inversion_positif_conjugue : forall (k : R) (M M' : PO) (z z' : C), O <> M :>PO -> k > 0 -> z = affixe_vec (vec O M) :>C -> z' = affixe_vec (vec O M') :>C -> M' = inversion O k M :>PO -> argument z' = argument (Cinv (Conj z)) :>AV. intros. assert (z <> zeroC). apply points_distincts_non_zeroC with (1 := H); auto with geo. assert (Conj z <> zeroC); auto with geo. rewrite (argument_affixe_inversion_pole_positif (k:=k) (M:=M) (M':=M') (z:=z) (z':=z')); auto. rewrite Cinv_argument; auto. rewrite argument_Conj2; auto. mes (argument z). RReplace (- - x) x; auto. Qed. Theorem inversion_positif_complexe : forall (k : R) (z z' : C) (M M' : PO), O <> M :>PO -> k > 0 -> z = affixe_vec (vec O M) :>C -> z' = affixe_vec (vec O M') :>C -> M' = inversion O k M :>PO -> z' = Cmult (Rinj k) (Cinv (Conj z)). intros. assert (k <> 0); auto with real. assert (z <> zeroC). apply points_distincts_non_zeroC with (1 := H); auto with geo. assert (Conj z <> zeroC); auto with geo. assert (O <> M'). apply image_distinct_pole with (3 := H3); auto with real. apply egalite_forme_polaire. apply points_distincts_non_zeroC with (1 := H7); auto with geo. apply nonzero_produit; auto with geo. rewrite (inversion_origine_module (k:=k) (z:=z) (z':=z') (M:=M) (M':=M')); auto. rewrite <- (module_Conj z). rewrite Cmult_module; auto. rewrite Cinv_module; auto. rewrite module_reel; auto. rewrite (argument_affixe_inversion_positif_conjugue (k:=k) (M:=M) (M':=M') (z:=z) (z':=z')); auto. rewrite Cmult_argument; auto with geo. rewrite argument_reel_pos; auto with real. mes (argument (Cinv (Conj z))). RReplace (0 + x) x; auto. Qed. Theorem inversion_negatif_complexe : forall (k : R) (z z' : C) (M M' : PO), O <> M :>PO -> k < 0 -> z = affixe_vec (vec O M) :>C -> z' = affixe_vec (vec O M') :>C -> M' = inversion O k M :>PO -> z' = Cmult (Rinj k) (Cinv (Conj z)). intros. assert (k <> 0); auto with real. assert (z <> zeroC). apply points_distincts_non_zeroC with (1 := H); auto with geo. assert (Conj z <> zeroC); auto with geo. symetrique O M ipattern:N. assert (M' = inversion O (- k) N). apply inversion_oppose_puissance with (3 := H3); auto. assert (- k > 0); auto with real. assert (O <> N). assert (O = homothetie (-1) O O); auto with geo. unfold symetrie in H5. apply (image_homothetie_distincts (k:=-1) (I:=O) (A:=O) (A':=O) (B:=M) (B':=N)); auto with real. rewrite (inversion_positif_complexe (k:=- k) (z:=Copp z) (z':=z') (M:=N) (M':=M')) ; auto. rewrite Rinj_opp. rewrite Conj_Copp. rewrite Cinv_Copp; auto. ring. symmetry in |- *. rewrite (produit_vecteur_image (k:=-1) (z:=z) (z':=affixe_vec (vec O N)) (A:=O) (B:=M) (A':=O) (B':=N)); auto. replace (Rinj (-1)) with (Copp oneC). ring. unfold oneC, Rinj in |- *. rewrite Copp_algebrique; auto. RReplace (-0) 0; auto. VReplace (mult_PP (-1) (vec O M)) (vec M O). rewrite (milieu_vecteur H8); auto. Qed. Theorem inversion_pole_origine_complexe : forall (k : R) (z z' : C) (M M' : PO), O <> M :>PO -> k <> 0 -> z = affixe_vec (vec O M) :>C -> z' = affixe_vec (vec O M') :>C -> M' = inversion O k M :>PO -> z' = Cmult (Rinj k) (Cinv (Conj z)). intros. elim Rtotal_order with (r1 := k) (r2 := 0); [ intros H4; try clear total_order | intros H4; elim H4; [ intros H5; try clear H4 total_order; try exact H5 | intros H5; try clear H4 total_order ] ]. rewrite (inversion_negatif_complexe (k:=k) (z:=z) (z':=z') (M:=M) (M':=M')); auto. absurd (k = 0); auto. rewrite (inversion_positif_complexe (k:=k) (z:=z) (z':=z') (M:=M) (M':=M')); auto. Qed. Theorem complexe_inversion_pole_origine : forall (k : R) (z z' : C) (M M' : PO), O <> M :>PO -> k <> 0 -> z = affixe_vec (vec O M) :>C -> z' = affixe_vec (vec O M') :>C -> z' = Cmult (Rinj k) (Cinv (Conj z)) -> M' = inversion O k M :>PO. intros. apply homothetie_inversion; auto. apply vecteur_homothetie; auto. apply (produit_reel_affixe_vecteur_OM (k:=/ Rsqr (distance O M) * k) (z:=z) (z':=z') (M:=M) (M':=M')); auto. rewrite H3. rewrite Rinj_Cmult. assert (z <> zeroC). apply points_distincts_non_zeroC with (1 := H); auto with geo. assert (Conj z <> zeroC); auto with geo. rewrite <- (module_def2 (z:=z) (M:=M)); auto with geo. rewrite Rinj_Cinv. rewrite <- produit_Conj_module. rewrite Cinv_Cmult; auto. replace (Cmult (Cmult (Cmult (Cinv z) (Cinv (Conj z))) (Rinj k)) z) with (Cmult (Cmult z (Cinv z)) (Cmult (Cinv (Conj z)) (Rinj k))). 2: ring. rewrite Cinv_def; auto. ring. unfold Rsqr in |- *. assert (module z <> 0); auto with geo. auto with real. Qed. Theorem ecriture_complexe_inversion_pole_origine : forall (k : R) (z z' : C) (M M' : PO), O <> M -> k <> 0 -> z = affixe M -> z' = affixe M' -> (M' = inversion O k M <-> z' = Cmult (Rinj k) (Cinv (Conj z))). intros; red in |- *; try split; intros. apply (inversion_pole_origine_complexe (k:=k) (z:=z) (z':=z') (M:=M) (M':=M')); auto with geo. apply (complexe_inversion_pole_origine (k:=k) (z:=z) (z':=z') (M:=M) (M':=M')); auto with geo. Qed. Theorem inversion_complexe : forall (k : R) (j z z' : C) (J M M' : PO), J <> M -> k <> 0 -> z = affixe M -> z' = affixe M' -> j = affixe J -> M' = inversion J k M -> Cplus z' (Copp j) = Cmult (Rinj k) (Cinv (Conj (Cplus z (Copp j)))). intros. elim existence_representant_vecteur with (A := O) (B := J) (C := M); intros N; intros. elim existence_representant_vecteur with (A := O) (B := J) (C := M'); intros N'; intros. assert (O <> N). apply distinct_egalite_vecteur with (2 := H5); auto. assert (vec J M' = mult_PP (/ Rsqr (distance J M) * k) (vec J M)). apply homothetie_vecteur. apply inversion_homothetie; auto. generalize H8. replace (Rsqr (distance J M)) with (Rsqr (distance O N)). rewrite <- H6; rewrite <- H5; intros. assert (N' = inversion O k N). apply homothetie_inversion; auto. apply vecteur_homothetie; auto. rewrite (affixe_vec_AB H3 H2). rewrite (affixe_vec_AB H3 H1). rewrite <- H6; rewrite <- H5. elim existence_affixe_vecteur_point with (M := N); intros z1; intros. elim existence_affixe_vecteur_point with (M := N'); intros z2; intros. rewrite <- H12; rewrite <- H11. apply inversion_pole_origine_complexe with (5 := H10); auto. unfold Rsqr in |- *. repeat rewrite <- carre_scalaire_distance. rewrite H5; auto. Qed. Theorem complexe_inversion : forall (k : R) (j z z' : C) (J M M' : PO), J <> M -> k <> 0 -> z = affixe M -> z' = affixe M' -> j = affixe J -> Cplus z' (Copp j) = Cmult (Rinj k) (Cinv (Conj (Cplus z (Copp j)))) -> M' = inversion J k M. intros. elim existence_representant_vecteur with (A := O) (B := J) (C := M); intros N; intros. elim existence_representant_vecteur with (A := O) (B := J) (C := M'); intros N'; intros. assert (O <> N). apply distinct_egalite_vecteur with (2 := H5); auto. apply homothetie_inversion; auto. apply vecteur_homothetie. rewrite <- H6; rewrite <- H5. replace (Rsqr (distance J M)) with (Rsqr (distance O N)). assert (N' = inversion O k N). apply complexe_inversion_pole_origine with (5 := H4); auto. rewrite H5; auto with geo. rewrite H6; auto with geo. apply homothetie_vecteur. apply inversion_homothetie; auto. unfold Rsqr in |- *. repeat rewrite <- carre_scalaire_distance. rewrite H5; auto. Qed. Theorem ecriture_complexe_inversion : forall (k : R) (j z z' : C) (J M M' : PO), J <> M -> k <> 0 -> z = affixe M -> z' = affixe M' -> j = affixe J -> (M' = inversion J k M <-> Cplus z' (Copp j) = Cmult (Rinj k) (Cinv (Conj (Cplus z (Copp j))))). intros; red in |- *; try split; intros. apply (inversion_complexe (k:=k) (j:=j) (z:=z) (z':=z') (J:=J) (M:=M) (M':=M')); auto. apply (complexe_inversion (k:=k) (j:=j) (z:=z) (z':=z') (J:=J) (M:=M) (M':=M')); auto. Qed. HighSchoolGeometry/complexes_similitudes.v0000644000076500007650000002704412073525613021035 0ustar coqcoq00000000000000(* This program is free software; you can redistribute it and/or *) (* modify it under the terms of the GNU Lesser General Public License *) (* as published by the Free Software Foundation; either version 2.1 *) (* of the License, or (at your option) any later version. *) (* *) (* This program is distributed in the hope that it will be useful, *) (* but WITHOUT ANY WARRANTY; without even the implied warranty of *) (* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *) (* GNU General Public License for more details. *) (* *) (* You should have received a copy of the GNU Lesser General Public *) (* License along with this program; if not, write to the Free *) (* Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA *) (* 02110-1301 USA *) Require Export similitudes_directes. Require Export complexes_dilatations. Set Implicit Arguments. Unset Strict Implicit. Lemma isometrie_egalite_module : forall (A B A' B' : PO) (z z' : C), distance A' B' = distance A B -> z = affixe_vec (vec A B) -> z' = affixe_vec (vec A' B') -> module z' = module z. intros A B A' B' z z'; try assumption. elim existence_representant_vecteur with (A := O) (B := A) (C := B); intros M; intros H1. elim existence_representant_vecteur with (A := O) (B := A') (C := B'); intros M'; intros H2. rewrite <- H2; rewrite <- H1; intros. rewrite (module_def2 (z:=z) (M:=M)); auto with geo. rewrite (module_def2 (z:=z') (M:=M')); auto with geo. rewrite (egalite_vecteur_distance (A:=O) (B:=M') (C:=A') (D:=B')); auto with geo. rewrite H; auto with geo. Qed. Lemma angle_vecteurs_arguments : forall (A B A' B' : PO) (z z' : C), A <> B -> A' <> B' -> z = affixe_vec (vec A B) -> z' = affixe_vec (vec A' B') -> cons_AV (vec A B) (vec A' B') = plus (argument z') (opp (argument z)). intros A B A' B' z z'; try assumption. elim existence_representant_vecteur with (A := O) (B := A) (C := B); intros M; intros H1. elim existence_representant_vecteur with (A := O) (B := A') (C := B'); intros M'; intros H2. rewrite <- H2; rewrite <- H1; intros. apply angle_argument; auto with geo. apply distinct_egalite_vecteur with (2 := H1); auto. apply distinct_egalite_vecteur with (2 := H2); auto. Qed. Theorem complexe_rotation_centre_origine : forall (a : R) (z z' : C) (M M' : PO), z = affixe M -> z' = affixe M' -> z' = Cmult (cons_pol 1 a) z -> M' = rotation O a M. intros. cut (module z' = module z); intros. discrimine O M. cut (z = zeroC); intros. replace M with M'. rewrite <- rotation_def_centre; auto. apply (egalite_affixe_point (z:=z') (z':=z) (M:=M') (M':=M)); auto. rewrite H1; rewrite H4; ring. apply (egalite_point_image (z:=z) (z':=zeroC) (M:=M) (M':=O)); auto with geo. apply rotation_def2; auto. rewrite <- (module_def2 (z:=z) (M:=M)); auto. rewrite <- (module_def2 (z:=z') (M:=M')); auto. cut (z <> zeroC); intros; [ idtac | eauto with geo ]. cut (z' <> zeroC); intros. cut (O <> M'); intros; [ idtac | eauto with geo ]. rewrite (angle_argument (z:=z) (z':=z') (M:=M) (M':=M')); auto with geo. rewrite H1; rewrite Cmult_argument; auto with geo. rewrite argument_module_un. elim existence_argument with (z := z); [ intros; try clear existence_argument | auto with geo ]. rewrite H7. rewrite <- mes_opp; auto. repeat rewrite <- add_mes_compatible. replace (a + x + - x) with a; [ auto | ring ]. apply nonzero_module. rewrite H2; auto with geo. rewrite H1; rewrite Cmult_module; rewrite module_un_trivial; ring. Qed. Lemma nonzero_diff : forall (a b : C) (A B : PO), a = affixe A -> b = affixe B -> Cplus b (Copp a) <> zeroC -> A <> B. intros. red in |- *; intros; apply H1. rewrite (affixe_vec_AB (a:=a) (b:=b) (A:=A) (B:=B)); auto. rewrite affixe_vec_AB_affixes; rewrite H2; ring. Qed. Hint Resolve nonzero_diff: geo. Theorem complexe_rotation : forall (a : R) (j z z' : C) (J M M' : PO), z = affixe M -> z' = affixe M' -> j = affixe J -> Cplus z' (Copp j) = Cmult (cons_pol 1 a) (Cplus z (Copp j)) -> M' = rotation J a M. intros. cut (module (Cplus z' (Copp j)) = module (Cplus z (Copp j))); intros. discrimine J M. cut (Cplus z (Copp j) = zeroC); intros. replace M with M'. rewrite <- rotation_def_centre; auto. apply egalite_vecteur_point with J. apply (egalite_affixe_vecteur (z:=Cplus z' (Copp j)) (z':= Cplus z (Copp j)) (A:=J) (B:=M') (A':=J) (B':=M)); auto with geo. rewrite H2; rewrite H5; ring. apply (egalite_point_zeroC (z:=Cplus z (Copp j)) (A:=J) (B:=M)); auto with geo. apply rotation_def2; auto. rewrite <- (module_difference (a:=j) (b:=z) (A:=J) (B:=M)); auto. rewrite <- (module_difference (a:=j) (b:=z') (A:=J) (B:=M')); auto. cut (Cplus z (Copp j) <> zeroC); intros; [ idtac | eauto with geo ]. cut (Cplus z' (Copp j) <> zeroC); intros. cut (J <> M'); intros. rewrite (angle_vecteurs_arguments (A:=J) (B:=M) (A':=J) (B':=M') (z:=Cplus z (Copp j)) (z':=Cplus z' (Copp j))); auto with geo. rewrite H2; rewrite Cmult_argument; auto with geo. rewrite argument_module_un. elim existence_argument with (z := Cplus z (Copp j)); [ intros; try clear existence_argument | auto ]. rewrite H8; repeat rewrite <- mes_opp. repeat rewrite <- add_mes_compatible. replace (a + x + - x) with a; [ auto | ring ]. eauto with geo. apply nonzero_module. rewrite H3; auto with geo. rewrite H2; rewrite Cmult_module; rewrite module_un_trivial; ring. Qed. Theorem rotation_centre_origine_complexe : forall (a : R) (z z' : C) (M M' : PO), z = affixe M -> z' = affixe M' -> M' = rotation O a M -> z' = Cmult (cons_pol 1 a) z. intros a z z' M M'; try assumption. discrimine M O. intros. rewrite H1; rewrite H2; rewrite <- rotation_def_centre; rewrite H0; rewrite <- affixe_origine; ring. intros. cut (O <> M); intros. elim rotation_def with (I := O) (A := M) (B := M') (a := a); [ intros | auto | auto ]. cut (O <> M'); intros. cut (z <> zeroC); intros. cut (z' <> zeroC); intros. cut (module z' = module z); intros. apply egalite_forme_polaire; auto with geo. rewrite H9; rewrite Cmult_module; rewrite module_un_trivial; ring. rewrite Cmult_argument; auto with geo. rewrite argument_module_un; rewrite H5. rewrite (angle_argument (z:=z) (z':=z') (M:=M) (M':=M')); auto with geo. elim existence_argument with (z := z); [ intros; try clear existence_argument | auto ]. elim existence_argument with (z := z'); [ intros; try clear existence_argument | auto ]. rewrite H10; rewrite <- mes_opp. rewrite H11; repeat rewrite <- add_mes_compatible. replace (x0 + - x + x) with x0; [ auto | ring ]. rewrite (module_def2 (z:=z) (M:=M)); auto. rewrite (module_def2 (z:=z') (M:=M')); auto. eauto with geo. eauto with geo. apply isometrie_distinct with (1 := H3); auto. auto. Qed. Theorem rotation_complexe : forall (a : R) (j z z' : C) (J M M' : PO), z = affixe M -> z' = affixe M' -> j = affixe J -> M' = rotation J a M -> Cplus z' (Copp j) = Cmult (cons_pol 1 a) (Cplus z (Copp j)). intros a j z z' J M M'; try assumption. discrimine M J. intros. rewrite H1; rewrite H3; rewrite <- rotation_def_centre; rewrite H0; rewrite H2; ring. intros. cut (J <> M); intros. elim rotation_def with (I := J) (A := M) (B := M') (a := a); [ intros | auto | auto ]. cut (J <> M'); intros. cut (Cplus z (Copp j) <> zeroC); intros. cut (Cplus z' (Copp j) <> zeroC); intros. cut (module (Cplus z' (Copp j)) = module (Cplus z (Copp j))); intros. apply egalite_forme_polaire; auto with geo. rewrite H10; rewrite Cmult_module; rewrite module_un_trivial; ring. rewrite Cmult_argument; auto with geo. rewrite argument_module_un; rewrite H6. rewrite (angle_vecteurs_arguments (A:=J) (B:=M) (A':=J) (B':=M') (z:=Cplus z (Copp j)) (z':=Cplus z' (Copp j))); auto with geo. elim existence_argument with (z := Cplus z (Copp j)); [ intros; try clear existence_argument | auto ]. elim existence_argument with (z := Cplus z' (Copp j)); [ intros; try clear existence_argument | auto ]. rewrite H11; repeat rewrite <- mes_opp. rewrite H12; repeat rewrite <- add_mes_compatible. replace (x0 + - x + x) with x0; [ auto | ring ]. rewrite (module_difference (a:=j) (b:=z) (A:=J) (B:=M)); auto. rewrite (module_difference (a:=j) (b:=z') (A:=J) (B:=M')); auto. eauto with geo. eauto with geo. apply isometrie_distinct with (1 := H4); auto. auto. Qed. Theorem similitude_complexe : forall (k a : R) (j z z' : C) (J M M' : PO), k > 0 -> z = affixe M -> z' = affixe M' -> j = affixe J -> M' = similitude J k a M -> Cplus z' (Copp j) = Cmult (cons_pol k a) (Cplus z (Copp j)). intros k a j z z' J M M' H; try assumption. discrimine M J. intros. rewrite H2; rewrite H4; rewrite <- similitude_def_centre; auto; rewrite H1; rewrite H3; ring. intros. cut (J <> M); intros. elim similitude_def with (I := J) (A := M) (B := M') (k := k) (a := a); [ intros | auto | auto | auto ]. cut (J <> M'); intros. cut (Cplus z (Copp j) <> zeroC); intros. cut (Cplus z' (Copp j) <> zeroC); intros. cut (module (Cplus z' (Copp j)) = k * module (Cplus z (Copp j))); intros. cut (cons_pol k a <> zeroC); intros; auto with real geo. apply egalite_forme_polaire; auto with geo. rewrite H11; rewrite Cmult_module; rewrite complexe_polaire_module; ring. rewrite Cmult_argument; auto with geo. rewrite complexe_polaire_argument; auto with real geo. rewrite H7. rewrite (angle_vecteurs_arguments (A:=J) (B:=M) (A':=J) (B':=M') (z:=Cplus z (Copp j)) (z':=Cplus z' (Copp j))); auto with geo. elim existence_argument with (z := Cplus z (Copp j)); [ intros; try clear existence_argument | auto ]. elim existence_argument with (z := Cplus z' (Copp j)); [ intros; try clear existence_argument | auto ]. rewrite H13; rewrite H14; repeat rewrite <- mes_opp; repeat rewrite <- add_mes_compatible. replace (x0 + - x + x) with x0; [ auto | ring ]. rewrite (module_difference (a:=j) (b:=z) (A:=J) (B:=M)); auto. rewrite (module_difference (a:=j) (b:=z') (A:=J) (B:=M')); auto. eauto with geo. eauto with geo. apply image_sim_distinct_centre with (3 := H4); auto. auto. Qed. Theorem complexe_similitude : forall (k a : R) (j z z' : C) (J M M' : PO), k > 0 -> z = affixe M -> z' = affixe M' -> j = affixe J -> Cplus z' (Copp j) = Cmult (cons_pol k a) (Cplus z (Copp j)) -> M' = similitude J k a M. intros. cut (module (Cplus z' (Copp j)) = k * module (Cplus z (Copp j))); intros. discrimine J M. cut (Cplus z (Copp j) = zeroC); intros. replace M with M'. rewrite <- similitude_def_centre; auto. apply egalite_vecteur_point with J. apply (egalite_affixe_vecteur (z:=Cplus z' (Copp j)) (z':= Cplus z (Copp j)) (A:=J) (B:=M') (A':=J) (B':=M)); auto with geo. rewrite H3; rewrite H6; ring. apply (egalite_point_zeroC (z:=Cplus z (Copp j)) (A:=J) (B:=M)); auto with geo. apply similitude_def2; auto. rewrite <- (module_difference (a:=j) (b:=z) (A:=J) (B:=M)); auto. rewrite <- (module_difference (a:=j) (b:=z') (A:=J) (B:=M')); auto. cut (Cplus z (Copp j) <> zeroC); intros; [ idtac | eauto with geo ]. cut (Cplus z' (Copp j) <> zeroC); intros. cut (J <> M'); intros. rewrite (angle_vecteurs_arguments (A:=J) (B:=M) (A':=J) (B':=M') (z:=Cplus z (Copp j)) (z':=Cplus z' (Copp j))); auto with geo. rewrite H3; rewrite Cmult_argument; auto with geo. rewrite complexe_polaire_argument; auto with real geo. elim existence_argument with (z := Cplus z (Copp j)); [ intros; try clear existence_argument | auto ]. rewrite H9; repeat rewrite <- mes_opp; repeat rewrite <- add_mes_compatible. replace (a + x + - x) with a; [ auto | ring ]. auto with real geo. eauto with geo. apply nonzero_module. rewrite H4; apply Rmult_integral_contrapositive; split; auto with real geo. rewrite H3; rewrite Cmult_module; rewrite complexe_polaire_module; ring. Qed.HighSchoolGeometry/complexes_transformations.v0000644000076500007650000002353512117747636021746 0ustar coqcoq00000000000000(* This program is free software; you can redistribute it and/or *) (* modify it under the terms of the GNU Lesser General Public License *) (* as published by the Free Software Foundation; either version 2.1 *) (* of the License, or (at your option) any later version. *) (* *) (* This program is distributed in the hope that it will be useful, *) (* but WITHOUT ANY WARRANTY; without even the implied warranty of *) (* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *) (* GNU General Public License for more details. *) (* *) (* You should have received a copy of the GNU Lesser General Public *) (* License along with this program; if not, write to the Free *) (* Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA *) (* 02110-1301 USA *) Require Export complexes_similitudes. Set Implicit Arguments. Unset Strict Implicit. Lemma equation_equiv : forall a b z : C, z = Cplus (Cmult a z) b -> Cmult (Cplus oneC (Copp a)) z = b. intros. replace b with (Cplus z (Copp (Cmult a z))). ring. pattern z at 1 in |- *. rewrite H; ring. Qed. Lemma equation_equiv2 : forall a b z : C, Cmult (Cplus oneC (Copp a)) z = b -> z = Cplus (Cmult a z) b. intros. rewrite <- H; ring. Qed. Lemma nonzero_amoins_un : forall a : C, a <> oneC -> Cplus oneC (Copp a) <> zeroC. intros. red in |- *; intros; apply H. replace a with (Cplus a zeroC); [ idtac | ring ]. rewrite <- H0; ring. Qed. Hint Resolve nonzero_amoins_un: geo. Lemma existence_solution_equation : forall a b : C, a <> oneC -> exists z : C, z = Cplus (Cmult a z) b. intros. cut (Cplus oneC (Copp a) <> zeroC); intros; auto with geo. cut (exists z : C, Cmult (Cplus oneC (Copp a)) z = b); intros. elim H1; intros z H2; try clear H1; try exact H2. exists z. apply equation_equiv2; auto. exists (Cmult (Cinv (Cplus oneC (Copp a))) b). replace (Cmult (Cplus oneC (Copp a)) (Cmult (Cinv (Cplus oneC (Copp a))) b)) with (Cmult (Cmult (Cplus oneC (Copp a)) (Cinv (Cplus oneC (Copp a)))) b); [ idtac | ring ]. rewrite Cinv_def; auto. ring. Qed. Lemma unicite_solution_equation : forall a b z z' : C, a <> oneC -> z = Cplus (Cmult a z) b -> z' = Cplus (Cmult a z') b -> z = z'. intros. cut (Cplus z (Copp z') = zeroC); intros. replace z with (Cplus (Cplus z (Copp z')) z'); [ idtac | ring ]. rewrite H2; ring. apply Cintegre with (z := Cplus oneC (Copp a)); auto with geo. cut (Cmult (Cplus oneC (Copp a)) z = b); intros. 2: apply equation_equiv; auto. cut (Cmult (Cplus oneC (Copp a)) z' = b); intros. 2: apply equation_equiv; auto. replace zeroC with (Cplus b (Copp b)); [ idtac | ring ]. pattern b at 1 in |- *. rewrite <- H2. rewrite <- H3; ring. Qed. Lemma existence_point_fixe_complexe : forall (a b : C) (f : C -> C), a <> oneC -> (forall z : C, f z = Cplus (Cmult a z) b) -> exists j : C, f j = j. intros. elim existence_solution_equation with (a := a) (b := b); [ intros z0 H1; try clear existence_solution_equation; try exact H1 | auto ]. exists z0. rewrite (H0 z0). rewrite <- H1; auto. Qed. Parameter transforme : (C -> C) -> PO -> PO. Axiom transforme_def : forall (f : C -> C) (M : PO), transforme f M = image (f (affixe M)). Lemma image_affixe : forall M : PO, image (affixe M) = M. intros. elim existence_affixe_point with (M := M); intros z H; try clear existence_affixe_point; try exact H. rewrite <- H; symmetry in |- *; auto with geo. Qed. Lemma affixe_image : forall z : C, affixe (image z) = z. intros. elim existence_image_complexe with (z := z); intros M H; try clear existence_image_complexe; try exact H. rewrite <- H; symmetry in |- *; auto with geo. Qed. Hint Resolve image_affixe affixe_image: geo. Lemma transforme_image : forall (f : C -> C) (z : C), transforme f (image z) = image (f z). intros. rewrite transforme_def; rewrite affixe_image; auto. Qed. Lemma affixe_transforme : forall (f : C -> C) (M : PO), affixe (transforme f M) = f (affixe M). intros. rewrite transforme_def; auto with geo. Qed. Lemma f_fonction_transforme : forall (f : C -> C) (z : C), f z = affixe (transforme f (image z)). intros. rewrite affixe_transforme; rewrite affixe_image; auto with geo. Qed. Parameters (a : C) (b : C). Parameter f : C -> C. Hypothesis f_def : forall z : C, f z = Cplus (Cmult a z) b. Parameter g : PO -> PO. Hypothesis g_def : forall M : PO, g M = transforme f M. Lemma explicitation : forall (z z' : C) (M M' : PO), z = affixe M -> z' = affixe M' -> M' = g M -> z' = Cplus (Cmult a z) b. intros. rewrite H0; rewrite H1; rewrite g_def. rewrite affixe_transforme; rewrite <- H; rewrite f_def; auto. Qed. Lemma existence_point_fixe_g : a <> oneC -> exists J : PO, g J = J. intros. elim existence_point_fixe_complexe with (a := a) (b := b) (f := f); [ intros j H0; try clear existence_point_fixe_complexe; try exact H0 | auto | auto ]. exists (image j). rewrite g_def; rewrite transforme_image; rewrite H0; auto. try exact f_def. Qed. Lemma equation_solution : forall z z' j : C, z' = f z -> f j = j -> Cplus z' (Copp j) = Cmult a (Cplus z (Copp j)). intros z z' j; try assumption. repeat rewrite f_def; intros. rewrite H. pattern j at 1 in |- *. rewrite <- H0; ring. Qed. Lemma point_fixe_gf : forall M : PO, g M = M -> f (affixe M) = affixe M. intros M; try assumption. repeat rewrite g_def; intros. pattern M at 2 in |- *. rewrite <- H. rewrite affixe_transforme; auto. Qed. Lemma un_module_a_rotation : forall x : R, a <> oneC -> a = cons_pol 1 x -> exists J : PO, (forall M : PO, g M = rotation J x M). intros. elim existence_point_fixe_g; [ intros J H1; try clear existence_point_fixe_g; try exact H1 | auto ]. exists J; intros. elim existence_affixe_point with (M := M); intros z H2; try clear existence_affixe_point; try exact H2. elim existence_affixe_point with (M := g M); intros z'; intros; try exact H2. apply (complexe_rotation (a:=x) (j:=affixe J) (z:=z) (z':=z') (J:=J) (M:=M) (M':=g M)); auto. rewrite <- H0. cut (f (affixe J) = affixe J); intros. apply (equation_solution (z:=z) (z':=z') (j:=affixe J)); auto with geo. rewrite H3; rewrite g_def; rewrite H2; rewrite affixe_transforme; auto. apply point_fixe_gf; auto. Qed. Lemma a_oneC_translation : a = oneC -> exists A : PO, (forall M : PO, g M = translation O A M). intros. elim existence_image_complexe with (z := b); intros A H1; try clear existence_image_complexe; try exact H1. exists A; intros. elim existence_affixe_point with (M := M); intros z H2; try clear existence_affixe_point; try exact H2. elim existence_affixe_point with (M := g M); intros z'; intros; try exact H2. apply (complexe_translation (a:=b) (z:=z) (z':=z') (A:=A) (M:=M) (M':=g M)); auto with geo. rewrite H0; rewrite g_def; rewrite H2; rewrite affixe_transforme; rewrite f_def; rewrite H; ring. Qed. Lemma un_module_a_deplacement : module a = 1 -> (exists A : PO, (forall M : PO, g M = translation O A M)) \/ (exists J : PO, (exists x : R, (forall M : PO, g M = rotation J x M))). intros. elim (classic (a = oneC)); intros. left; try assumption. apply a_oneC_translation; auto. right; try assumption. cut (a <> zeroC). intros H20. elim existence_forme_polaire with (z := a); [ intros r H1; elim H1; intros x H2; elim H2; intros H3 H4; try clear H2 H1; try exact H4 | auto with geo ]. elim un_module_a_rotation with (x := x); [ intros J H1; try clear un_module_a_rotation; try exact H1 | auto with geo | auto with geo ]. exists J; exists x; auto with geo. apply nonzero_module. rewrite H; discrR. Qed. Lemma cas_a_reel_homothetie : forall x : R, a <> oneC -> a = Rinj x -> ex (fun J : PO => forall M : PO, g M = homothetie x J M). intros. elim existence_point_fixe_g; [ intros J H1; try clear existence_point_fixe_g; try exact H1 | auto ]. exists J; intros. elim existence_affixe_point with (M := M); intros z H2; try clear existence_affixe_point; try exact H2. elim existence_affixe_point with (M := g M); intros z'; intros; try exact H2. apply (complexe_homothetie (k:=x) (j:=affixe J) (z:=z) (z':=z') (J:=J) (M:=M) (M':=g M)); auto. rewrite <- H0. cut (f (affixe J) = affixe J); intros. apply (equation_solution (z:=z) (z':=z') (j:=affixe J)); auto. rewrite H3; rewrite g_def; rewrite H2; rewrite affixe_transforme; auto. apply point_fixe_gf; auto. Qed. Lemma cas_a_nonzero_nonone : forall r x : R, r > 0 -> a <> oneC -> a = cons_pol r x -> ex (fun J : PO => forall M : PO, g M = similitude J r x M). intros r x H H20 H0; try assumption. elim existence_point_fixe_g; [ intros J H1; try clear existence_point_fixe_g; try exact H1 | auto ]. exists J; intros. elim existence_affixe_point with (M := M); intros z H2; try clear existence_affixe_point; try exact H2. elim existence_affixe_point with (M := g M); intros z'; intros; try exact H2. cut (f (affixe J) = affixe J); intros. apply (complexe_similitude (k:=r) (a:=x) (j:=affixe J) (z:=z) (z':=z') (J:=J) (M:=M) (M':=g M)); auto. rewrite <- H0. apply (equation_solution (z:=z) (z':=z') (j:=affixe J)); auto. rewrite H3; rewrite g_def; rewrite H2; rewrite affixe_transforme; auto. apply point_fixe_gf; auto. Qed. Theorem cas_general_deplacement_similitude : a <> zeroC -> (ex (fun A : PO => forall M : PO, g M = translation O A M) \/ ex (fun J : PO => ex (fun x : R => forall M : PO, g M = rotation J x M))) \/ (exists r : R, (exists x : R, (exists J : PO, (forall M : PO, g M = similitude J r x M)))). intros. elim existence_forme_polaire with (z := a); [ intros r H0; elim H0; intros x H1; elim H1; intros H2 H3; try clear H1 H0; try exact H3 | auto with geo ]. cut (a = cons_pol r x); intros; auto with geo. elim (classic (module a = 1)); intros. left; try assumption. apply un_module_a_deplacement; auto with geo. right; try assumption. exists r; exists x. apply cas_a_nonzero_nonone; auto. rewrite <- H2; auto with geo. red in |- *; intros; apply H1. rewrite H4; auto with geo. Qed.HighSchoolGeometry/composee_dilatations.v0000644000076500007650000002347712073525615020640 0ustar coqcoq00000000000000(* This program is free software; you can redistribute it and/or *) (* modify it under the terms of the GNU Lesser General Public License *) (* as published by the Free Software Foundation; either version 2.1 *) (* of the License, or (at your option) any later version. *) (* *) (* This program is distributed in the hope that it will be useful, *) (* but WITHOUT ANY WARRANTY; without even the implied warranty of *) (* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *) (* GNU General Public License for more details. *) (* *) (* You should have received a copy of the GNU Lesser General Public *) (* License along with this program; if not, write to the Free *) (* Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA *) (* 02110-1301 USA *) Require Export dilatations. Set Implicit Arguments. Unset Strict Implicit. Lemma compo_transl : forall A A' A1 I J K L : PO, A1 = translation I J A -> A' = translation K L A1 -> vec A A' = add_PP (vec I J) (vec K L). intros A A' A1 I J K L H H0; try assumption. cut (vec K L = vec A1 A'); intros. cut (vec I J = vec A A1); intros. rewrite H1; rewrite H2; Ringvec. rewrite (translation_vecteur (I:=I) (J:=J) (A:=A) (A':=A1)); auto. apply translation_vecteur; auto. Qed. Lemma composition_translation : forall A A' A1 I J K L : PO, A1 = translation I J A -> A' = translation K L A1 -> ex (fun M : PO => vec I M = add_PP (vec I J) (vec K L) :>PP /\ A' = translation I M A). intros A A' A1 I J K L H H0; try assumption. elim existence_representant_som_vecteur with (A := I) (B := J) (C := K) (D := L); intros M H1; try clear existence_representant_som_vecteur; try exact H1. exists M. split; [ try assumption | idtac ]. apply rec_translation_vecteur. rewrite H1. symmetry in |- *; apply compo_transl with A1; auto. Qed. Lemma compo_homothetie_I : forall (k k' : R) (I A A' A1 : PO), A1 = homothetie k I A :>PO -> A' = homothetie k' I A1 :>PO -> A' = homothetie (k' * k) I A. intros k k' I A A' A1 H H0; try assumption. cut (vec I A' = mult_PP (k' * k) (vec I A)); intros. apply vecteur_homothetie; auto. rewrite <- mult_mult_vec. rewrite <- (homothetie_vecteur (k:=k) (I:=I) (A:=A) (A':=A1)); auto. apply homothetie_vecteur; auto. Qed. Lemma compo_homothetie_IJ : forall (k k' : R) (I J A A' A1 : PO), A1 = homothetie k I A :>PO -> A' = homothetie k' J A1 -> cons 1 A' = add_PP (add_PP (cons (k' * k) A) (cons (k' * (1 + - k)) I)) (cons (1 + - k') J) :>PP. unfold vec, homothetie in |- *; intros. rewrite H0; rewrite H. rewrite (distrib_mult_cons k (1 + - k) k' A I). rewrite add_PP_barycentre; try discrR. replace (k + (1 + - k)) with 1; try ring; auto. rewrite def_mult_PP. replace (k' * 1) with k'; try ring; auto. rewrite add_PP_barycentre; try discrR. replace (k' + (1 + - k')) with 1; try ring; auto. replace (k' + (1 + - k')) with 1; try ring; try discrR. replace (k + (1 + - k)) with 1; try ring; try discrR. Qed. Lemma compo_homothetie_IJ_1 : forall (k k' : R) (I J A A' A1 K : PO), k' * k = 1 -> A1 = homothetie k I A :>PO -> A' = homothetie k' J A1 :>PO -> vec I K = mult_PP (1 + - k') (vec I J) :>PP -> A' = translation I K A. intros. cut (vec A A' = mult_PP (1 + - k') (vec I J)); intros. apply rec_translation_vecteur; auto. rewrite H3; rewrite H2; auto. cut (cons 1 A' = add_PP (add_PP (cons (k' * k) A) (cons (k' * (1 + - k)) I)) (cons (1 + - k') J)); intros. unfold vec in |- *. rewrite H3; auto. repeat rewrite add_PP_assoc. replace (k' * (1 + - k)) with (- (k' * k) + k'); try ring; try ring; auto. rewrite H; auto. RingPP. apply compo_homothetie_IJ with A1; auto. Qed. Lemma compo_homothetie_IJ_1_exists : forall (k : R) (I J : PO), k <> 0 -> exists K : PO, (forall A A' A1 : PO, A1 = homothetie k I A -> A' = homothetie (/ k) J A1 :>PO -> A' = translation I K A). intros. elim existence_representant_mult_vecteur with (A := I) (B := I) (C := J) (k := 1 + - / k); intros K H3; try clear existence_representant_mult_vecteur. exists K; intros. apply compo_homothetie_IJ_1 with (2 := H0) (3 := H1); auto with *. Qed. Lemma compo_homothetie_IJ_non1 : forall (k k' : R) (I J A A' A1 K : PO), k' * k <> 1 -> A1 = homothetie k I A :>PO -> A' = homothetie k' J A1 :>PO -> K = barycentre (cons (k' * (1 + - k)) I) (cons (1 + - k') J) :>PO -> A' = homothetie (k' * k) K A. intros; unfold homothetie in |- *. cut (A' = barycentre (cons (k' * k) A) (cons (1 + - (k' * k)) K)); intros. rewrite H3; auto. elim cons_inj with (a := 1) (b := k' * k + (1 + - (k' * k))) (A := A') (B := barycentre (cons (k' * k) A) (cons (1 + - (k' * k)) K)); intros; auto with *. rewrite <- add_PP_barycentre; auto with real. rewrite H2. RReplace (1 + - (k' * k)) (k' * (1 + - k) + (1 + - k')). rewrite <- add_PP_barycentre; auto with real. rewrite add_PP_assoc. apply compo_homothetie_IJ with A1; auto. RReplace (k' * (1 + - k) + (1 + - k')) (1 + - (k' * k)). auto with real. RReplace (k' * k + (1 + - (k' * k))) 1. auto with real. Qed. Lemma compo_homothetie_IJ_non1_exists : forall (k k' : R) (I J : PO), k' * k <> 1 -> exists K : PO, (forall A A' A1 : PO, A1 = homothetie k I A -> A' = homothetie k' J A1 :>PO -> A' = homothetie (k' * k) K A :>PO). intros. exists (barycentre (cons (k' * (1 + - k)) I) (cons (1 + - k') J)); intros. apply compo_homothetie_IJ_non1 with (2 := H0) (3 := H1); auto. Qed. Lemma composee_homothetie_translation : forall (k : R) (A A' B B' B1 I J : PO), k <> 1 -> k <> 0 -> B1 = homothetie k I B :>PO -> B' = translation A A' B1 :>PO -> J = barycentre (cons 1 A') (cons (-1 + (1 + - k)) (barycentre (cons (-1) A) (cons (1 + - k) I))) :>PO -> B' = homothetie k J B. unfold translation, homothetie in |- *; intros k A A' B B' B1 I J H H0 H1 H2 H30. elim cons_inj with (a := 1) (b := 1) (A := B') (B := barycentre (cons k B) (cons (1 + - k) (barycentre (cons 1 A') (cons (-1 + (1 + - k)) (barycentre (cons (-1) A) (cons (1 + - k) I)))))); intros; auto with *. rewrite H4; rewrite H30; auto. rewrite H2. pattern 1 at 1 in |- *. replace 1 with (-1 + 2); [ idtac | try ring ]. rewrite <- add_PP_barycentre; auto. rewrite <- add_PP_barycentre; auto. pattern 1 at 3 in |- *. replace 1 with (k + (1 + - k)); [ idtac | try ring ]. rewrite H1. rewrite <- add_PP_barycentre; auto. pattern 1 at 4 in |- *. replace 1 with (k + (1 + - k)); [ idtac | try ring ]. rewrite <- add_PP_barycentre; auto. pattern (1 + - k) at 2 in |- *. replace (1 + - k) with (1 + (-1 + (1 + - k))); [ idtac | try ring ]. rewrite <- add_PP_barycentre; auto. rewrite <- add_PP_barycentre; auto. RingPP. replace (-1 + (1 + - k)) with (- k); try ring; auto with *. replace (1 + (-1 + (1 + - k))) with (1 + - k); try ring; auto with *. replace (k + (1 + - k)) with 1; try ring; auto with *. replace (k + (1 + - k)) with 1; try ring; auto with *. discrR. replace (-1 + 2) with 1; try ring; auto with *. Qed. Lemma composee_homothetie_translation_exists : forall (k : R) (I A A' : PO), k <> 1 :>R -> k <> 0 :>R -> exists J : PO, (forall B B' B1 : PO, B1 = homothetie k I B :>PO -> B' = translation A A' B1 :>PO -> B' = homothetie k J B :>PO). intros. exists (barycentre (cons 1 A') (cons (-1 + (1 + - k)) (barycentre (cons (-1) A) (cons (1 + - k) I)))); intros. apply composee_homothetie_translation with (4 := H2) (3 := H1); auto. Qed. Lemma composee_translation_homothetie : forall (k : R) (A A' B B' B1 I J : PO), k <> 1 -> k <> 0 -> B1 = translation A A' B :>PO -> B' = homothetie k I B1 :>PO -> J = barycentre (cons (- k) A) (cons (k + (1 + - k)) (barycentre (cons k A') (cons (1 + - k) I))) :>PO -> B' = homothetie k J B. unfold translation, homothetie in |- *; intros k A A' B B' B1 I J H H0 H1 H2 H30. elim cons_inj with (a := 1) (b := 1) (A := B') (B := barycentre (cons k B) (cons (1 + - k) (barycentre (cons (- k) A) (cons (k + (1 + - k)) (barycentre (cons k A') (cons (1 + - k) I)))))); intros; auto with *. rewrite H4; rewrite H30; auto. rewrite H2. cut (cons k B1 = add_PP (cons (- k) A) (add_PP (cons k A') (cons k B))); intros. pattern 1 at 1 in |- *. replace 1 with (k + (1 + - k)); [ idtac | try ring ]. rewrite <- add_PP_barycentre; auto. rewrite H3. pattern 1 at 2 in |- *. replace 1 with (k + (1 + - k)); [ idtac | try ring ]. rewrite <- add_PP_barycentre; auto. pattern (1 + - k) at 2 in |- *. replace (1 + - k) with (- k + (k + (1 + - k))); [ idtac | try ring ]. rewrite <- add_PP_barycentre; auto. rewrite <- add_PP_barycentre; auto. RingPP. replace (k + (1 + - k)) with 1; try ring; auto with *. replace (- k + (k + (1 + - k))) with (1 + - k); try ring; auto with *. replace (k + (1 + - k)) with 1; try ring; auto with *. replace (k + (1 + - k)) with 1; try ring; auto with *. apply mult_PP_regulier with (/ k); auto with real. replace (mult_PP (/ k) (add_PP (cons (- k) A) (add_PP (cons k A') (cons k B)))) with (add_PP (cons (-1) A) (add_PP (cons 1 A') (cons 1 B))). replace (mult_PP (/ k) (cons k B1)) with (cons 1 B1). rewrite H1. pattern 1 at 1 in |- *. replace 1 with (-1 + 2); [ idtac | try ring ]. rewrite <- add_PP_barycentre; auto with real. rewrite <- add_PP_barycentre; auto with real. discrR. Fieldvec k. Fieldvec k. Qed. Lemma composee_translation_homothetie_exists : forall (k : R) (I A A' : PO), k <> 1 :>R -> k <> 0 :>R -> exists J : PO, (forall B B' B1 : PO, B1 = translation A A' B :>PO -> B' = homothetie k I B1 :>PO -> B' = homothetie k J B :>PO). intros. exists (barycentre (cons (- k) A) (cons (k + (1 + - k)) (barycentre (cons k A') (cons (1 + - k) I)))); intros. apply composee_translation_homothetie with (4 := H2) (3 := H1); auto. Qed.HighSchoolGeometry/composee_reflexions.v0000644000076500007650000003357412073525613020500 0ustar coqcoq00000000000000(* This program is free software; you can redistribute it and/or *) (* modify it under the terms of the GNU Lesser General Public License *) (* as published by the Free Software Foundation; either version 2.1 *) (* of the License, or (at your option) any later version. *) (* *) (* This program is distributed in the hope that it will be useful, *) (* but WITHOUT ANY WARRANTY; without even the implied warranty of *) (* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *) (* GNU General Public License for more details. *) (* *) (* You should have received a copy of the GNU Lesser General Public *) (* License along with this program; if not, write to the Free *) (* Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA *) (* 02110-1301 USA *) Require Export reflexion_plane. Require Export dilatations. Require Export rotation_plane. Set Implicit Arguments. Unset Strict Implicit. Theorem composee_reflexions_axes_paralleles : forall A B C D E M M' M1 : PO, A <> B -> A <> C -> orthogonal (vec A B) (vec A C) -> D = translation A B C -> E = translation A C C -> M1 = reflexion A B M -> M' = reflexion C D M1 -> M' = translation A E M. intros A B C D E M M' M1 H11 H0 H6 H2 H3 H4 H5; try assumption. generalize (translation_vecteur (I:=A) (J:=C) (A:=C) (A':=E)); intros H21. generalize (translation_vecteur (I:=A) (J:=B) (A:=C) (A':=D)); intros H22. cut (C <> D). intros H7. elim existence_projete_orthogonal with (A := A) (B := B) (C := M); [ intros H H8; try clear existence_projete_orthogonal; try exact H8 | auto ]. elim existence_projete_orthogonal with (A := C) (B := D) (C := M1); [ intros H1 H12; try clear existence_projete_orthogonal | auto ]. elim def_projete_orthogonal2 with (A := A) (B := B) (C := M) (H := H); [ intros | auto | auto ]. elim def_projete_orthogonal2 with (A := C) (B := D) (C := M1) (H := H1); [ intros | auto | auto ]. apply rec_translation_vecteur. generalize (reflexion_projete_orthogonal_milieu (A:=A) (B:=B) (M:=M) (M':=M1) (H:=H)); intros. generalize (reflexion_projete_orthogonal_milieu (A:=C) (B:=D) (M:=M1) (M':=M') (H:=H1)); intros. replace (vec M M') with (add_PP (vec M M1) (vec M1 M')). rewrite (reflexion_def (A:=A) (B:=B) (M:=M) (M':=M1) (H:=H)); auto. rewrite (reflexion_def (A:=C) (B:=D) (M:=M1) (M':=M') (H:=H1)); auto. rewrite (milieu_vecteur (A:=M) (B:=M1) (M:=H)); auto. replace (add_PP (mult_PP 2 (vec H M1)) (mult_PP 2 (vec M1 H1))) with (mult_PP 2 (add_PP (vec H M1) (vec M1 H1))). replace (add_PP (vec H M1) (vec M1 H1)) with (vec H H1). cut (vec H H1 = vec A C); intros. rewrite H17. generalize (translation_vecteur (I:=A) (J:=C) (A:=C) (A':=E)); intros. replace (vec A E) with (add_PP (vec A C) (vec C E)). rewrite H18; auto. Ringvec. Ringvec. generalize (triangle_rectangle_repere (O:=A) (I:=B) (J:=C)); intros. halignes H9 ipattern:k. halignes H13 ipattern:k0. elim (classic (k = 0)); intros. cut (A = H); intros. generalize (translation_bipoint (I:=A) (J:=B) (A:=A) (A':=B) (B:=C) (B':=D)); intros. cut (B <> D); intros. cut (orthogonal (vec B A) (vec B D)); intros. generalize (triangle_rectangle_repere (O:=B) (I:=A) (J:=D)); intros. rewrite H24; auto with geo. elim orthogonal_paralleles with (A := B) (B := A) (C := D) (E := H) (F := H1); [ intros k1 H28; try clear orthogonal_paralleles | auto | auto | auto | auto ]. rewrite (couple_colineaires_parallelogramme (A:=B) (B:=H) (C:=D) (D:=H1) (k:=1 + - k0) (k':=k1)); auto. unfold not in |- *; intros; apply H11. rewrite H29; rewrite H23; auto. rewrite <- H23. auto with geo. replace (vec D H1) with (add_PP (mult_PP (-1) (vec C D)) (vec C H1)). rewrite H19. rewrite <- H23. rewrite <- H22; auto. Ringvec. Ringvec. cut (orthogonal (vec H H1) (vec A B)); intros; auto with geo. replace (vec H H1) with (add_PP (vec H M) (vec M H1)). apply ortho_somme; auto with geo. replace (vec M H1) with (add_PP (mult_PP 1 (vec M M1)) (mult_PP (-1) (vec H1 M1))). Simplortho. replace (vec M M1) with (add_PP (mult_PP (-1) (vec H M)) (mult_PP 1 (vec H M1))). Simplortho. rewrite <- (milieu_vecteur (A:=M) (B:=M1) (M:=H)); auto with geo. Ringvec. rewrite H22; auto with geo. Ringvec. Ringvec. rewrite <- H24; auto with geo. unfold not in |- *; intros; apply H0. cut (vec A C = vec B D); auto with geo; intros. rewrite H25 in H26. apply conversion_PP with (a := 1) (b := 1); auto. RingPP2 H26. Ringvec. discrR. apply conversion_PP with (a := 1) (b := 1); auto. RingPP2 H18. rewrite H20. Ringvec. discrR. elim orthogonal_paralleles with (A := A) (B := B) (C := C) (E := H) (F := H1); [ intros k1 H23; try clear orthogonal_paralleles; try exact H23 | auto | auto | auto | auto ]. rewrite <- H22 in H19; auto. cut (vec A B = mult_PP (/ k) (vec A H)); intros; auto with geo. rewrite H24 in H19. rewrite (couple_colineaires_parallelogramme (A:=A) (B:=H) (C:=C) (D:=H1) (k:=k0 * / k) (k':=k1)); auto. unfold not in |- *; intros; apply H20. rewrite <- H25 in H18; auto. elim produit_vecteur_nul with (a := k) (A := A) (B := B); [ intros H26; try clear produit_vecteur_nul; try exact H26 | intros H26; try clear produit_vecteur_nul | try clear produit_vecteur_nul ]. absurd (A = B); auto. rewrite <- H18; Ringvec. apply alignes_non_alignes_trans with B; auto with geo. apply distinct_produit_vecteur with (3 := H18); auto. rewrite H19; Ringvec. rewrite H18. Fieldvec k. cut (vec A H1 = add_PP (mult_PP k0 (vec A B)) (mult_PP 1 (vec A C))); intros. replace (vec H H1) with (add_PP (vec H M) (vec M H1)). Simplortho. replace (vec M H1) with (add_PP (mult_PP 1 (vec M M1)) (mult_PP (-1) (vec H1 M1))). Simplortho. replace (vec M M1) with (add_PP (mult_PP (-1) (vec H M)) (mult_PP 1 (vec H M1))). Simplortho. rewrite <- (milieu_vecteur (A:=M) (B:=M1) (M:=H)); auto with geo. Ringvec. rewrite H22; auto with geo. Ringvec. Ringvec. replace (vec A H1) with (add_PP (vec A C) (vec C H1)). rewrite H19; rewrite H22; auto. Ringvec. Ringvec. Ringvec. Ringvec. Ringvec. unfold not in |- *; intros; apply H11. cut (vec A B = vec C D); auto; intros. rewrite H in H1. apply conversion_PP with (a := 1) (b := 1); auto. RingPP2 H1. Ringvec. discrR. Qed. Theorem composee_reflexions_axes_secants : forall (A B C M M' M1 : PO) (a : R), A <> B -> A <> C -> image_angle a = cons_AV (vec A B) (vec A C) -> M1 = reflexion A B M -> M' = reflexion A C M1 -> M' = rotation A (a + a) M. intros A B C M M' M1 a H H0 H1 H2 H3; try assumption. elim (classic (A = M)). intros H5; try assumption. rewrite <- H5 in H2. rewrite H2 in H3. rewrite <- (reflexion_axe (A:=A) (B:=B) (M:=A)) in H3; auto with geo. rewrite <- (reflexion_axe (A:=A) (B:=C) (M:=A)) in H3; auto with geo. rewrite H3; rewrite <- H5. apply rotation_def_centre. elim (classic (alignes A B M)); intros. cut (M1 = M); intros; auto. rewrite H6 in H3. elim (classic (alignes A C M)); intros. cut (alignes A B C); intros. cut (M' = M); intros. rewrite H9. pattern M at 1 in |- *. rewrite (rotation_angle_nul A M). apply deux_mes_angle_rotation. symmetry in |- *. replace (image_angle (a + a)) with (double_AV (cons_AV (vec A B) (vec A C))). apply angle_alignes; auto. rewrite add_mes_compatible. rewrite H1; auto. rewrite H3; symmetry in |- *. apply reflexion_axe with (2 := H7); auto. cut (alignes A M C); auto with geo; intros. apply alignes_trans with M; auto with geo. generalize (axe_reflexion_bissectrice (A:=A) (B:=C) (M:=M) (M':=M')); intros. apply rotation_def2; auto. generalize (reflexion_mediatrice (A:=A) (B:=C) (M:=M) (M':=M')); intros. elim H9; intros; auto. cut (cons_AV (vec A M) (vec A B) = cons_AV (vec A B) (vec A M)); intros. replace (cons_AV (vec A M) (vec A M')) with (plus (plus (cons_AV (vec A M) (vec A B)) (cons_AV (vec A B) (vec A M1))) (plus (cons_AV (vec A M1) (vec A C)) (cons_AV (vec A C) (vec A M')))). rewrite H6; rewrite H9; rewrite <- H8; auto. replace (plus (plus (cons_AV (vec A B) (vec A M)) (cons_AV (vec A B) (vec A M))) (plus (cons_AV (vec A M) (vec A C)) (cons_AV (vec A M) (vec A C)))) with (plus (plus (cons_AV (vec A B) (vec A M)) (cons_AV (vec A M) (vec A C))) (plus (cons_AV (vec A B) (vec A M)) (cons_AV (vec A M) (vec A C)))). replace (plus (cons_AV (vec A B) (vec A M)) (cons_AV (vec A M) (vec A C))) with (cons_AV (vec A B) (vec A C)). rewrite <- H1; rewrite add_mes_compatible; auto. rewrite Chasles; auto. mesure A B A M. mesure A M A C. replace (x + x0 + (x + x0)) with (x + x + (x0 + x0)); auto. ring. rewrite H6. rewrite Chasles; auto. generalize (non_axe_image_non_axe (A:=A) (B:=C) (M:=M) (M':=M')); intros. generalize (non_alignes_distincts (A:=A) (B:=C) (C:=M')); intros. rewrite Chasles; auto. rewrite Chasles; auto. rewrite angles_representants_unitaires; auto. rewrite angles_representants_unitaires; auto. elim existence_representant_unitaire with (A := A) (B := B); [ intros; try clear existence_representant_unitaire | auto ]. elim existence_representant_unitaire with (A := A) (B := M); [ intros; try clear existence_representant_unitaire | auto ]. elim alignes_representant_unitaire with (A := A) (B := B) (C := M); [ intros; try clear alignes_representant_unitaire; auto | intros; auto | auto | auto | auto ]. rewrite H11; auto. rewrite <- angles_representants_unitaires; auto. rewrite <- angles_representants_unitaires; auto. rewrite angles_representants_unitaires; auto. rewrite angles_representants_unitaires; auto. replace (representant_unitaire (vec A B)) with (mult_PP (-1) (representant_unitaire (vec A M))). cut (A <> x0); intros. replace (mult_PP (-1) (representant_unitaire (vec A M))) with (vec x0 A). rewrite <- H10. rewrite <- angle_plat; auto. rewrite <- angle_plat; auto. rewrite <- H10. Ringvec. apply distance_non_nulle. elim def_representant_unitaire2 with (A := A) (B := M) (C := x0); [ intros; elim H13; intros H22 H23; rewrite H22; try discrR | auto | auto ]. rewrite H11; Ringvec. rewrite H2. rewrite <- reflexion_axe; auto. generalize (non_axe_image_non_axe (A:=A) (B:=B) (M:=M) (M':=M1)); intros. generalize (non_alignes_distincts (A:=A) (B:=B) (C:=M1)); intros. elim (classic (alignes A C M1)); intros. cut (M' = M1); intros; auto. rewrite H9. generalize (axe_reflexion_bissectrice (A:=A) (B:=B) (M:=M) (M':=M1)); intros. apply rotation_def2; auto. generalize (reflexion_mediatrice (A:=A) (B:=B) (M:=M) (M':=M1)); intros. elim H11; intros; auto. rewrite <- H9. cut (cons_AV (vec A M') (vec A C) = cons_AV (vec A C) (vec A M')); intros. replace (cons_AV (vec A M) (vec A M')) with (plus (plus (cons_AV (vec A M) (vec A B)) (cons_AV (vec A B) (vec A M1))) (plus (cons_AV (vec A M1) (vec A C)) (cons_AV (vec A C) (vec A M')))). rewrite <- H11; rewrite H10; auto. rewrite <- H9. replace (plus (plus (cons_AV (vec A B) (vec A M')) (cons_AV (vec A B) (vec A M'))) (plus (cons_AV (vec A M') (vec A C)) (cons_AV (vec A M') (vec A C)))) with (plus (plus (cons_AV (vec A B) (vec A M')) (cons_AV (vec A M') (vec A C))) (plus (cons_AV (vec A B) (vec A M')) (cons_AV (vec A M') (vec A C)))). replace (plus (cons_AV (vec A B) (vec A M')) (cons_AV (vec A M') (vec A C))) with (cons_AV (vec A B) (vec A C)). rewrite <- H1; rewrite add_mes_compatible; auto. rewrite H9; rewrite Chasles; auto. rewrite H9. mesure A B A M1. mesure A M1 A C. replace (x + x0 + (x + x0)) with (x + x + (x0 + x0)); auto. ring. rewrite H9; rewrite Chasles; auto. rewrite Chasles; auto. rewrite Chasles; auto. rewrite H9. rewrite angles_representants_unitaires; auto. rewrite angles_representants_unitaires; auto. elim existence_representant_unitaire with (A := A) (B := C); [ intros; try clear existence_representant_unitaire | auto ]. elim existence_representant_unitaire with (A := A) (B := M1); [ intros; try clear existence_representant_unitaire | auto ]. elim alignes_representant_unitaire with (A := A) (B := C) (C := M1); [ intros; try clear alignes_representant_unitaire; auto | intros; auto | auto | auto | auto ]. rewrite H13; auto. replace (representant_unitaire (vec A C)) with (mult_PP (-1) (representant_unitaire (vec A M1))). cut (A <> x0); intros. replace (mult_PP (-1) (representant_unitaire (vec A M1))) with (vec x0 A). rewrite <- H12. replace (mult_PP (-1) (vec A x0)) with (vec x0 A). rewrite <- angle_plat; auto. rewrite <- angle_plat; auto. Ringvec. rewrite <- H12. Ringvec. apply distance_non_nulle. elim def_representant_unitaire2 with (A := A) (B := M1) (C := x0); [ intros; elim H15; intros H22 H23; rewrite H22; try discrR | auto | auto ]. rewrite H13; Ringvec. rewrite H3. rewrite <- reflexion_axe; auto. generalize (non_axe_image_non_axe (A:=A) (B:=C) (M:=M1) (M':=M')); intros. generalize (non_alignes_distincts (A:=A) (B:=C) (C:=M')); intros. generalize (axe_reflexion_bissectrice (A:=A) (B:=B) (M:=M) (M':=M1)); intros. generalize (axe_reflexion_bissectrice (A:=A) (B:=C) (M:=M1) (M':=M')); intros. apply rotation_def2; auto. generalize (reflexion_mediatrice (A:=A) (B:=B) (M:=M) (M':=M1)); intros. generalize (reflexion_mediatrice (A:=A) (B:=C) (M:=M1) (M':=M')); intros. cut (distance A M = distance A M1); intros. rewrite H15. elim H13; intros; auto. elim H14; intros; auto. elim H13; intros; auto. replace (cons_AV (vec A M) (vec A M')) with (plus (plus (cons_AV (vec A M) (vec A B)) (cons_AV (vec A B) (vec A M1))) (plus (cons_AV (vec A M1) (vec A C)) (cons_AV (vec A C) (vec A M')))). rewrite <- H12; auto. rewrite H11; auto. replace (plus (plus (cons_AV (vec A B) (vec A M1)) (cons_AV (vec A B) (vec A M1))) (plus (cons_AV (vec A M1) (vec A C)) (cons_AV (vec A M1) (vec A C)))) with (plus (plus (cons_AV (vec A B) (vec A M1)) (cons_AV (vec A M1) (vec A C))) (plus (cons_AV (vec A B) (vec A M1)) (cons_AV (vec A M1) (vec A C)))). replace (plus (cons_AV (vec A B) (vec A M1)) (cons_AV (vec A M1) (vec A C))) with (cons_AV (vec A B) (vec A C)). rewrite <- H1; rewrite add_mes_compatible; auto. rewrite Chasles; auto. mesure A B A M1. mesure A M1 A C. replace (x + x0 + (x + x0)) with (x + x + (x0 + x0)); auto. ring. rewrite Chasles; auto. rewrite Chasles; auto. rewrite Chasles; auto. Qed.HighSchoolGeometry/composee_transformations.v0000644000076500007650000004403112073525613021541 0ustar coqcoq00000000000000(* This program is free software; you can redistribute it and/or *) (* modify it under the terms of the GNU Lesser General Public License *) (* as published by the Free Software Foundation; either version 2.1 *) (* of the License, or (at your option) any later version. *) (* *) (* This program is distributed in the hope that it will be useful, *) (* but WITHOUT ANY WARRANTY; without even the implied warranty of *) (* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *) (* GNU General Public License for more details. *) (* *) (* You should have received a copy of the GNU Lesser General Public *) (* License along with this program; if not, write to the Free *) (* Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA *) (* 02110-1301 USA *) Require Export composee_translation_rotation. Set Implicit Arguments. Unset Strict Implicit. Theorem composee_rotation_IJ_translation : forall (I J : PO) (a b : R), image_angle (a + b) = image_angle 0 -> exists A : PO, (exists B : PO, (forall M M1 M2 : PO, M1 = rotation I a M -> M2 = rotation J b M1 -> M2 = translation A B M)). intros I J a b H; try assumption. discrimine I J. exists J; exists J; intros. generalize (composee_rotations_meme_centre (I:=J) (A:=M) (B:=M1) (C:=M2) (a:=a) (b:=b)); intros. rewrite H3; auto. apply rec_translation_vecteur; auto. rewrite (deux_mes_angle_rotation J M (a:=a + b) (b:=0)); auto. rewrite <- (rotation_angle_nul J M); auto. Ringvec. elim existence_rotation_Ia with (I := J) (M := I) (a := / 2 * b); intros C H7. elim (rotation_def (I:=J) (A:=I) (B:=C) (a:=/ 2 * b)); auto; intros. elim existence_rotation_Ia with (I := I) (M := J) (a := - (/ 2 * a)); intros D H10. elim (rotation_def (I:=I) (A:=J) (B:=D) (a:=- (/ 2 * a))); auto; intros. cut (I <> D); intros. cut (J <> C); intros. cut (paralleles (droite I D) (droite J C)); intros. elim (existence_projete_orthogonal (A:=J) (B:=C) I). intros K H25; try assumption. generalize (def_projete_orthogonal2 (A:=J) (B:=C) (C:=I) (H:=K)). intros H60. elim H60; auto; intros H61 H62; clear H60. discrimine I K. rewrite <- H9 in H61. exists I; exists I; intros. elim existence_reflexion_AB with (A := I) (B := D) (M := M); [ intros M' H16; try clear existence_reflexion_AB | auto ]. elim existence_reflexion_AB with (A := I) (B := J) (M := M'); [ intros N' H17; try clear existence_reflexion_AB | auto ]. elim existence_reflexion_AB with (A := J) (B := I) (M := M1); [ intros N1 H19; try clear existence_reflexion_AB | auto ]. elim existence_reflexion_AB with (A := J) (B := C) (M := N1); [ intros N2 H21; try clear existence_reflexion_AB | auto ]. generalize (composee_reflexions_axes_secants (A:=J) (B:=I) (C:=C) (M:=M1) (M':=N2) (M1:=N1) (a:=/ 2 * b)); intros H23. generalize (composee_reflexions_axes_secants (A:=I) (B:=D) (C:=J) (M:=M) (M':=N') (M1:=M') (a:=/ 2 * a)); intros H24. cut (M1 = N'); intros. cut (N1 = M'); intros. cut (M2 = N2); intros. rewrite <- H15 in H21; rewrite H14 in H21; auto. generalize (axe_reflexion_droite (A:=J) (B:=C) (C:=I) (M:=M') (M':=M2)); intros. generalize (axe_reflexion_droite (A:=I) (B:=J) (C:=D) (M:=M') (M':=M2)); intros. generalize (axe_reflexion_droite (A:=D) (B:=I) (C:=I) (M:=M') (M':=M2)); intros. rewrite H22; auto with geo. generalize (reflexion_symetrie (A:=I) (B:=D) (M:=M) (M':=M')); intros. rewrite <- H26; auto. apply rec_translation_vecteur; auto. Ringvec. rewrite H20; auto. apply paralleles_alignes3 with (3 := H8); auto. rewrite H23; auto. rewrite H12; auto. apply deux_mes_angle_rotation. replace (/ 2 * b + / 2 * b) with b; auto with real. rewrite H13 in H19. generalize (reflexion_symetrie (A:=I) (B:=J) (M:=M') (M':=N')); intros. rewrite H14; auto. generalize (axe_reflexion_droite (A:=J) (B:=I) (C:=I) (M:=N') (M':=N1)); intros. rewrite H15; auto with geo. rewrite H24; auto. rewrite H11; auto. rewrite <- H9. apply deux_mes_angle_rotation. replace (/ 2 * a + / 2 * a) with a; auto with real. rewrite <- (mes_oppx (A:=I) (B:=J) (C:=I) (D:=D) (x:=- (/ 2 * a))); auto. replace (- - (/ 2 * a)) with (/ 2 * a); auto. ring. cut (orthogonal (vec I D) (vec I K)); intros. elim existence_representant_vecteur with (A := K) (B := I) (C := D); intros L H28. generalize (egalite_vecteur (A:=K) (B:=L) (C:=I) (D:=D)); intros. cut (K <> L); intros. elim existence_representant_vecteur with (A := K) (B := I) (C := K); intros P H31. exists I; exists P; intros. elim existence_reflexion_AB with (A := I) (B := D) (M := M); [ intros M' H16; try clear existence_reflexion_AB | auto ]. elim existence_reflexion_AB with (A := I) (B := J) (M := M'); [ intros N' H17; try clear existence_reflexion_AB | auto ]. elim existence_reflexion_AB with (A := J) (B := I) (M := M1); [ intros N1 H19; try clear existence_reflexion_AB | auto ]. elim existence_reflexion_AB with (A := J) (B := C) (M := N1); [ intros N2 H21; try clear existence_reflexion_AB | auto ]. generalize (composee_reflexions_axes_secants (A:=J) (B:=I) (C:=C) (M:=M1) (M':=N2) (M1:=N1) (a:=/ 2 * b)); intros H23. generalize (composee_reflexions_axes_secants (A:=I) (B:=D) (C:=J) (M:=M) (M':=N') (M1:=M') (a:=/ 2 * a)); intros H24. cut (M1 = N'); intros. cut (N1 = M'); intros. cut (M2 = N2); intros. generalize (composee_reflexions_axes_paralleles (A:=I) (B:=D) (C:=K) (D:=L) (E:=P) (M:=M) (M':=M2) (M1:=M')); intros. rewrite H26; auto. apply rec_translation_vecteur; auto. apply rec_translation_vecteur; auto. rewrite <- H22 in H21; rewrite H20 in H21; auto. elim (classic (L = J)); intros. rewrite H27. generalize (axe_reflexion_droite (A:=J) (B:=C) (C:=K) (M:=M') (M':=M2)); intros. rewrite <- H29; auto. rewrite H27 in H13; auto. generalize (axe_reflexion_droite (A:=J) (B:=C) (C:=L) (M:=M') (M':=M2)); intros. generalize (axe_reflexion_droite (A:=L) (B:=J) (C:=K) (M:=M') (M':=M2)); intros. rewrite <- H30; auto. apply paralleles_alignes2 with (4 := H8); auto. rewrite H29; auto. apply paralleles_alignes1 with (3 := H28); auto. rewrite H23; auto. rewrite H15; auto. apply deux_mes_angle_rotation. replace (/ 2 * b + / 2 * b) with b; auto with real. rewrite H18 in H19. generalize (reflexion_symetrie (A:=I) (B:=J) (M:=M') (M':=N')); intros. rewrite H20; auto. generalize (axe_reflexion_droite (A:=J) (B:=I) (C:=I) (M:=N') (M':=N1)); intros. rewrite H22; auto with geo. rewrite H24; auto. rewrite H14; auto. apply deux_mes_angle_rotation. replace (/ 2 * a + / 2 * a) with a; auto with real. rewrite <- (mes_oppx (A:=I) (B:=J) (C:=I) (D:=D) (x:=- (/ 2 * a))); auto. replace (- - (/ 2 * a)) with (/ 2 * a); auto. ring. red in |- *; intros; apply H5. apply vecteur_nul_conf; auto. rewrite <- H28; rewrite <- H13; Ringvec. elim (paralleles_vecteur (A:=I) (B:=D) (C:=J) (D:=C)); auto; intros. replace (vec I D) with (add_PP (mult_PP x (vec J C)) (mult_PP 0 (vec J C))). apply ortho_combinaison_lineaire. apply def_orthogonal2. replace (scalaire (vec J C) (vec I K)) with (- scalaire (vec J C) (vec K I)). rewrite (def_orthogonal (A:=J) (B:=C) (C:=K) (D:=I)); auto. ring. replace (vec I K) with (mult_PP (-1) (vec K I)). Simplscal. Ringvec. auto with geo. rewrite H11; Ringvec. try exact H6. apply droites_paralleles_angle; auto. unfold double_AV in |- *. replace (cons_AV (vec I D) (vec J C)) with (plus (cons_AV (vec I D) (vec I J)) (plus (cons_AV (vec I J) (vec J I)) (cons_AV (vec J I) (vec J C)))); auto. rewrite <- (mes_oppx (A:=I) (B:=J) (C:=I) (D:=D) (x:=- (/ 2 * a))); auto. rewrite <- H2. rewrite <- angle_plat. repeat rewrite <- add_mes_compatible. replace (- - (/ 2 * a)) with (/ 2 * a); auto. replace (/ 2 * a + (pi + / 2 * b) + (/ 2 * a + (pi + / 2 * b))) with (/ 2 * a + / 2 * a + (/ 2 * b + / 2 * b) + (pi + pi)); auto. replace (/ 2 * a + / 2 * a) with a; auto with real. replace (/ 2 * b + / 2 * b) with b; auto with real. rewrite add_mes_compatible. rewrite H. replace (pi + pi) with deuxpi; auto. rewrite pi_plus_pi. repeat rewrite <- add_mes_compatible. replace (0 + 0) with 0; auto. ring. ring. ring. try exact H0. repeat rewrite Chasles; auto. apply (image_distinct_centre (I:=J) (A:=I) (B:=C) (a:=/ 2 * b)); auto. apply (image_distinct_centre (I:=I) (A:=J) (B:=D) (a:=- (/ 2 * a))); auto. Qed. Theorem composee_rotation_IJ_rotation : forall (I J : PO) (a b : R), image_angle (a + b) <> image_angle 0 -> ex (fun K : PO => forall M M1 M2 : PO, M1 = rotation I a M -> M2 = rotation J b M1 -> M2 = rotation K (a + b) M). intros I J a b H; try assumption. discrimine I J. exists I; intros. generalize (composee_rotations_meme_centre (I:=J) (A:=M) (B:=M1) (C:=M2) (a:=a) (b:=b)); intros. rewrite H0; rewrite H3; auto. elim existence_rotation_Ia with (I := J) (M := I) (a := / 2 * b); intros C H7. elim existence_rotation_Ia with (I := I) (M := J) (a := - (/ 2 * a)); intros D H10. cut (I <> D); intros. cut (J <> C); intros. generalize (position_relative_droites_coplanaires (A:=I) (B:=D) (C:=J) (D:=C)); intros. elim H3; intros. elim def_concours2 with (A := I) (B := D) (C := J) (D := C); [ intros K H27; try clear def_concours2; try exact H27 | auto | auto | auto ]. elim H27; intros H28 H29; try clear H27; try exact H29. exists K; intros. elim existence_reflexion_AB with (A := I) (B := D) (M := M); [ intros M' H16; try clear existence_reflexion_AB | auto ]. elim existence_reflexion_AB with (A := I) (B := J) (M := M'); [ intros N' H17; try clear existence_reflexion_AB | auto ]. elim existence_reflexion_AB with (A := J) (B := I) (M := M1); [ intros N1 H19; try clear existence_reflexion_AB | auto ]. elim existence_reflexion_AB with (A := J) (B := C) (M := N1); [ intros N2 H21; try clear existence_reflexion_AB | auto ]. generalize (composee_reflexions_axes_secants (A:=J) (B:=I) (C:=C) (M:=M1) (M':=N2) (M1:=N1) (a:=/ 2 * b)); intros H23. generalize (composee_reflexions_axes_secants (A:=I) (B:=D) (C:=J) (M:=M) (M':=N') (M1:=M') (a:=/ 2 * a)); intros H24. cut (M1 = N'); intros. cut (N1 = M'); intros. cut (M2 = N2); intros. elim (classic (I = K)); intros. cut (J <> K); intros. rewrite <- H12 in H29; rewrite <- H12. elim (rotation_def (I:=J) (A:=I) (B:=C) (a:=/ 2 * b)); auto; intros. cut (image_angle b = image_angle 0); intros. cut (M2 = M1); intros. rewrite H20; rewrite H5. apply deux_mes_angle_rotation. rewrite add_mes_compatible. rewrite H18; rewrite <- add_mes_compatible. replace (a + 0) with a; auto. ring. rewrite H6. pattern M1 at 2 in |- *. rewrite (rotation_angle_nul J M1). apply deux_mes_angle_rotation; auto. replace b with (/ 2 * b + / 2 * b); auto with real. generalize (angle_alignes (A:=J) (B:=I) (C:=C)); intros H22; rewrite <- H22; auto with geo. unfold double_AV in |- *. rewrite <- H15. rewrite add_mes_compatible; auto. red in |- *; intros; apply H0. rewrite H12; rewrite H13; auto. elim (classic (J = K)); intros. rewrite <- H13 in H28; rewrite <- H13. elim (rotation_def (I:=I) (A:=J) (B:=D) (a:=- (/ 2 * a))); auto; intros. cut (image_angle a = image_angle 0); intros. cut (M1 = M); intros. rewrite <- H20; rewrite H6. apply deux_mes_angle_rotation. rewrite add_mes_compatible. rewrite H18; rewrite <- add_mes_compatible. replace (0 + b) with b; try ring; auto. rewrite (rotation_angle_nul I M). rewrite H5. apply deux_mes_angle_rotation; auto. replace a with (/ 2 * a + / 2 * a); auto with real. generalize (angle_alignes (A:=I) (B:=D) (C:=J)); intros H22; rewrite <- H22; auto. unfold double_AV in |- *. rewrite <- (mes_oppx (A:=I) (B:=J) (C:=I) (D:=D) (x:=- (/ 2 * a))); auto. replace (- - (/ 2 * a)) with (/ 2 * a); auto. rewrite add_mes_compatible; auto. ring. mesure I K J K. cut (plus (cons_AV (vec I K) (vec J K)) (cons_AV (vec I K) (vec J K)) = image_angle (a + b)); intros. generalize (composee_reflexions_axes_secants (A:=K) (B:=I) (C:=J) (M:=M) (M':=M2) (M1:=M') (a:=x)); intros. rewrite H18; auto. apply deux_mes_angle_rotation. rewrite add_mes_compatible. rewrite H14; rewrite H15; auto. rewrite angle_oppu_oppv; auto. generalize (axe_reflexion_droite (A:=I) (B:=D) (C:=K) (M:=M) (M':=M')); intros. rewrite H20; auto. generalize (axe_reflexion_droite (A:=J) (B:=C) (C:=K) (M:=N1) (M':=N2)); intros. rewrite H11; rewrite H20; auto; rewrite H9; auto. replace (plus (cons_AV (vec I K) (vec J K)) (cons_AV (vec I K) (vec J K))) with (double_AV (cons_AV (vec I K) (vec J K))); auto. generalize (alignement_et_angles (A:=I) (B:=D) (C:=K) (D:=J) (E:=C) (F:=K)); intros. rewrite <- H15; auto. unfold double_AV in |- *. replace (cons_AV (vec I D) (vec J C)) with (plus (cons_AV (vec I D) (vec I J)) (plus (cons_AV (vec I J) (vec J I)) (cons_AV (vec J I) (vec J C)))); auto. rewrite <- angle_plat; auto. elim (rotation_def (I:=I) (A:=J) (B:=D) (a:=- (/ 2 * a))); auto; intros. elim (rotation_def (I:=J) (A:=I) (B:=C) (a:=/ 2 * b)); auto; intros. rewrite <- H25. rewrite <- (mes_oppx (A:=I) (B:=J) (C:=I) (D:=D) (x:=- (/ 2 * a))); auto. repeat rewrite <- add_mes_compatible. replace (- - (/ 2 * a)) with (/ 2 * a). replace (/ 2 * a + (pi + / 2 * b) + (/ 2 * a + (pi + / 2 * b))) with (/ 2 * a + / 2 * a + (/ 2 * b + / 2 * b) + (pi + pi)). replace (/ 2 * a + / 2 * a) with a; auto with real. replace (/ 2 * b + / 2 * b) with b; auto with real. replace (pi + pi) with deuxpi; auto. rewrite add_mes_compatible. rewrite pi_plus_pi. repeat rewrite <- add_mes_compatible. replace (a + b + 0) with (a + b); auto. ring. ring. ring. repeat rewrite Chasles; auto. rewrite H6; rewrite H23; auto. apply deux_mes_angle_rotation. replace (/ 2 * b + / 2 * b) with b; auto with real. elim (rotation_def (I:=J) (A:=I) (B:=C) (a:=/ 2 * b)); auto; intros. rewrite <- H8 in H17. generalize (reflexion_symetrie (A:=I) (B:=J) (M:=M') (M':=M1)); intros. rewrite H9; auto. generalize (axe_reflexion_droite (A:=J) (B:=I) (C:=I) (M:=M1) (M':=N1)); intros. rewrite H11; auto with geo. rewrite H5; rewrite H24; auto. apply deux_mes_angle_rotation. replace (/ 2 * a + / 2 * a) with a; auto with real. elim (rotation_def (I:=I) (A:=J) (B:=D) (a:=- (/ 2 * a))); auto; intros. rewrite <- (mes_oppx (A:=I) (B:=J) (C:=I) (D:=D) (x:=- (/ 2 * a))); auto. replace (- - (/ 2 * a)) with (/ 2 * a); auto. ring. absurd (paralleles (droite J C) (droite I D)); auto with geo. cut (double_AV (cons_AV (vec I D) (vec J C)) = image_angle (a + b)); intros. apply angle_non_paralleles; auto. red in |- *; intros; apply H. rewrite <- H6; auto. rewrite add_mes_compatible; auto. unfold double_AV in |- *. replace (cons_AV (vec I D) (vec J C)) with (plus (cons_AV (vec I D) (vec I J)) (plus (cons_AV (vec I J) (vec J I)) (cons_AV (vec J I) (vec J C)))); auto. rewrite <- angle_plat; auto. elim (rotation_def (I:=I) (A:=J) (B:=D) (a:=- (/ 2 * a))); auto; intros. elim (rotation_def (I:=J) (A:=I) (B:=C) (a:=/ 2 * b)); auto; intros. rewrite <- H9. rewrite <- (mes_oppx (A:=I) (B:=J) (C:=I) (D:=D) (x:=- (/ 2 * a))); auto. repeat rewrite <- add_mes_compatible. replace (- - (/ 2 * a)) with (/ 2 * a). replace (/ 2 * a + (pi + / 2 * b) + (/ 2 * a + (pi + / 2 * b))) with (/ 2 * a + / 2 * a + (/ 2 * b + / 2 * b) + (pi + pi)). replace (/ 2 * a + / 2 * a) with a; auto with real. replace (/ 2 * b + / 2 * b) with b; auto with real. replace (pi + pi) with deuxpi; auto. rewrite add_mes_compatible. rewrite pi_plus_pi. repeat rewrite <- add_mes_compatible. replace (a + b + 0) with (a + b); auto. ring. ring. ring. repeat rewrite Chasles; auto. apply (image_distinct_centre (I:=I) (A:=J) (B:=D) (a:=- (/ 2 * a))); auto. apply (image_distinct_centre (I:=J) (A:=I) (B:=C) (a:=/ 2 * b)); auto. apply geometrie_plane; auto. apply (image_distinct_centre (I:=J) (A:=I) (B:=C) (a:=/ 2 * b)); auto. apply (image_distinct_centre (I:=I) (A:=J) (B:=D) (a:=- (/ 2 * a))); auto. Qed. Theorem translation_reflexion_axe_parallele_commutent : forall A B C D M M1 M2 N1 N2 : PO, A <> B -> C <> D -> paralleles (droite A B) (droite C D) -> M1 = translation A B M -> M2 = reflexion C D M1 -> N1 = reflexion C D M -> N2 = translation A B N1 -> N2 = M2. intros A B C D M M1 M2 N1 N2 H H0 H1 H2 H3 H4 H5; try assumption. rewrite H3. cut (vec M M1 = vec A B). intros H100. cut (vec N1 N2 = vec A B). intros H102. cut (vec M M1 = vec N1 N2); intros. elim (paralleles_vecteur (A:=C) (B:=D) (C:=A) (D:=B)); intros; auto with geo. cut (x <> 0); intros. elim (classic (alignes C D M)); intros. generalize (reflexion_axe (A:=C) (B:=D) (M:=M)); intros. cut (N1 = M); intros. rewrite H11 in H6. cut (alignes C D M1); intros. generalize (reflexion_axe (A:=C) (B:=D) (M:=M1)); intros. rewrite <- H13; auto. apply conversion_PP with (a := 1) (b := 1); auto. RingPP2 H6; Ringvec. auto with real. halignes H9 ipattern:x0. apply colineaire_alignes with (x0 + / x). replace (vec C M1) with (add_PP (vec C M) (vec M M1)). rewrite H12. rewrite <- (translation_vecteur H2). replace (vec A B) with (mult_PP (/ x) (vec C D)). Ringvec. rewrite H7. replace (mult_PP (/ x) (mult_PP x (vec A B))) with (mult_PP (/ x * x) (vec A B)). replace (/ x * x) with 1; auto with real. Ringvec. Ringvec. Ringvec. rewrite H10; auto. elim (existence_projete_orthogonal (A:=C) (B:=D) M); auto; intros K H10. elim existence_representant_vecteur with (A := K) (B := A) (C := B); intros L H11. generalize (reflexion_def (A:=C) (B:=D) (M:=M) (M':=N1) (H:=K)); intros H12. cut (L = milieu M1 N2); intros. generalize (reflexion_axe_orthogonal_segment (A:=C) (B:=D) (M:=M) (M':=N1)); intros. generalize (paralleles_orthogonal (A:=M) (B:=N1) (C:=M1) (D:=N2) (E:=C) (F:=D)); intros. apply reflexion_def2 with L; auto. elim (def_projete_orthogonal2 (A:=C) (B:=D) (C:=M) (H:=K)); auto; intros. apply def_projete_orthogonal; auto. apply (paralleles_alignes1 (A:=A) (B:=B) (C:=C) (D:=D) (E:=K) (F:=L)); auto. replace (vec L M1) with (vec K M); auto. apply egalite_vecteur. rewrite H11; auto with geo. apply milieu_vecteur_double; auto. apply vecteur_milieu. replace (vec M1 N2) with (vec M N1); auto with geo. rewrite H12; auto. cut (2 <> 0); intros; auto with real. replace (mult_PP (/ 2) (mult_PP 2 (vec M K))) with (vec M K); auto. replace (vec M1 L) with (vec M K); auto. apply egalite_vecteur; auto. rewrite H11; auto. Fieldvec 2. red in |- *; intros; apply H0. apply vecteur_nul_conf. rewrite H7; rewrite H8; Ringvec. rewrite H100; auto. symmetry in |- *. apply translation_vecteur; auto. symmetry in |- *. apply translation_vecteur; auto. Qed.HighSchoolGeometry/composee_translation_rotation.v0000644000076500007650000004217212073525612022570 0ustar coqcoq00000000000000(* This program is free software; you can redistribute it and/or *) (* modify it under the terms of the GNU Lesser General Public License *) (* as published by the Free Software Foundation; either version 2.1 *) (* of the License, or (at your option) any later version. *) (* *) (* This program is distributed in the hope that it will be useful, *) (* but WITHOUT ANY WARRANTY; without even the implied warranty of *) (* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *) (* GNU General Public License for more details. *) (* *) (* You should have received a copy of the GNU Lesser General Public *) (* License along with this program; if not, write to the Free *) (* Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA *) (* 02110-1301 USA *) Require Export composee_reflexions. Set Implicit Arguments. Unset Strict Implicit. Theorem composee_translation_rotation : forall (I A B : PO) (a : R), image_angle a <> image_angle 0 -> exists J : PO, (forall M M1 M2 : PO, M1 = translation A B M -> M2 = rotation I a M1 -> M2 = rotation J a M). intros I A B a H50; try assumption. elim (classic (A = B)); intros H2. exists I; intros. generalize (translation_vecteur (I:=A) (J:=B) (A:=M) (A':=M1)); intros. cut (M1 = M); intros. rewrite H3 in H0; auto. symmetry in |- *. apply vecteur_nul_conf. rewrite <- H1; auto. rewrite <- H2; Ringvec. elim existence_representant_vecteur with (A := I) (B := milieu A B) (C := A); intros D H3; try clear existence_representant_vecteur; try exact H3. cut (vec A B = mult_PP 2 (mult_PP (/ 2) (vec A B))); intros. cut (I <> D); intros. elim existence_rotation_Ia with (I := I) (M := D) (a := pisurdeux); intros C H7. cut (I <> C); auto; intros. cut (orthogonal (vec I C) (vec I D)); intros. elim existence_representant_vecteur with (A := C) (B := I) (C := D); intros E H10; try clear existence_representant_vecteur; try exact H10. generalize (egalite_vecteur (A:=C) (B:=E) (C:=I) (D:=D)). intros H33. elim existence_representant_vecteur with (A := D) (B := A) (C := B); intros F H11; try clear existence_representant_vecteur; try exact H11. cut (D <> E); intros. cut (paralleles (droite I C) (droite D E)); intros. elim existence_rotation_Ia with (I := I) (M := C) (a := / 2 * a); intros G H18. cut (I <> G); intros. generalize (rotation_def (I:=I) (A:=C) (B:=G) (a:=/ 2 * a)); intros. generalize (position_relative_droites_coplanaires (A:=D) (B:=E) (C:=I) (D:=G)); intros. elim H12; intros; auto with geo. elim def_concours2 with (A := D) (B := E) (C := I) (D := G); [ intros J H27; try clear def_concours2; try exact H27 | auto | auto | auto ]. elim H27; intros H28 H29; try clear H27; try exact H29. cut (J <> I); intros. exists J; intros. generalize (translation_vecteur (I:=A) (J:=B) (A:=M) (A':=M1)); intros. elim existence_reflexion_AB with (A := D) (B := E) (M := M); [ intros M' H23; try clear existence_reflexion_AB | auto ]. elim existence_reflexion_AB with (A := I) (B := C) (M := M'); [ intros N H24; try clear existence_reflexion_AB | auto ]. generalize (composee_reflexions_axes_paralleles (A:=D) (B:=E) (C:=I) (D:=C) (E:=F) (M:=M) (M':=N) (M1:=M')); intros. cut (N = translation D F M); intros. cut (M1 = N); intros. elim existence_reflexion_AB with (A := I) (B := C) (M := M1); [ intros N' H31; try clear existence_reflexion_AB | auto ]. elim existence_reflexion_AB with (A := I) (B := G) (M := N'); [ intros N1 H32; try clear existence_reflexion_AB | auto ]. generalize (reflexion_symetrie (A:=I) (B:=C) (M:=M') (M':=N)); intros. rewrite H21 in H31. cut (N' = M'); intros. generalize (composee_reflexions_axes_secants (A:=I) (B:=C) (C:=G) (M:=N) (M':=N1) (M1:=N') (a:=/ 2 * a)); intros. rewrite H16. rewrite H21. replace a with (/ 2 * a + / 2 * a); auto. rewrite <- H26; auto. elim H9; intros. cut (D <> J \/ E <> J); intros. elim H34; [ intros H35; try clear H34 | intros H35; try clear H34; try exact H35 ]. mesure J D J I. cut (double_AV (cons_AV (vec J D) (vec J I)) = image_angle a); intros. generalize (axe_reflexion_droite (A:=D) (B:=E) (C:=J) (M:=M) (M':=M')); intros. generalize (axe_reflexion_droite (A:=I) (B:=G) (C:=J) (M:=M') (M':=N1)); intros. generalize (composee_reflexions_axes_secants (A:=J) (B:=D) (C:=I) (M:=M) (M':=N1) (M1:=M') (a:=x)); intros. rewrite H39; auto. apply deux_mes_angle_rotation. rewrite add_mes_compatible. unfold double_AV in H36. rewrite H34; rewrite H36. replace (/ 2 * a + / 2 * a) with a; auto with real. apply (axe_reflexion_droite (A:=I) (B:=G) (C:=J) (M:=M') (M':=N1)); auto. rewrite H32; rewrite H25; auto. rewrite (angles_et_paralleles (A:=J) (B:=D) (C:=J) (D:=I) (E:=I) (F:=C) (G:=I) (I:=G)). unfold double_AV in |- *; rewrite <- H30. rewrite <- add_mes_compatible. replace (/ 2 * a + / 2 * a) with a; auto with real. auto. red in |- *; intros. rewrite H36 in H28. absurd (alignes D E I); auto. auto. auto. generalize (alignes_paralleles (A:=D) (B:=E) (C:=J)); intros. apply paralleles_trans with (C := D) (D := E); auto with geo. apply paralleles_trans with (C := D) (D := J); auto with geo. generalize (alignes_paralleles (A:=I) (B:=G) (C:=J)); intros. apply paralleles_trans with (C := I) (D := J); auto with geo. mesure J E J I. cut (plus (cons_AV (vec J E) (vec J I)) (cons_AV (vec J E) (vec J I)) = image_angle a); intros. generalize (axe_reflexion_droite (A:=E) (B:=D) (C:=J) (M:=M) (M':=M')); intros. generalize (axe_reflexion_droite (A:=I) (B:=G) (C:=J) (M:=M') (M':=N1)); intros. generalize (composee_reflexions_axes_secants (A:=J) (B:=E) (C:=I) (M:=M) (M':=N1) (M1:=M') (a:=x)); intros. rewrite H39; auto. apply deux_mes_angle_rotation. rewrite add_mes_compatible. unfold double_AV in H36. rewrite H34; rewrite H36. replace (/ 2 * a + / 2 * a) with a; auto with real. apply (axe_reflexion_droite (A:=E) (B:=D) (C:=J) (M:=M) (M':=M')); auto with geo. apply (axe_reflexion_droite (A:=D) (B:=E) (C:=E) (M:=M) (M':=M')); auto with geo. apply (axe_reflexion_droite (A:=I) (B:=G) (C:=J) (M:=M') (M':=N1)); auto with geo. rewrite H32; rewrite H25; auto. replace (plus (cons_AV (vec J E) (vec J I)) (cons_AV (vec J E) (vec J I))) with (double_AV (cons_AV (vec J E) (vec J I))); auto. rewrite (angles_et_paralleles (A:=J) (B:=E) (C:=J) (D:=I) (E:=I) (F:=C) (G:=I) (I:=G)). unfold double_AV in |- *. rewrite <- H30. rewrite <- add_mes_compatible. replace (/ 2 * a + / 2 * a) with a; auto with real. auto. auto. auto. auto. generalize (alignes_paralleles (A:=E) (B:=D) (C:=J)); intros. apply paralleles_trans with (C := D) (D := E); auto with geo. apply paralleles_trans with (C := E) (D := D); auto with geo. apply paralleles_trans with (C := E) (D := J); auto with geo. generalize (alignes_paralleles (A:=I) (B:=G) (C:=J)); intros. apply paralleles_trans with (C := I) (D := J); auto with geo. apply not_and_or. red in |- *; intros. elim H34; intros. apply H5. rewrite H36; rewrite H35; auto. auto. auto. elim H9; intros; auto with real. auto with real. rewrite H22; auto. rewrite H20. apply rec_translation_vecteur. rewrite <- H17; auto. apply H19; auto. replace (vec D E) with (vec I C). apply ortho_sym; auto with geo. apply egalite_vecteur; auto with geo. apply rec_translation_vecteur. apply egalite_vecteur; auto with geo. replace (vec D I) with (mult_PP (-1) (vec I D)). rewrite <- H10; Ringvec. Ringvec. apply rec_translation_vecteur. replace (vec D I) with (mult_PP (-1) (vec I D)). replace (vec I F) with (add_PP (vec I D) (vec D F)). rewrite H11; rewrite H3; auto. rewrite (milieu_vecteur_double (A:=A) (B:=B) (M:=milieu A B)); auto. Ringvec. Ringvec. Ringvec. red in |- *; intros. rewrite H14 in H28. absurd (alignes D E I); auto. apply orthogonal_non_alignes; auto. replace (vec D E) with (vec I C); auto with geo. absurd (paralleles (droite D E) (droite I G)); auto with geo. generalize (angle_non_paralleles (A:=I) (B:=C) (C:=I) (D:=G)); intros. apply non_paralleles_trans with (A := I) (B := C); auto with geo. red in |- *; intros. apply H14; auto with geo. elim H9; auto; intros. unfold double_AV in |- *; rewrite <- H17. rewrite <- add_mes_compatible. replace (/ 2 * a + / 2 * a) with a; auto with real. apply image_distinct_centre with (2 := H18); auto with geo. apply (colineaires_paralleles (k:=1) (A:=I) (B:=C) (C:=D) (D:=E)); auto. replace (vec D E) with (vec I C); auto with geo. Ringvec. red in |- *; intros; apply H1. symmetry in |- *. apply vecteur_nul_conf; auto. rewrite H33; auto. rewrite H5; Ringvec. elim (rotation_def (I:=I) (A:=D) (B:=C) (a:=pisurdeux)); auto with geo; intros. apply image_distinct_centre with (2 := H7); auto. red in |- *; intros; apply H2. apply vecteur_nul_conf; auto. rewrite (milieu_vecteur_double (A:=A) (B:=B) (M:=milieu A B)); auto. replace (vec A (milieu A B)) with (mult_PP (-1) (vec (milieu A B) A)). rewrite <- H3; rewrite H0; auto. Ringvec. Ringvec. cut (2 <> 0); intros; auto with real. Fieldvec 2. Qed. Theorem composee_rotation_translation : forall (I A B : PO) (a : R), image_angle a <> image_angle 0 -> ex (fun J : PO => forall M M1 M2 : PO, M1 = rotation I a M -> M2 = translation A B M1 -> M2 = rotation J a M). intros I A B a H50; try assumption. elim (classic (A = B)); intros H2. exists I; intros. generalize (translation_vecteur (I:=A) (J:=B) (A:=M1) (A':=M2)); intros. cut (M1 = M2); intros. rewrite H3 in H; auto. apply vecteur_nul_conf. rewrite <- H1; auto. rewrite <- H2; Ringvec. elim existence_representant_vecteur with (A := I) (B := milieu A B) (C := B); intros D H3; try clear existence_representant_vecteur; try exact H3. cut (vec A B = mult_PP 2 (mult_PP (/ 2) (vec A B))); intros. cut (I <> D); intros. elim existence_rotation_Ia with (I := I) (M := D) (a := pisurdeux); intros C H7. cut (I <> C); auto with geo; intros. cut (orthogonal (vec I C) (vec I D)); intros. elim existence_representant_vecteur with (A := C) (B := I) (C := D); intros E H10; try clear existence_representant_vecteur; try exact H10. generalize (egalite_vecteur (A:=C) (B:=E) (C:=I) (D:=D)). intros H33. elim existence_representant_vecteur with (A := I) (B := A) (C := B); intros F H11; try clear existence_representant_vecteur; try exact H11. cut (D <> E); intros. cut (paralleles (droite I C) (droite D E)); intros. elim existence_rotation_Ia with (I := I) (M := C) (a := - (/ 2 * a)); intros G H18. cut (I <> G); intros. generalize (rotation_def (I:=I) (A:=C) (B:=G) (a:=- (/ 2 * a))); intros. generalize (position_relative_droites_coplanaires (A:=D) (B:=E) (C:=I) (D:=G)); intros. elim H12; intros; auto with geo. elim def_concours2 with (A := D) (B := E) (C := I) (D := G); [ intros J H28; try clear def_concours2; try exact H28 | auto | auto | auto ]. elim H28; intros. clear H28. cut (J <> I); intros. exists J; intros. generalize (translation_vecteur (I:=A) (J:=B) (A:=M1) (A':=M2)); intros. elim existence_reflexion_AB with (A := I) (B := G) (M := M); [ intros N' H25; try clear existence_reflexion_AB | auto ]. elim existence_reflexion_AB with (A := I) (B := C) (M := N'); [ intros N1 H26; try clear existence_reflexion_AB | auto ]. elim existence_reflexion_AB with (A := I) (B := C) (M := M1); [ intros M' H27; try clear existence_reflexion_AB | auto ]. elim existence_reflexion_AB with (A := D) (B := E) (M := M'); [ intros N H29; try clear existence_reflexion_AB | auto ]. generalize (composee_reflexions_axes_paralleles (A:=I) (B:=C) (C:=D) (D:=E) (E:=F) (M:=M1) (M':=N) (M1:=M')); intros. cut (N = translation I F M1); intros. cut (M1 = N1); intros. cut (M2 = N); intros. generalize (reflexion_symetrie (A:=I) (B:=C) (M:=N') (M':=N1)); intros. rewrite H23 in H27. cut (N' = M'); intros. generalize (composee_reflexions_axes_secants (A:=I) (B:=G) (C:=C) (M:=M) (M':=M1) (M1:=N') (a:=/ 2 * a)); intros. elim H9; auto; intros. rewrite H24. cut (D <> J \/ E <> J); intros. elim H35; intros. mesure J I J D. cut (plus (cons_AV (vec J I) (vec J D)) (cons_AV (vec J I) (vec J D)) = image_angle a); intros. generalize (axe_reflexion_droite (A:=I) (B:=G) (C:=J) (M:=M) (M':=N')); intros. generalize (axe_reflexion_droite (A:=D) (B:=E) (C:=J) (M:=N') (M':=N)); intros. generalize (composee_reflexions_axes_secants (A:=J) (B:=I) (C:=D) (M:=M) (M':=N) (M1:=N') (a:=x)); intros. rewrite H41; auto. apply deux_mes_angle_rotation. rewrite add_mes_compatible. rewrite H37; rewrite H38; auto. rewrite H40; auto. rewrite H30; rewrite H29; auto. replace (plus (cons_AV (vec J I) (vec J D)) (cons_AV (vec J I) (vec J D))) with (double_AV (cons_AV (vec J I) (vec J D))); auto. rewrite (angles_et_paralleles (A:=J) (B:=I) (C:=J) (D:=D) (E:=I) (F:=G) (G:=I) (I:=C)); auto. unfold double_AV in |- *. rewrite <- (mes_oppx (A:=I) (B:=C) (C:=I) (D:=G) (x:=- (/ 2 * a))); auto. rewrite <- add_mes_compatible. replace (- - (/ 2 * a)) with (/ 2 * a); auto. replace (/ 2 * a + / 2 * a) with a; auto with real. ring. generalize (alignes_paralleles (A:=I) (B:=G) (C:=J)); intros. apply paralleles_trans with (C := I) (D := J); auto with geo. generalize (alignes_paralleles (A:=D) (B:=E) (C:=J)); intros. apply paralleles_trans with (C := D) (D := E); auto. apply paralleles_trans with (C := D) (D := J); auto with geo. mesure J I J E. cut (plus (cons_AV (vec J I) (vec J E)) (cons_AV (vec J I) (vec J E)) = image_angle a); intros. generalize (axe_reflexion_droite (A:=I) (B:=G) (C:=J) (M:=M) (M':=N')); intros. generalize (axe_reflexion_droite (A:=E) (B:=D) (C:=J) (M:=N') (M':=N)); intros. generalize (composee_reflexions_axes_secants (A:=J) (B:=I) (C:=E) (M:=M) (M':=N) (M1:=N') (a:=x)); intros. rewrite H41; auto. apply deux_mes_angle_rotation. rewrite add_mes_compatible. rewrite H37; rewrite H38; auto. rewrite H40; auto with geo. apply (axe_reflexion_droite (A:=D) (B:=E) (C:=E) (M:=N') (M':=N)); auto with geo. rewrite H29; rewrite H30; auto. replace (plus (cons_AV (vec J I) (vec J E)) (cons_AV (vec J I) (vec J E))) with (double_AV (cons_AV (vec J I) (vec J E))); auto. rewrite (angles_et_paralleles (A:=J) (B:=I) (C:=J) (D:=E) (E:=I) (F:=G) (G:=I) (I:=C)); auto. unfold double_AV in |- *. rewrite <- (mes_oppx (A:=I) (B:=C) (C:=I) (D:=G) (x:=- (/ 2 * a))); auto. rewrite <- add_mes_compatible. replace (- - (/ 2 * a)) with (/ 2 * a); auto. replace (/ 2 * a + / 2 * a) with a; auto with real. ring. generalize (alignes_paralleles (A:=I) (B:=G) (C:=J)); intros. apply paralleles_trans with (C := I) (D := J); auto with geo. generalize (alignes_paralleles (A:=E) (B:=D) (C:=J)); intros. apply paralleles_trans with (C := D) (D := E); auto. apply paralleles_trans with (C := E) (D := D); auto with geo. apply paralleles_trans with (C := E) (D := J); auto with geo. apply not_and_or. red in |- *; intros. elim H35; intros. apply H5. rewrite H36; rewrite H37; auto. rewrite H28; auto. rewrite H21; auto. apply rec_translation_vecteur. rewrite H11; auto. apply rec_translation_vecteur; auto with geo. apply rec_translation_vecteur; auto with geo. replace (vec D F) with (add_PP (vec I F) (mult_PP (-1) (vec I D))). rewrite H11; rewrite H3; auto. rewrite (milieu_vecteur_double (A:=A) (B:=B) (M:=milieu A B)); auto. rewrite <- (milieu_vecteur (A:=A) (B:=B) (M:=milieu A B)); auto. Ringvec. Ringvec. generalize (composee_reflexions_axes_secants (A:=I) (B:=G) (C:=C) (M:=M) (M':=N1) (M1:=N') (a:=/ 2 * a)); intros. rewrite H17; rewrite H23; auto. replace (/ 2 * a + / 2 * a) with a; auto with real. rewrite <- (mes_oppx (A:=I) (B:=C) (C:=I) (D:=G) (x:=- (/ 2 * a))); auto. replace (- - (/ 2 * a)) with (/ 2 * a); auto. ring. elim H9; auto. apply H21; auto. apply rec_translation_vecteur; auto with geo. apply rec_translation_vecteur; auto with geo. replace (vec D F) with (add_PP (vec I F) (mult_PP (-1) (vec I D))). rewrite H11; rewrite H3; auto. rewrite (milieu_vecteur_double (A:=A) (B:=B) (M:=milieu A B)); auto. rewrite <- (milieu_vecteur (A:=A) (B:=B) (M:=milieu A B)); auto. Ringvec. Ringvec. red in |- *; intros. rewrite H16 in H14. absurd (alignes D E I); auto. apply orthogonal_non_alignes; auto with geo. replace (vec D E) with (vec I C); auto with geo. absurd (paralleles (droite D E) (droite I G)); auto. generalize (angle_non_paralleles (A:=I) (B:=G) (C:=I) (D:=C)); intros H31. apply non_paralleles_trans with (A := I) (B := C); auto with geo. red in |- *; intros. apply H31; auto. elim H9; auto; intros. unfold double_AV in |- *. rewrite <- (mes_oppx (A:=I) (B:=C) (C:=I) (D:=G) (x:=- (/ 2 * a))); auto. rewrite <- add_mes_compatible. replace (- - (/ 2 * a)) with (/ 2 * a); auto with geo. replace (/ 2 * a + / 2 * a) with a; auto with real. ring. apply image_distinct_centre with (2 := H18); auto. apply (colineaires_paralleles (k:=1) (A:=I) (B:=C) (C:=D) (D:=E)); auto. replace (vec D E) with (vec I C); auto with geo. Ringvec. red in |- *; intros; apply H1. symmetry in |- *. apply vecteur_nul_conf; auto. rewrite H33; auto. rewrite H5; Ringvec. elim (rotation_def (I:=I) (A:=D) (B:=C) (a:=pisurdeux)); auto with geo; intros. apply image_distinct_centre with (2 := H7); auto with geo. red in |- *; intros; apply H2. apply vecteur_nul_conf; auto. replace (vec A B) with (mult_PP 2 (vec (milieu A B) B)). rewrite <- H3. rewrite H0. Ringvec. rewrite (milieu_vecteur_double (A:=A) (B:=B) (M:=milieu A B)); auto. rewrite <- (milieu_vecteur (A:=A) (B:=B) (M:=milieu A B)); auto. cut (2 <> 0); intros; auto with real. Fieldvec 2. Qed.HighSchoolGeometry/contact.v0000755000076500007650000005562712073525613016071 0ustar coqcoq00000000000000(* This program is free software; you can redistribute it and/or *) (* modify it under the terms of the GNU Lesser General Public License *) (* as published by the Free Software Foundation; either version 2.1 *) (* of the License, or (at your option) any later version. *) (* *) (* This program is distributed in the hope that it will be useful, *) (* but WITHOUT ANY WARRANTY; without even the implied warranty of *) (* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *) (* GNU General Public License for more details. *) (* *) (* You should have received a copy of the GNU Lesser General Public *) (* License along with this program; if not, write to the Free *) (* Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA *) (* 02110-1301 USA *) Require Export complements_cercle. Set Implicit Arguments. Unset Strict Implicit. Lemma existence_intersection_droite_cercle_centre : forall (r : R) (A B : PO), A <> B -> r >= 0 -> exists C : PO, alignes A B C /\ distance A C = r. intros. assert (distance A B <> 0); auto with geo. elim existence_representant_mult_vecteur with (A := A) (B := A) (C := B) (k := / distance A B * r); intros C H2. exists C. split; [ try assumption | idtac ]. apply (colineaire_alignes H2); auto. assert (Rsqr (distance A C) = Rsqr r). unfold Rsqr in |- *; repeat rewrite <- carre_scalaire_distance. rewrite H2. Simplscal. rewrite carre_scalaire_distance. field. auto with real. auto with real. apply Rsqr_inj; auto with geo real. Qed. Theorem intersection_cercle_droite : forall A B O D H : PO, A <> B -> H = projete_orthogonal A B O -> distance O H <= distance O D -> exists C : PO, alignes A B C /\ cercle_rayon O D C. icercle. assert (Rsqr (distance O D) + - Rsqr (distance O H) >= 0). unfold Rsqr in |- *. RReplace (distance O D * distance O D + - (distance O H * distance O H)) ((distance O D + - distance O H) * (distance O D + distance O H)). assert (distance O D >= 0); auto with geo. assert (distance O H >= 0); auto with geo. assert (distance O D + distance O H >= 0). fourier. assert (distance O D + - distance O H >= 0). fourier. RReplace 0 (0 * (distance O D + distance O H)). apply Rmult_ge_compat_r; auto. elim def_projete_orthogonal2 with (A := A) (B := B) (C := O) (H := H); [ intros; auto | auto | auto ]. discrimine H A. assert (H <> B). contrapose H0. rewrite <- H7; auto. elim existence_intersection_droite_cercle_centre with (r := sqrt (Rsqr (distance O D) + - Rsqr (distance O H))) (A := H) (B := B); [ intros C H8; elim H8; [ intros H9 H10; try clear H8; try exact H10 ] | auto | auto ]. exists C; split; auto. assert (Rsqr (distance O D) = Rsqr (distance O C)). elim (Pythagore H O C); intros. rewrite H8; auto. replace (Rsqr (distance H C)) with (distance H C * distance H C); auto with real. rewrite H10. rewrite sqrt_sqrt; auto with real. rewrite (distance_sym H O); ring. halignes H9 ipattern:k. apply ortho_sym. rewrite H12; pattern H at 1 in |- *; rewrite H6; auto with geo. auto with real. apply Rsqr_inj; auto with geo real. auto with real. elim existence_intersection_droite_cercle_centre with (r := sqrt (Rsqr (distance O D) + - Rsqr (distance O H))) (A := H) (B := A); [ intros C H8; elim H8; [ intros H9 H10; try clear H8; try exact H10 ] | auto | auto ]. exists C; split; auto. halignes H9 ipattern:k. halignes H4 ipattern:k'. apply colineaire_alignes with (k' + - (k * k')). VReplace (vec A C) (add_PP (vec A H) (vec H C)). rewrite H7. VReplace (vec H A) (mult_PP (-1) (vec A H)). rewrite H8; Ringvec. assert (Rsqr (distance O D) = Rsqr (distance O C)). elim (Pythagore H O C); intros. rewrite H7; auto. replace (Rsqr (distance H C)) with (distance H C * distance H C); auto with real. rewrite H10. rewrite sqrt_sqrt; auto with real. rewrite (distance_sym H O); ring. halignes H9 ipattern:k. halignes H4 ipattern:k'. apply ortho_sym. rewrite H11. VReplace (vec H A) (mult_PP (-1) (vec A H)). rewrite H12. VReplace (mult_PP k (mult_PP (-1) (mult_PP k' (vec A B)))) (mult_PP (- (k * k')) (vec A B)). auto with geo. apply Rsqr_inj; auto with geo real. auto with real. Qed. Lemma unicite_contact_cercle_droite_tangente : forall A B O D H C : PO, A <> B -> H = projete_orthogonal A B O -> cercle_rayon O D H -> alignes A B C -> cercle_rayon O D C -> H = C. icercle. elim def_projete_orthogonal2 with (A := A) (B := B) (C := O) (H := H); [ intros; auto | auto | auto ]. elim (Pythagore H O C); intros. assert (distance H C = 0); auto with geo. apply Rsqr_inj; auto with geo real. assert (Rsqr (distance O C) + - Rsqr (distance H O) = 0). rewrite (distance_sym H O). rewrite <- H4; rewrite <- H2; (unfold Rsqr in |- *; ring). replace (Rsqr 0) with 0; [ idtac | unfold Rsqr in |- *; ring ]. rewrite <- H9; rewrite H7; auto. unfold Rsqr in |- *; ring. halignes H3 ipattern:x. halignes H5 ipattern:y. apply ortho_sym. replace (vec H C) with (mult_PP (x + - y) (vec A B)); auto with geo. VReplace (vec H C) (add_PP (vec A C) (mult_PP (-1) (vec A H))). rewrite H11; rewrite H10; Ringvec. Qed. Theorem tangente_cercle_contact_unique : forall A B O M C : PO, B <> M -> tangente_cercle O A B M -> alignes B M C -> cercle_rayon O A C -> B = C. intros. hcercle H0. assert (B = projete_orthogonal B M O). apply def_projete_orthogonal; auto with geo. apply (unicite_contact_cercle_droite_tangente (A:=B) (B:=M) (O:=O) (D:=A) (H:=B) (C:=C)); auto. Qed. Theorem intersection2_cercle_droite : forall A B O H : PO, A <> B -> O <> A -> H = projete_orthogonal A B O -> distance O H < distance O A -> exists C : PO, A <> C /\ alignes A B C /\ cercle_rayon O A C. icercle. assert (Rsqr (distance O A) + - Rsqr (distance O H) > 0). unfold Rsqr in |- *. assert (distance O A <> 0); auto with geo. cut (distance O A >= 0); auto with geo. unfold Rge in |- *; intros. elim H5; [ intros H6; try clear H5 | intros H6; absurd (distance O A = 0); auto ]. RReplace (distance O A * distance O A + - (distance O H * distance O H)) ((distance O A + - distance O H) * (distance O A + distance O H)). assert (0 < distance O A + - distance O H). fourier. assert (0 < distance O A + distance O H). apply Rplus_lt_le_0_compat; auto with real geo. assert (0 < (distance O A + - distance O H) * (distance O A + distance O H)). apply Rmult_lt_0_compat; auto with real. fourier. elim def_projete_orthogonal2 with (A := A) (B := B) (C := O) (H := H); [ intros; auto | auto | auto ]. assert (H <> A). assert (distance O H <> distance O A); auto with real. contrapose H7. rewrite <- H8; auto. halignes H5 ipattern:k. elim existence_symetrique with (A := H) (B := A); (intros C; intros). assert (H = milieu A C); auto with geo. assert (vec A C = mult_PP 2 (vec A H)); auto with geo. exists C; split; auto. generalize (distinct_produit_vecteur (A:=A) (B:=H) (C:=C) (a:=2)); intros H18; apply H18; auto with real geo. split; [ idtac | try assumption ]. apply colineaire_alignes with (2 * k). rewrite H11; rewrite H8; Ringvec. assert (Rsqr (distance O A) = Rsqr (distance O C)). elim (Pythagore H O C); intros. rewrite H12; auto. replace (Rsqr (distance H C)) with (Rsqr (distance H A)). elim (Pythagore H O A); intros. rewrite H14; auto. apply ortho_sym. replace (vec H A) with (mult_PP (- k) (vec A B)). auto with geo. VReplace (vec H A) (mult_PP (-1) (vec A H)). rewrite H8; Ringvec. rewrite (milieu_distance H10); auto. replace (vec H C) with (vec A H). apply ortho_sym. rewrite H8; auto with geo. auto with geo. auto with geo. Qed. Definition cercles_tangents (O A O' A' : PO) := O <> A -> O' <> A' -> exists B : PO, alignes O B O' /\ cercle_rayon O A B /\ cercle_rayon O' A' B. Lemma auto_cercles_tangents : forall O A : PO, O <> A -> cercles_tangents O A O A. unfold cercles_tangents in |- *; intros. exists A. icercle. Qed. Lemma cercles_concentriques_tangents_egaux : forall O A A' : PO, O <> A -> O <> A' -> cercles_tangents O A O A' -> cercle_rayon O A A'. unfold cercles_tangents in |- *; icercle. elim H1; [ intros B H2; elim H2; [ intros H3 H4; elim H4; [ intros H5 H6; try clear H4 H2 H1; try exact H5 ] ] | auto | auto ]. rewrite H6; auto. Qed. Lemma cercles_tangents_tangente_commune : forall O A O' A' : PO, O <> A -> O' <> A' -> cercles_tangents O A O' A' -> exists B : PO, (exists M : PO, B <> M /\ tangente_cercle O A B M /\ tangente_cercle O' A' B M). unfold cercles_tangents, tangente_cercle in |- *; intros. elim H1; [ intros B H2; elim H2; [ intros H3 H4; elim H4; [ intros H5 H6; try clear H4 H2 H1; try exact H5 ] ] | auto | auto ]. assert (O <> B). hcercle H5. apply (isometrie_distinct (A:=O) (B:=A) (A':=O) (B':=B)); auto with geo. soit_orthogonal B O ipattern:M. exists B; exists M. split; [ auto | split; [ split; [ try assumption | auto with geo ] | try assumption ] ]. split; [ try assumption | idtac ]. halignes H3 ipattern:k. apply ortho_sym. VReplace (vec B O') (add_PP (vec B O) (vec O O')). rewrite H7. VReplace (add_PP (vec B O) (mult_PP k (vec O B))) (mult_PP (- k + 1) (vec B O)). auto with geo. Qed. Lemma tangente_commune_cercles_tangents : forall O A O' A' B M : PO, O <> A -> O' <> A' -> B <> M -> tangente_cercle O A B M -> tangente_cercle O' A' B M -> cercles_tangents O A O' A'. unfold cercles_tangents, tangente_cercle in |- *; intros. repeat applatit_and. exists B. split; [ idtac | split; try assumption ]. assert (O <> B). hcercle H3. apply (isometrie_distinct (A:=O) (B:=A) (A':=O) (B':=B)); auto with geo. elim orthogonal_colineaires with (A := B) (B := M) (C := B) (D := O) (E := B) (F := O'); [ intros | auto | auto | auto | auto ]. apply colineaire_alignes with (- x + 1). VReplace (vec O O') (add_PP (vec O B) (vec B O')). rewrite H9. VReplace (add_PP (vec O B) (mult_PP x (vec B O))) (mult_PP (- x + 1) (vec O B)); auto. Qed. Lemma point_contact_k_positif : forall (O A O' A' B : PO) (k : R), k >= 0 -> O <> A -> O' <> A' -> vec O' B = mult_PP k (vec O B) -> cercle_rayon O A B -> cercle_rayon O' A' B -> mult_PP (distance O A) (vec O' B) = mult_PP (distance O' A') (vec O B). icercle. assert (distance O A <> 0); auto with geo. assert (Rsqr k = Rsqr (distance O' A' * / distance O A)). unfold Rsqr in |- *. assert (O <> B). apply (isometrie_distinct (A:=O) (B:=A) (A':=O) (B':=B)); auto with geo. assert (distance O B <> 0); auto with geo. apply Rmult_eq_reg_l with (scalaire (vec O B) (vec O B)); auto with geo real. replace (scalaire (vec O B) (vec O B) * (k * k)) with (scalaire (mult_PP k (vec O B)) (mult_PP k (vec O B))). rewrite <- H2. repeat rewrite carre_scalaire_distance. rewrite H3; rewrite H4. RReplace (distance O B * distance O B * (distance O' B * / distance O B * (distance O' B * / distance O B))) (distance O' B * distance O' B * (distance O B * / distance O B * (distance O B * / distance O B))). RReplace (distance O B * / distance O B) 1. ring. Simplscal. rewrite H2. assert (k = distance O' A' * / distance O A). apply Rsqr_inj; auto with real geo. rewrite H7. VReplace (mult_PP (distance O A) (mult_PP (distance O' A' * / distance O A) (vec O B))) (mult_PP (distance O' A' * (distance O A * / distance O A)) (vec O B)). RReplace (distance O A * / distance O A) 1. Ringvec. Qed. Lemma point_contact_k_negatif : forall (O A O' A' B : PO) (k : R), k <= 0 -> O <> A -> O' <> A' -> vec O' B = mult_PP k (vec O B) -> cercle_rayon O A B -> cercle_rayon O' A' B -> mult_PP (distance O A) (vec O' B) = mult_PP (- distance O' A') (vec O B). icercle. assert (distance O A <> 0); auto with geo. assert (Rsqr k = Rsqr (distance O' A' * / distance O A)). unfold Rsqr in |- *. assert (O <> B). apply (isometrie_distinct (A:=O) (B:=A) (A':=O) (B':=B)); auto with geo. assert (distance O B <> 0); auto with geo. apply Rmult_eq_reg_l with (scalaire (vec O B) (vec O B)); auto with geo real. replace (scalaire (vec O B) (vec O B) * (k * k)) with (scalaire (mult_PP k (vec O B)) (mult_PP k (vec O B))). rewrite <- H2. repeat rewrite carre_scalaire_distance. rewrite H3; rewrite H4. RReplace (distance O B * distance O B * (distance O' B * / distance O B * (distance O' B * / distance O B))) (distance O' B * distance O' B * (distance O B * / distance O B * (distance O B * / distance O B))). RReplace (distance O B * / distance O B) 1. ring. Simplscal. rewrite H2. assert (- k = distance O' A' * / distance O A). apply Rsqr_inj; auto with real geo. rewrite <- H6; unfold Rsqr in |- *; ring. RReplace k (- - k). rewrite H7. VReplace (mult_PP (distance O A) (mult_PP (- (distance O' A' * / distance O A)) (vec O B))) (mult_PP (- (distance O' A' * (distance O A * / distance O A))) (vec O B)). RReplace (distance O A * / distance O A) 1. Ringvec. Qed. Lemma point_contact_cercles_tangents : forall O A O' A' B : PO, O <> A -> O' <> A' -> alignes O B O' -> cercle_rayon O A B -> cercle_rayon O' A' B -> mult_PP (distance O A) (vec O' B) = mult_PP (distance O' A') (vec O B) \/ mult_PP (distance O A) (vec O' B) = mult_PP (- distance O' A') (vec O B). icercle. assert (O <> B). apply (isometrie_distinct (A:=O) (B:=A) (A':=O) (B':=B)); auto with geo. cut (alignes B O O'); [ intros H20 | auto with geo ]. halignes H20 ipattern:k. absurd (B = O); auto. assert (vec O' B = mult_PP k (vec O B)). VReplace (vec O' B) (mult_PP (-1) (vec B O')). rewrite H5; Ringvec. elim (Rlt_le_dec k 0); intros. right; try assumption. apply point_contact_k_negatif with k; auto with real. left; try assumption. apply point_contact_k_positif with k; auto with real. Qed. Lemma k_negatif_barycentre : forall (O A O' A' B : PO) (k : R), k <= 0 -> O <> A -> O' <> A' -> vec O' B = mult_PP k (vec O B) -> cercle_rayon O A B -> cercle_rayon O' A' B -> B = barycentre (cons (distance O A) O') (cons (distance O' A') O). intros. assert (mult_PP (distance O A) (vec O' B) = mult_PP (- distance O' A') (vec O B)). apply point_contact_k_negatif with k; auto. assert (distance O A <> 0); auto with geo. assert (distance O' A' <> 0); auto with geo. assert (distance O A >= 0); auto with geo. assert (distance O' A' >= 0); auto with geo. assert (distance O A + distance O' A' <> 0). apply tech_Rplus; auto with geo real. elim H9; intros; auto. absurd (distance O' A' = 0); auto. apply def_vecteur_bary_rec; auto. VReplace (mult_PP (distance O' A') (vec B O)) (mult_PP (- distance O' A') (vec O B)). rewrite <- H5. Ringvec. Qed. Lemma k_negatif_distance_centres : forall (O A O' A' B : PO) (k : R), k <= 0 -> O <> A -> O' <> A' -> vec O' B = mult_PP k (vec O B) -> cercle_rayon O A B -> cercle_rayon O' A' B -> distance O O' = distance O A + distance O' A'. intros. assert (distance O A <> 0); auto with geo. assert (distance O' A' <> 0); auto with geo. assert (distance O A >= 0); auto with geo. assert (distance O' A' >= 0); auto with geo. assert (distance O A + distance O' A' <> 0). apply tech_Rplus; auto with geo real. elim H8; intros; auto. absurd (distance O' A' = 0); auto. assert (B = barycentre (cons (distance O A) O') (cons (distance O' A') O)). apply k_negatif_barycentre with k; auto. assert (mult_PP (distance O A + distance O' A') (vec O B) = mult_PP (distance O A) (vec O O')). rewrite <- (prop_vecteur_bary (a:=distance O A) (b:=distance O' A') (A:=O') (B:=O) (G:=B) O); auto. Ringvec. assert (vec O O' = mult_PP (/ distance O A * (distance O A + distance O' A')) (vec O B)). VReplace (mult_PP (/ distance O A * (distance O A + distance O' A')) (vec O B)) (mult_PP (/ distance O A) (mult_PP (distance O A + distance O' A') (vec O B))). rewrite H11. VReplace (mult_PP (/ distance O A) (mult_PP (distance O A) (vec O O'))) (mult_PP (distance O A * / distance O A) (vec O O')). RReplace (distance O A * / distance O A) 1. Ringvec. rewrite (colinearite_distance H12). rewrite Rabs_right; auto with real. hcercle H3. rewrite <- H13. RReplace (/ distance O A * (distance O A + distance O' A') * distance O A) (/ distance O A * distance O A * (distance O A + distance O' A')). RReplace (/ distance O A * distance O A) 1. ring. apply Rmult_pos; auto with real geo. fourier. Qed. Lemma k_positif_vecteur_centres : forall (O A O' A' B : PO) (k : R), k >= 0 -> O <> A -> O' <> A' -> vec O' B = mult_PP k (vec O B) -> cercle_rayon O A B -> cercle_rayon O' A' B -> vec O O' = mult_PP (/ distance O A * (distance O A + - distance O' A')) (vec O B). intros. assert (mult_PP (distance O A) (vec O' B) = mult_PP (distance O' A') (vec O B)). apply point_contact_k_positif with k; auto. assert (distance O A <> 0); auto with geo. assert (distance O' A' <> 0); auto with geo. assert (distance O A >= 0); auto with geo. assert (distance O' A' >= 0); auto with geo. assert (mult_PP (distance O A + - distance O' A') (vec O B) = mult_PP (distance O A) (vec O O')). VReplace (mult_PP (distance O A) (vec O O')) (add_PP (mult_PP (distance O A) (vec O B)) (mult_PP (-1) (mult_PP (distance O A) (vec O' B)))). rewrite H5. Ringvec. VReplace (mult_PP (/ distance O A * (distance O A + - distance O' A')) (vec O B)) (mult_PP (/ distance O A) (mult_PP (distance O A + - distance O' A') (vec O B))). rewrite H10. VReplace (mult_PP (/ distance O A) (mult_PP (distance O A) (vec O O'))) (mult_PP (distance O A * / distance O A) (vec O O')). RReplace (distance O A * / distance O A) 1. Ringvec. Qed. Lemma k_positif_distance_centres : forall (O A O' A' B : PO) (k : R), k >= 0 -> O <> A -> O' <> A' -> vec O' B = mult_PP k (vec O B) -> cercle_rayon O A B -> cercle_rayon O' A' B -> distance O O' = Rabs (distance O A + - distance O' A'). intros. assert (distance O A <> 0); auto with geo. assert (vec O O' = mult_PP (/ distance O A * (distance O A + - distance O' A')) (vec O B)). apply k_positif_vecteur_centres with k; auto. rewrite (colinearite_distance H6). rewrite Rabs_mult. rewrite Rabs_right; auto with real geo. hcercle H3. rewrite <- H7. RReplace (/ distance O A * Rabs (distance O A + - distance O' A') * distance O A) (/ distance O A * distance O A * Rabs (distance O A + - distance O' A')). RReplace (/ distance O A * distance O A) 1. ring. Qed. Lemma aux_Rpos : forall a b : R, a >= 0 -> b >= 0 -> a + b = Rabs (a + - b) -> a = 0 \/ b = 0. intros. assert (Rsqr (a + b) = Rsqr (a + - b)). rewrite H1. rewrite <- Rsqr_abs; auto. apply Rmult_integral. assert (4 * (a * b) = 0). RReplace (4 * (a * b)) (2 * a * (2 * b)). RReplace (2 * a) (a + b + (a + - b)). RReplace (2 * b) (a + b - (a + - b)). rewrite Rsqr_plus_minus. rewrite H2; auto with real. assert (4 <> 0); auto with real. elim Rmult_integral with (r1 := 4) (r2 := a * b); [ intros H5; try clear without_div_Od | intros H5; try clear without_div_Od; try exact H5 | auto ]. absurd (4 = 0); auto. Qed. Theorem cercles_tangents_contact_unique : forall O A O' A' B C : PO, O <> A -> O' <> A' -> ~ cercle_rayon O A A' -> alignes O B O' -> cercle_rayon O A B -> cercle_rayon O' A' B -> alignes O C O' -> cercle_rayon O A C -> cercle_rayon O' A' C -> B = C. intros O A O' A' B C H H0 H100 H1 H2 H3 H4 H5 H6; try assumption. assert (O <> B). apply (isometrie_distinct (A:=O) (B:=A) (A':=O) (B':=B)); auto with geo. assert (O <> C). apply (isometrie_distinct (A:=O) (B:=A) (A':=O) (B':=C)); auto with geo. assert (alignes B O O'); auto with geo. halignes H9 ipattern:x. absurd (B = O); auto. assert (vec O' B = mult_PP x (vec O B)). VReplace (vec O' B) (mult_PP (-1) (vec B O')). rewrite H10; Ringvec. assert (alignes C O O'); auto with geo. halignes H12 ipattern:k. absurd (C = O); auto. assert (vec O' C = mult_PP k (vec O C)). VReplace (vec O' C) (mult_PP (-1) (vec C O')). rewrite H13; Ringvec. assert (distance O A <> 0); auto with geo. assert (distance O' A' <> 0); auto with geo. assert (distance O A >= 0); auto with geo. assert (distance O' A' >= 0); auto with geo. assert (distance O A + distance O' A' <> 0). apply tech_Rplus; auto with geo real. elim H18; intros; auto. absurd (distance O' A' = 0); auto. elim (Rlt_le_dec x 0); intros. assert (x <= 0); auto with real. assert (B = barycentre (cons (distance O A) O') (cons (distance O' A') O)). apply k_negatif_barycentre with x; auto. elim (Rlt_le_dec k 0); intros. assert (k <= 0); auto with real. assert (C = barycentre (cons (distance O A) O') (cons (distance O' A') O)). apply k_negatif_barycentre with k; auto. rewrite H21; auto. assert (distance O O' = distance O A + distance O' A'). apply k_negatif_distance_centres with (4 := H11); auto. assert (distance O O' = Rabs (distance O A + - distance O' A')). apply k_positif_distance_centres with (4 := H14); auto. auto with real. assert (distance O A = 0 \/ distance O' A' = 0). apply aux_Rpos; auto. rewrite <- H23; auto. elim H24; intros. absurd (distance O A = 0); auto. absurd (distance O' A' = 0); auto. assert (distance O O' = Rabs (distance O A + - distance O' A')). apply k_positif_distance_centres with (4 := H11); auto. auto with real. elim (classic (distance O A = distance O' A')); intros. assert (O = O'). assert (distance O O' = 0); auto with geo. rewrite H20; rewrite H21. RReplace (distance O' A' + - distance O' A') 0. rewrite Rabs_right; auto with real. absurd (cercle_rayon O A A'); auto. icercle. rewrite H21; rewrite H22; auto. assert (mult_PP (distance O A + - distance O' A') (vec O B) = mult_PP (distance O A) (vec O O')). VReplace (mult_PP (distance O A) (vec O O')) (add_PP (mult_PP (distance O A) (vec O B)) (mult_PP (-1) (mult_PP (distance O A) (vec O' B)))). assert (mult_PP (distance O A) (vec O' B) = mult_PP (distance O' A') (vec O B)). apply point_contact_k_positif with x; auto. auto with real. rewrite H22; Ringvec. assert (distance O A + - distance O' A' <> 0); auto with real. elim (Rlt_le_dec k 0); intros. assert (k <= 0); auto with real. assert (distance O O' = distance O A + distance O' A'). apply k_negatif_distance_centres with (4 := H14); auto. assert (distance O A = 0 \/ distance O' A' = 0). apply aux_Rpos; auto. rewrite <- H25; auto. elim H26; intros. absurd (distance O A = 0); auto. absurd (distance O' A' = 0); auto. assert (mult_PP (distance O A + - distance O' A') (vec O C) = mult_PP (distance O A) (vec O O')). VReplace (mult_PP (distance O A) (vec O O')) (add_PP (mult_PP (distance O A) (vec O C)) (mult_PP (-1) (mult_PP (distance O A) (vec O' C)))). assert (mult_PP (distance O A) (vec O' C) = mult_PP (distance O' A') (vec O C)). apply point_contact_k_positif with k; auto. auto with real. rewrite H24; Ringvec. apply egalite_vecteur_point with O. assert (vec O B = mult_PP (/ (distance O A + - distance O' A')) (mult_PP (distance O A) (vec O O'))). rewrite <- H22. VReplace (mult_PP (/ (distance O A + - distance O' A')) (mult_PP (distance O A + - distance O' A') (vec O B))) (mult_PP ((distance O A + - distance O' A') * / (distance O A + - distance O' A')) (vec O B)). replace ((distance O A + - distance O' A') * / (distance O A + - distance O' A')) with 1; auto with real. Ringvec. rewrite H25. rewrite <- H24. VReplace (mult_PP (/ (distance O A + - distance O' A')) (mult_PP (distance O A + - distance O' A') (vec O C))) (mult_PP ((distance O A + - distance O' A') * / (distance O A + - distance O' A')) (vec O C)). replace ((distance O A + - distance O' A') * / (distance O A + - distance O' A')) with 1; auto with real. Ringvec. Qed.HighSchoolGeometry/coplanarite.v0000644000076500007650000001503112073525612016714 0ustar coqcoq00000000000000(* This program is free software; you can redistribute it and/or *) (* modify it under the terms of the GNU Lesser General Public License *) (* as published by the Free Software Foundation; either version 2.1 *) (* of the License, or (at your option) any later version. *) (* *) (* This program is distributed in the hope that it will be useful, *) (* but WITHOUT ANY WARRANTY; without even the implied warranty of *) (* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *) (* GNU General Public License for more details. *) (* *) (* You should have received a copy of the GNU Lesser General Public *) (* License along with this program; if not, write to the Free *) (* Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA *) (* 02110-1301 USA *) Require Export alignement. Set Implicit Arguments. Unset Strict Implicit. Definition coplanaires1 (A B C D : PO) := exists a : R, (exists b : R, cons 1 D = add_PP (cons a A) (add_PP (cons b B) (cons (1 + - (a + b)) C))). Lemma vecteur_def_coplanaires1 : forall (k k' : R) (A B C D : PO), vec A D = add_PP (mult_PP k (vec A B)) (mult_PP k' (vec A C)) -> coplanaires1 A B C D. unfold coplanaires1, vec in |- *; intros. exists (1 + - (k + k')); auto. exists k; auto. RingPP2 H. RingPP. Qed. Lemma coplanaires1_vecteur_def : forall A B C D : PO, coplanaires1 A B C D -> exists k : R, (exists k' : R, vec A D = add_PP (mult_PP k (vec A B)) (mult_PP k' (vec A C))). unfold coplanaires1, vec in |- *; intros. elim H; intros a H0; elim H0; intros b H1; try clear H0 H; try exact H1. exists b; auto. exists (1 + - (a + b)); auto. rewrite H1. RingPP. Qed. Definition coplanaires (A B C D : PO) := alignes A B C \/ coplanaires1 A B C D. Lemma coplanaires_trivial : forall A B C : PO, coplanaires A B C A. unfold coplanaires, coplanaires1 in |- *; intros. right; try assumption. exists 1; exists 0. RingPP. Qed. Lemma coplanaires_trivial2 : forall A B C : PO, coplanaires A B C B. unfold coplanaires, coplanaires1 in |- *; intros. right; try assumption. exists 0; exists 1. RingPP. Qed. Lemma coplanaires_trivial3 : forall A B C : PO, coplanaires A B C C. unfold coplanaires, coplanaires1 in |- *; intros. right; try assumption. exists 0; exists 0. RingPP. Qed. Hint Resolve coplanaires_trivial coplanaires_trivial2 coplanaires_trivial3: geo. Ltac hcoplanaires H x y := elim H; clear H; intros H; [ tauto || idtac | elim (coplanaires1_vecteur_def H); clear H; intros x H; elim H; clear H; intros y H ]. Ltac hPPcoplanaires H x y := elim H; clear H; intros H; [ tauto || idtac | elim H; clear H; intros x H; elim H; clear H; intros y H ]. Lemma non_coplanaires_expl : forall A B C D : PO, ~ coplanaires A B C D -> ~ alignes A B C /\ ~ coplanaires1 A B C D. unfold coplanaires in |- *; intros. intuition. Qed. Axiom repere_espace : forall A B C D E : PO, ~ coplanaires A B C D -> exists a : R, (exists b : R, (exists c : R, cons 1 E = add_PP (add_PP (cons a A) (cons b B)) (add_PP (cons c C) (cons (1 + - (a + b + c)) D)))). Hint Unfold coplanaires: geo. Lemma vecteur_def_coplanaires : forall (k k' : R) (A B C D : PO), vec A D = add_PP (mult_PP k (vec A B)) (mult_PP k' (vec A C)) -> coplanaires A B C D. intros; unfold coplanaires in |- *. right; try assumption. apply vecteur_def_coplanaires1 with (k := k) (k' := k'); try assumption. Qed. Lemma alignes_coplanaires : forall A B C D : PO, alignes A B C -> coplanaires A B D C. intros. halignes H ipattern:a. apply vecteur_def_coplanaires with (k := a) (k' := 0). rewrite H0. Ringvec. Qed. Hint Resolve alignes_coplanaires: geo. Lemma coplanaire_ordre_permute : forall A B C D : PO, coplanaires A B C D -> coplanaires A B D C. intros. elim H; clear H; intros; auto with geo. elim (coplanaires1_vecteur_def H); intros. elim H0; [ intros y H1; try clear H0; try exact H1 ]. elim (classic (y = 0)); intros. assert (alignes A B D); auto with geo. apply colineaire_alignes with x. rewrite H1; rewrite H0; Ringvec. apply vecteur_def_coplanaires with (k := / y * - x) (k' := / y). rewrite H1. Fieldvec y. Qed. Lemma coplanaire_ordre_cycle : forall A B C D : PO, coplanaires A B C D -> coplanaires B C D A. intros. elim H; clear H; intros; auto with geo. elim coplanaires1_vecteur_def with (A := A) (B := B) (C := C) (D := D); [ intros x H0; elim H0; [ intros y H1; try clear H0 coplanaires1_vecteur_def; try exact H1 ] | auto ]. elim (classic (y = 1 + - x)); intros. rewrite H2 in H1. assert (alignes B C D); auto with geo. apply colineaire_alignes with (1 + - x). VReplace (vec B D) (add_PP (vec B A) (vec A D)). rewrite H1. Ringvec. assert (1 + - x + - y <> 0). contrapose H0. RReplace y (y + 0). rewrite <- H3; ring. apply vecteur_def_coplanaires with (k := / (1 + - x + - y) * - y) (k' := / (1 + - x + - y)). VReplace (vec B D) (add_PP (vec B A) (vec A D)). rewrite H1. Fieldvec (1 + - x + - y). Qed. Hint Resolve coplanaire_ordre_cycle coplanaire_ordre_permute: geo. Lemma coplanaire_trans : forall A B C D E : PO, ~ alignes A B C -> coplanaires A B C D -> coplanaires A B C E -> coplanaires B C D E. intros. elim H1; clear H1; intros. tauto. elim H0; clear H0; intros. tauto. elim coplanaires1_vecteur_def with (A := A) (B := B) (C := C) (D := D); [ intros x H2; elim H2; [ intros y H3; try clear H2; try exact H3 ] | auto ]. elim coplanaires1_vecteur_def with (A := A) (B := B) (C := C) (D := E); [ intros k H4; elim H4; [ intros k' H5; try clear H4; try exact H5 ] | auto ]. elim (classic (y = 1 + - x)); intros. rewrite H2 in H3. assert (alignes B C D); auto with geo. apply colineaire_alignes with (1 + - x). VReplace (vec B D) (add_PP (vec B A) (vec A D)). rewrite H3. Ringvec. assert (1 + - x + - y <> 0). contrapose H0. RReplace y (y + 0). rewrite <- H4; ring. assert (vec B A = add_PP (mult_PP (/ (1 + - x + - y) * - y) (vec B C)) (mult_PP (/ (1 + - x + - y)) (vec B D))). VReplace (vec B D) (add_PP (vec B A) (vec A D)). rewrite H3. Fieldvec (1 + - x + - y). assert (vec B E = add_PP (mult_PP (1 + - k + - k') (vec B A)) (mult_PP k' (vec B C))). VReplace (vec B E) (add_PP (vec B A) (vec A E)). rewrite H5. Ringvec. apply vecteur_def_coplanaires with (k := k' + / (1 + - x + - y) * - y * (1 + - k + - k')) (k' := / (1 + - x + - y) * (1 + - k + - k')). rewrite H7; rewrite H6. Fieldvec (1 + - x + - y). Qed.HighSchoolGeometry/description0000644000076500007650000000076212073525612016477 0ustar coqcoq00000000000000Name: HighSchoolGeometry Title: Geometry for French high-school Author: Frédérique Guilhot Email: Frederique.Guilhot@sophia.inria.fr Homepage: http://www-sop.inria.fr/lemme/Frederique.Guilhot/index.html Institution: INRIA Sophia-Antipolis Date: January 2004 Description: This library is dedicated to high-shool geometry teaching. The axiomatisation for affine euclidean space is in a non analytic setting. Keywords: geometry, teaching, high-school Require: Category: Mathematics/Geometry/General HighSchoolGeometry/determinant.v0000644000076500007650000001732712117747636016752 0ustar coqcoq00000000000000(* This program is free software; you can redistribute it and/or *) (* modify it under the terms of the GNU Lesser General Public License *) (* as published by the Free Software Foundation; either version 2.1 *) (* of the License, or (at your option) any later version. *) (* *) (* This program is distributed in the hope that it will be useful, *) (* but WITHOUT ANY WARRANTY; without even the implied warranty of *) (* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *) (* GNU General Public License for more details. *) (* *) (* You should have received a copy of the GNU Lesser General Public *) (* License along with this program; if not, write to the Free *) (* Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA *) (* 02110-1301 USA *) Require Export aire_signee. Require Export metrique_triangle. Set Implicit Arguments. Unset Strict Implicit. Parameters (O : PO) (I : PO) (J : PO). Hypothesis OIJ : repere_orthonormal_direct O I J. Hint Resolve OIJ: geo. Lemma OIJ_repere_ortho : repere_orthonormal O I J. auto with geo. Qed. Lemma OIJ_repere : repere O I J. auto with geo. Qed. Lemma OI_distincts : O <> I. elim OIJ; intros. auto with geo. elim H0; intros; auto with geo. Qed. Lemma OJ_distincts : O <> J. elim OIJ; intros. elim H0; intros; auto with geo. Qed. Hint Resolve OIJ_repere_ortho OIJ_repere OI_distincts OJ_distincts: geo. Lemma IJ_distincts : I <> J. cut (repere_orthonormal O I J); intros; auto with geo. elim H; intros. apply non_alignes_distincts2 with O; auto. apply orthogonal_non_alignes; auto with geo. Qed. Hint Resolve IJ_distincts: geo. Ltac deroule_OIJ := elim OIJ; intro; intros toto; elim toto; intros; clear toto; cut (distance O I = 1); intros; [ idtac | auto with geo ]; cut (distance O J = 1); intros; [ idtac | auto with geo ]. Lemma unite_aire : aire (vec O I) (vec O J) = 1. intros. deroule_OIJ. rewrite def_aire; auto with geo. rewrite (def_Sin (A:=O) (B:=I) (C:=J) (D:=J)); auto with geo. rewrite H1; rewrite H2; rewrite H3; ring. Qed. Lemma opp_unite_aire : aire (vec O J) (vec O I) = -1. intros. deroule_OIJ. rewrite def_aire; auto with geo. rewrite Sin_opp; auto with geo. rewrite (def_Sin (A:=O) (B:=I) (C:=J) (D:=J)); auto with geo. rewrite H1; rewrite H2; rewrite H3; ring. Qed. Parameter det : PP -> PP -> R. Axiom determinant_def : forall (A B C D : PO) (x y x' y' : R), vec A B = add_PP (mult_PP x (vec O I)) (mult_PP y (vec O J)) -> vec C D = add_PP (mult_PP x' (vec O I)) (mult_PP y' (vec O J)) -> det (vec A B) (vec C D) = x * y' + - (y * x'). Lemma aire_coordonnees : forall (M N : PO) (x y x' y' : R), vec O M = add_PP (mult_PP x (vec O I)) (mult_PP y (vec O J)) -> vec O N = add_PP (mult_PP x' (vec O I)) (mult_PP y' (vec O J)) -> aire (vec O M) (vec O N) = x * y' + - (y * x'). intros. rewrite H. elim existence_representant_mult_vecteur with (A := O) (B := O) (C := I) (k := x); [ intros A H1; rewrite <- H1 ]. elim existence_representant_mult_vecteur with (A := O) (B := O) (C := J) (k := y); [ intros B H2; rewrite <- H2 ]. rewrite aire_distrib_r. rewrite H1. rewrite aire_colineaire_l. rewrite H2. rewrite aire_colineaire_l. rewrite H0. elim existence_representant_mult_vecteur with (A := O) (B := O) (C := I) (k := x'); [ intros C H3; rewrite <- H3 ]. elim existence_representant_mult_vecteur with (A := O) (B := O) (C := J) (k := y'); [ intros D H4; rewrite <- H4 ]. repeat rewrite aire_distrib_l. rewrite H3. repeat rewrite aire_colineaire_r. rewrite H4. repeat rewrite aire_colineaire_r. repeat rewrite aire_ABAB. rewrite unite_aire. rewrite opp_unite_aire. ring. Qed. Lemma determinant_aire : forall A B C D : PO, det (vec A B) (vec C D) = aire (vec A B) (vec C D). intros. elim composantes_vecteur with (O := O) (I := I) (J := J) (M := A) (N := B); [ intros x H; elim H; [ intros y H0; try clear H composantes_vecteur; try exact H0 ] | auto with geo ]. elim composantes_vecteur with (O := O) (I := I) (J := J) (M := C) (N := D); [ intros x' H1; elim H1; [ intros y' H2; try clear H1 composantes_vecteur; try exact H2 ] | auto with geo ]. rewrite (determinant_def (A:=A) (B:=B) (C:=C) (D:=D) (x:=x) (y:=y) (x':=x') (y':=y')) ; auto. generalize H0 H2. elim existence_representant_vecteur with (A := O) (B := A) (C := B); [ intros E H3; rewrite <- H3 ]. elim existence_representant_vecteur with (A := O) (B := C) (C := D); [ intros F H4; rewrite <- H4 ]. intros; symmetry in |- *. apply aire_coordonnees; auto. Qed. Lemma determinant_antisymetrique : forall A B C D : PO, det (vec A B) (vec C D) = - det (vec C D) (vec A B). intros. repeat rewrite determinant_aire. rewrite aire_anti_symetrique; auto. Qed. Lemma determinant_colinearite : forall (k : R) (A B C D : PO), vec C D = mult_PP k (vec A B) -> det (vec A B) (vec C D) = 0. intros. repeat rewrite determinant_aire. apply (aire_colinearite H). Qed. Lemma determinant_nul_colinearite : forall A B C D : PO, A <> B -> det (vec A B) (vec C D) = 0 -> exists k : _, vec C D = mult_PP k (vec A B). intros A B C D H; try assumption. rewrite determinant_aire; intros. apply aire_nulle_colineaires; auto. Qed. Lemma alignement_determinant : forall A B M : PO, alignes A B M -> det (vec A B) (vec A M) = 0. intros. rewrite determinant_aire. apply aire_alignement; auto. Qed. Lemma determinant_nul_alignement : forall A B M : PO, det (vec A B) (vec A M) = 0 -> alignes A B M. intros. discrimine A B. elim determinant_nul_colinearite with (A := A) (B := B) (C := A) (D := M); [ intros k H1; try clear determinant_nul_colinearite; try exact H1 | auto | auto ]. apply colineaire_alignes with k; auto. Qed. Lemma determinant_colineaire_l : forall (k : R) (A B C D : PO), det (mult_PP k (vec A B)) (vec C D) = k * det (vec A B) (vec C D). intros. elim existence_representant_mult_vecteur with (A := A) (B := A) (C := B) (k := k); [ intros E H1; rewrite <- H1 ]. repeat rewrite determinant_aire. rewrite H1. apply aire_colineaire_l. Qed. Lemma determinant_distrib_l : forall A B C D E F : PO, det (vec A B) (add_PP (vec C D) (vec E F)) = det (vec A B) (vec C D) + det (vec A B) (vec E F). intros. elim existence_representant_som_vecteur with (A := C) (B := D) (C := E) (D := F); [ intros G H; try clear existence_representant_som_vecteur; rewrite <- H ]. repeat rewrite determinant_aire. rewrite H. apply aire_distrib_l. Qed. Lemma determinant_ordre_cycle : forall A B C D E F : PO, det (vec B C) (vec B A) = det (vec A B) (vec A C). intros. repeat rewrite determinant_aire. apply aire_ordre_cycle. Qed. Lemma determinant_aire_triangle : forall A B C : PO, aire_triangle A B C = / 2 * Rabs (det (vec A B) (vec A C)). unfold aire_triangle in |- *; intros. repeat rewrite determinant_aire; auto. Qed. Lemma calcul_distance_droite : forall A B C : PO, A <> B -> distance_droite C (droite A B) = Rabs (det (vec A B) (vec A C)) / distance A B. intros A B C H0; try assumption. elim existence_projete_orthogonal with (A := A) (B := B) (C := C); [ intros H H1; try clear existence_projete_orthogonal; try exact H1 | auto ]. repeat rewrite determinant_aire. rewrite (distance_droite_def (A:=A) (B:=B) (C:=C) (H:=H)); auto. rewrite (aire_avec_projete (A:=A) (B:=B) (C:=C) (H:=H)); auto. replace (distance C H) with (distance H C); auto with geo. elim (def_projete_orthogonal2 (A:=A) (B:=B) (C:=C) (H:=H)); auto; intros. rewrite aire_orthogonal; auto with geo. unfold Rdiv in |- *. cut (distance A B <> 0); intros; auto with geo. RReplace (distance A B * distance H C * / distance A B) (distance A B * / distance A B * distance H C). RReplace (distance A B * / distance A B) 1. ring. Qed.HighSchoolGeometry/dilatations.v0000644000076500007650000004570312073525612016737 0ustar coqcoq00000000000000(* This program is free software; you can redistribute it and/or *) (* modify it under the terms of the GNU Lesser General Public License *) (* as published by the Free Software Foundation; either version 2.1 *) (* of the License, or (at your option) any later version. *) (* *) (* This program is distributed in the hope that it will be useful, *) (* but WITHOUT ANY WARRANTY; without even the implied warranty of *) (* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *) (* GNU General Public License for more details. *) (* *) (* You should have received a copy of the GNU Lesser General Public *) (* License along with this program; if not, write to the Free *) (* Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA *) (* 02110-1301 USA *) Require Export parallelisme_concours. Set Implicit Arguments. Unset Strict Implicit. Definition translation (I J A : PO) := barycentre (cons (-1) I) (cons 2 (barycentre (cons 1 J) (cons 1 A))). Lemma translation_vecteur : forall I J A A' : PO, A' = translation I J A -> vec I J = vec A A'. unfold vec, translation in |- *; intros. rewrite H. pattern 1 at 4 in |- *. replace 1 with (-1 + 2); try ring. repeat rewrite <- add_PP_barycentre; try discrR; auto. RingPP. Qed. Lemma translation_identite : forall I A A' : PO, A' = translation I I A :>PO -> A = A'. intros. apply vecteur_nul_conf; auto. rewrite <- (translation_vecteur (I:=I) (J:=I) (A:=A) (A':=A')); auto. Ringvec. Qed. Lemma rec_translation_vecteur : forall I J A A' : PO, vec I J = vec A A' :>PP -> A' = translation I J A :>PO. unfold vec, translation in |- *; intros. elim cons_inj with (a := 1) (b := -1 + 2) (A := A') (B := barycentre (cons (-1) I) (cons 2 (barycentre (cons 1 J) (cons 1 A)))); intros; auto with *. repeat rewrite <- add_PP_barycentre; try discrR. RingPP1 H. RingPP. Qed. Lemma translation_trivial : forall I J : PO, J = translation I J I. intros. apply rec_translation_vecteur; auto. Qed. Hint Resolve translation_trivial: geo. Lemma translation_bipoint : forall I J A A' B B' : PO, A' = translation I J A :>PO -> B' = translation I J B :>PO -> vec A B = vec A' B'. intros I J A A' B B' H H0; try assumption. apply egalite_vecteur. rewrite <- (translation_vecteur (I:=I) (J:=J) (A:=A) (A':=A')); auto. rewrite <- (translation_vecteur (I:=I) (J:=J) (A:=B) (A':=B')); auto. Qed. Lemma translation_trans : forall I J A A' B B' : PO, A' = translation I J A :>PO -> B' = translation I J B :>PO -> B' = translation A A' B :>PO. intros I J A A' B B' H H0; try assumption. apply rec_translation_vecteur. rewrite <- (translation_vecteur (I:=I) (J:=J) (A:=A) (A':=A')); auto. rewrite <- (translation_vecteur (I:=I) (J:=J) (A:=B) (A':=B')); auto. Qed. Lemma image_translation_distincts : forall I J A A' B B' : PO, A <> B -> A' = translation I J A :>PO -> B' = translation I J B -> A' <> B'. intros. apply distinct_egalite_vecteur with (A := A) (B := B); auto. symmetry in |- *; apply translation_bipoint with (I := I) (J := J); auto. Qed. Lemma translation_droite : forall I J A A' B B' : PO, A <> B -> A' = translation I J A :>PO -> B' = translation I J B :>PO -> paralleles (droite A' B') (droite A B). intros. apply colineaires_paralleles with 1; auto. apply image_translation_distincts with (2 := H0) (3 := H1); auto. replace (mult_PP 1 (vec A B)) with (vec A B). symmetry in |- *; apply translation_bipoint with (I := I) (J := J); auto. Ringvec. Qed. Lemma translation_milieu : forall I J A A' B B' M N : PO, A' = translation I J A :>PO -> B' = translation I J B -> M = milieu A B -> N = milieu A' B' -> N = translation I J M. intros I J A A' B B' M N H H0 H1 H2; try assumption. apply rec_translation_vecteur; auto. replace (vec M N) with (add_PP (cons (-1) M) (cons 1 N)); auto. apply mult_PP_regulier with 2; try discrR. repeat rewrite <- distrib_mult_cons. replace (2 * 1) with 2; try ring; auto. rewrite H2. rewrite <- add_PP_milieu. replace (2 * -1) with (-1 * 2); try ring; auto. repeat rewrite <- def_mult_PP. rewrite H1. rewrite <- add_PP_milieu. repeat rewrite <- distrib_mult_cons. replace (-1 * 1) with (-1); try ring; auto. rewrite <- calcul; auto. replace (add_PP (cons (-1) B) (cons 1 B')) with (vec B B'); auto. rewrite <- (translation_vecteur (I:=A) (J:=A') (A:=B) (A':=B')); auto. rewrite (translation_vecteur (I:=I) (J:=J) (A:=A) (A':=A')); auto. Ringvec. apply translation_trans with (1 := H); auto. Qed. Lemma translation_alignement : forall I J A A' B B' C C' : PO, A' = translation I J A :>PO -> B' = translation I J B :>PO -> C' = translation I J C -> alignes A B C -> alignes A' B' C'. intros I J A A' B B' C C' H H0 H1 H2; try assumption. discrimine A B. assert (A' = B'); auto with geo. rewrite H0; rewrite <- H3; auto. halignes H2 ipattern:k. apply colineaire_alignes with k. rewrite <- (translation_bipoint (I:=I) (J:=J) (A:=A) (A':=A') (B:=B) (B':=B')) ; auto. rewrite <- H4; auto. rewrite <- (translation_bipoint (I:=I) (J:=J) (A:=A) (A':=A') (B:=C) (B':=C')) ; auto. Qed. Lemma translation_inverse : forall I J A A' : PO, A' = translation I J A :>PO -> A = translation J I A' :>PO. intros. apply rec_translation_vecteur; auto. VReplace (vec J I) (mult_PP (-1) (vec I J)). rewrite (translation_vecteur (I:=I) (J:=J) (A:=A) (A':=A')); auto. Ringvec. Qed. Hint Resolve translation_inverse: geo. Lemma translation_intersection : forall I J A A' B B' C C' D D' K K' : PO, A <> B -> C <> D -> ~ alignes A B C \/ ~ alignes A B D -> K = pt_intersection (droite A B) (droite C D) -> A' = translation I J A :>PO -> B' = translation I J B -> C' = translation I J C :>PO -> D' = translation I J D :>PO -> K' = translation I J K :>PO -> K' = pt_intersection (droite A' B') (droite C' D'). intros. elim def_pt_intersection2 with (A := A) (B := B) (C := C) (D := D) (I := K); [ try clear def_pt_intersection2; intros | auto | auto | auto | auto ]. apply def_pt_intersection; auto. apply image_translation_distincts with (2 := H3) (3 := H4); auto. apply image_translation_distincts with (2 := H5) (3 := H6); auto. elim H1; [ intros H10; try clear H1 | intros H10; try clear H1; try exact H10 ]. left. red in |- *; intros; apply H10. apply (translation_alignement (I:=J) (J:=I) (A:=A') (A':=A) (B:=B') (B':=B) (C:=C') (C':=C)); auto with geo. right; red in |- *; intros H1; apply H10. apply (translation_alignement (I:=J) (J:=I) (A:=A') (A':=A) (B:=B') (B':=B) (C:=D') (C':=D)); auto with geo. apply (translation_alignement (I:=I) (J:=J) (A:=A) (A':=A') (B:=B) (B':=B') (C:=K) (C':=K')); auto with geo. apply (translation_alignement (I:=I) (J:=J) (A:=C) (A':=C') (B:=D) (B':=D') (C:=K) (C':=K')); auto with geo. Qed. Lemma translation_paralleles : forall I J A A' B B' C C' D D' : PO, A <> B -> C <> D -> paralleles (droite A B) (droite C D) -> A' = translation I J A :>PO -> B' = translation I J B -> C' = translation I J C :>PO -> D' = translation I J D :>PO -> paralleles (droite A' B') (droite C' D'). intros. elim paralleles_vecteur with (A := A) (B := B) (C := C) (D := D); [ intros k H6; try clear paralleles_vecteur; try exact H6 | auto | auto | auto ]. apply colineaires_paralleles with k. apply distinct_egalite_vecteur with (A := A) (B := B); auto. symmetry in |- *; apply translation_bipoint with (I := I) (J := J); auto. apply distinct_egalite_vecteur with (A := C) (B := D); auto. symmetry in |- *; apply translation_bipoint with (I := I) (J := J); auto. rewrite <- (translation_bipoint (I:=I) (J:=J) (A:=C) (A':=C') (B:=D) (B':=D')) ; auto. rewrite <- H6; auto. symmetry in |- *; apply translation_bipoint with (I := I) (J := J); auto. Qed. Definition homothetie (k : R) (I A : PO) := barycentre (cons k A) (cons (1 + - k) I). Lemma homothetie_identite : forall I A : PO, A = homothetie 1 I A. unfold homothetie, vec in |- *; intros. replace (1 + -1) with 0; try ring; auto. rewrite barycentre_zero; auto with *. Qed. Lemma vecteur_homothetie : forall (k : R) (I A A' : PO), vec I A' = mult_PP k (vec I A) :>PP -> A' = homothetie k I A :>PO. unfold vec, homothetie in |- *; intros. elim cons_inj with (a := 1) (b := k + (1 + - k)) (A := A') (B := barycentre (cons k A) (cons (1 + - k) I)); intros; auto with *. repeat rewrite <- add_PP_barycentre; try discrR. RingPP2 H. RingPP. replace (k + (1 + - k)) with 1; try ring; try discrR. Qed. Lemma homothetie_centre : forall (I : PO) (k : R), I = homothetie k I I. intros. apply vecteur_homothetie. Ringvec. Qed. Hint Resolve homothetie_centre: geo. Lemma homothetie_vecteur : forall (k : R) (I A A' : PO), A' = homothetie k I A -> vec I A' = mult_PP k (vec I A). unfold homothetie, vec in |- *; intros. rewrite H. pattern 1 at 2 in |- *. replace 1 with (k + (1 + - k)); try ring. repeat rewrite <- add_PP_barycentre; try discrR. RingPP. replace (k + (1 + - k)) with 1; try ring. try discrR. Qed. Definition symetrie (I A : PO) := homothetie (-1) I A. Lemma milieu_symetrie : forall A B I : PO, I = milieu A B :>PO -> B = symetrie I A :>PO. unfold symetrie in |- *; intros. apply vecteur_homothetie. rewrite <- (milieu_vecteur (A:=A) (B:=B) (M:=I)); auto. Ringvec. Qed. Lemma symetrie_milieu : forall A B I : PO, B = symetrie I A :>PO -> I = milieu A B :>PO. unfold symetrie in |- *; intros. cut (vec I B = mult_PP (-1) (vec I A)); intros. 2: apply homothetie_vecteur; auto. apply vecteur_milieu. replace (vec A B) with (add_PP (vec A I) (vec I B)); [ idtac | Ringvec ]. rewrite H0. cut (2 <> 0); intros; auto with real. Fieldvec 2. Qed. Hint Resolve milieu_symetrie symetrie_milieu: geo. Lemma symetrie_involution : forall A B I : PO, B = symetrie I A :>PO -> A = symetrie I B :>PO. intros. apply milieu_symetrie. apply milieu_permute. apply symetrie_milieu; auto. Qed. Lemma existence_homothetique : forall (k : R) (I A : PO), exists A' : PO, A' = homothetie k I A. intros. elim existence_representant_mult_vecteur with (A := I) (B := I) (C := A) (k := k); intros A' H1; try clear existence_representant_mult_vecteur. exists A'. apply vecteur_homothetie; auto. Qed. Lemma existence_symetrique : forall A B : PO, exists C : PO, C = symetrie A B. unfold symetrie in |- *; intros. apply (existence_homothetique (-1) A B). Qed. Ltac symetrique O A B := elim (existence_symetrique O A); intros B; intros; assert (O = milieu A B); auto with geo. Lemma existence_symetrique_milieu: forall (A I : PO), (exists B : PO , I = milieu A B ). intros. elim (existence_symetrique I A); [intros B H; (try clear existence_symetrique); (try exact H)]. exists B. apply symetrie_milieu; auto. Qed. Lemma unicite_symetrique: forall (A B P : PO), milieu A P = milieu B P -> A = B. intros. elim (existence_milieu B P); [intros I H1; (try clear existence_milieu)]. assert (B = symetrie I P). apply milieu_symetrie; auto with geo. rewrite H0. apply milieu_symetrie. rewrite H1. auto with geo. Qed. Lemma homothetie_bipoint : forall (k : R) (I A B A' B' : PO), A' = homothetie k I A -> B' = homothetie k I B -> vec A' B' = mult_PP k (vec A B). unfold homothetie, vec in |- *; intros. rewrite H. rewrite H0. replace (cons (-1) (barycentre (cons k A) (cons (1 + - k) I))) with (mult_PP (-1) (cons 1 (barycentre (cons k A) (cons (1 + - k) I)))); try ring; auto. pattern 1 at 2 in |- *. replace 1 with (k + (1 + - k)); try ring. pattern 1 at 4 in |- *. replace 1 with (k + (1 + - k)); try ring. repeat rewrite <- add_PP_barycentre; try discrR. RingPP. replace (k + (1 + - k)) with 1; try ring. try discrR. replace (k + (1 + - k)) with 1; try ring. try discrR. RingPP. Qed. Lemma homothetie_milieu : forall (k : R) (I A A' B B' M N : PO), k <> 0 -> A' = homothetie k I A :>PO -> B' = homothetie k I B :>PO -> M = milieu A B :>PO -> N = milieu A' B' :>PO -> homothetie k I M = N. unfold homothetie, milieu in |- *; intros. rewrite H2; rewrite H3; rewrite H1; rewrite H0. elim cons_inj with (a := 2) (b := 2) (A := barycentre (cons k (barycentre (cons 1 A) (cons 1 B))) (cons (1 + - k) I)) (B := barycentre (cons 1 (barycentre (cons k A) (cons (1 + - k) I))) (cons 1 (barycentre (cons k B) (cons (1 + - k) I)))); (intros; auto); try discrR. repeat rewrite <- add_PP_barycentre; try discrR. replace 2 with (2 * (k + (1 + - k))); try ring; auto. rewrite <- (homogene_barycentre (a:=k) (b:=1 + - k) (k:=2) (barycentre (cons 1 A) (cons 1 B)) I); try discrR. replace (2 * (k + (1 + - k))) with (2 * k + 2 * (1 + - k)); try ring; try discrR. repeat rewrite <- add_PP_barycentre; try discrR. rewrite <- (homogene_barycentre (a:=1) (b:=1) (k:=k) A B); auto; try discrR. replace (2 * k) with (k * 1 + k * 1); try ring; auto. repeat rewrite <- add_PP_barycentre; auto; try discrR. pattern 1 at 6 in |- *. replace 1 with (k + (1 + - k)); try ring; auto. repeat rewrite <- add_PP_barycentre; try discrR. pattern 1 at 7 in |- *. replace 1 with (k + (1 + - k)); try ring; auto. repeat rewrite <- add_PP_barycentre; try discrR. RingPP. replace (k + (1 + - k)) with 1; try ring; try discrR. replace (k + (1 + - k)) with 1; try ring; try discrR. replace (k * 1 + k * 1) with (k * 2); try ring; auto. apply Rmult_integral_contrapositive; (split; auto; try discrR). replace (2 * k + 2 * (1 + - k)) with (2 * 1); try ring; try discrR. replace (k + (1 + - k)) with 1; try ring; try discrR. Qed. Lemma image_homothetie_distincts : forall (k : R) (I A A' B B' : PO), k <> 0 :>R -> A <> B -> A' = homothetie k I A :>PO -> B' = homothetie k I B -> A' <> B'. intros. cut (vec A' B' <> zero); intros. red in |- *; intros; apply H3; auto. rewrite H4; Ringvec. rewrite (homothetie_bipoint (k:=k) (I:=I) (A:=A) (B:=B) (A':=A') (B':=B')); auto. red in |- *; intros. elim produit_vecteur_nul with (a := k) (A := A) (B := B); [ intros; try trivial | intros; try trivial | try trivial ]. absurd (k = 0); auto. absurd (A = B); auto. Qed. Lemma homothetie_droite : forall (k : R) (I A A' B B' : PO), k <> 0 :>R -> A <> B -> A' = homothetie k I A :>PO -> B' = homothetie k I B :>PO -> paralleles (droite A' B') (droite A B). intros. apply colineaires_paralleles with k; auto. apply image_homothetie_distincts with (3 := H1) (4 := H2); auto. apply homothetie_bipoint with (I := I); auto. Qed. Lemma homothetie_inverse : forall (k : R) (I A A' : PO), k <> 0 :>R -> A' = homothetie k I A :>PO -> A = homothetie (/ k) I A' :>PO. intros. apply vecteur_homothetie. rewrite (homothetie_vecteur (k:=k) (I:=I) (A:=A) (A':=A')); auto. Fieldvec k. Qed. Hint Resolve homothetie_inverse: geo. Lemma homothetie_alignement : forall (k : R) (I A B A' B' C C' : PO), A' = homothetie k I A :>PO -> B' = homothetie k I B :>PO -> C' = homothetie k I C -> alignes A B C -> alignes A' B' C'. intros k I A B A' B' C C' H H0 H1 H2; try assumption. discrimine A B. assert (A' = B'); auto with geo. rewrite H0; rewrite <- H3; auto. halignes H2 ipattern:k0. apply colineaire_alignes with k0. rewrite (homothetie_bipoint (k:=k) (I:=I) (A:=A) (B:=B) (A':=A') (B':=B')); auto. rewrite (homothetie_bipoint (k:=k) (I:=I) (A:=A) (B:=C) (A':=A') (B':=C')); auto. rewrite H4. Ringvec. Qed. Lemma homothetie_paralleles : forall (k : R) (I A A' B B' C C' D D' : PO), k <> 0 :>R -> A <> B -> C <> D -> paralleles (droite A B) (droite C D) -> A' = homothetie k I A :>PO -> B' = homothetie k I B -> C' = homothetie k I C :>PO -> D' = homothetie k I D :>PO -> paralleles (droite A' B') (droite C' D'). intros. elim paralleles_vecteur with (A := A) (B := B) (C := C) (D := D); [ intros x H7; try clear paralleles_vecteur | auto | auto | auto ]. apply colineaires_paralleles with x. apply (image_homothetie_distincts (k:=k) (I:=I) (A:=A) (A':=A') (B:=B) (B':=B')); auto. apply (image_homothetie_distincts (k:=k) (I:=I) (A:=C) (A':=C') (B:=D) (B':=D')); auto. rewrite (homothetie_bipoint (k:=k) (I:=I) (A:=A) (B:=B) (A':=A') (B':=B')); auto. rewrite (homothetie_bipoint (k:=k) (I:=I) (A:=C) (B:=D) (A':=C') (B':=D')); auto. rewrite H7; Ringvec. Qed. Lemma homothetie_intersection : forall (k : R) (I A A' B B' C C' D D' K K' : PO), k <> 0 :>R -> A <> B -> C <> D -> ~ alignes A B C \/ ~ alignes A B D -> K = pt_intersection (droite A B) (droite C D) :>PO -> A' = homothetie k I A :>PO -> B' = homothetie k I B -> C' = homothetie k I C :>PO -> D' = homothetie k I D :>PO -> K' = homothetie k I K :>PO -> K' = pt_intersection (droite A' B') (droite C' D') :>PO. intros. elim def_pt_intersection2 with (A := A) (B := B) (C := C) (D := D) (I := K); [ try clear def_pt_intersection2; intros | auto | auto | auto | auto ]. apply def_pt_intersection; auto. apply image_homothetie_distincts with (3 := H4) (4 := H5); auto. apply image_homothetie_distincts with (3 := H6) (4 := H7); auto. elim H2; [ intros H11; try clear H2 | intros H11; try clear H2; try exact H11 ]. left. red in |- *; intros; apply H11. apply (homothetie_alignement (k:=/ k) (I:=I) (A:=A') (B:=B') (A':=A) (B':=B) (C:=C') (C':=C)); auto with geo. right; red in |- *; intros H2; apply H11. apply (homothetie_alignement (k:=/ k) (I:=I) (A:=A') (B:=B') (A':=A) (B':=B) (C:=D') (C':=D)); auto with geo. apply (homothetie_alignement (k:=k) (I:=I) (A:=A) (B:=B) (A':=A') (B':=B') (C:=K) (C':=K')); auto with geo. apply (homothetie_alignement (k:=k) (I:=I) (A:=C) (B:=D) (A':=C') (B':=D') (C:=K) (C':=K')); auto with geo. Qed. Lemma paralleles_dilatations : forall A A' B B' : PO, A <> B -> A' <> B' -> paralleles (droite A' B') (droite A B) -> (exists I : PO, (exists J : PO, A' = translation I J A /\ B' = translation I J B)) \/ (exists k : R, (exists I : PO, A' = homothetie k I A /\ B' = homothetie k I B)). intros. elim paralleles_vecteur with (A := A') (B := B') (C := A) (D := B); [ intros k H2; try clear paralleles_vecteur; try exact H2 | trivial | trivial | trivial ]. elim (classic (k = 0)); intros; auto. absurd (A' = B'); intros; auto. apply vecteur_nul_conf; auto. rewrite H2; rewrite H3; Ringvec. elim (classic (k = 1)); intros; auto. rewrite H4 in H2. left; try assumption. exists A; exists A'. split; apply rec_translation_vecteur; auto. apply egalite_vecteur; rewrite H2; Ringvec. right; try assumption. exists k; exists (barycentre (cons (- k) A) (cons 1 A')). cut (A' = homothetie k (barycentre (cons (- k) A) (cons 1 A')) A). intros H20. split; [ try assumption | idtac ]. apply vecteur_homothetie. replace (vec (barycentre (cons (- k) A) (cons 1 A')) B') with (add_PP (vec (barycentre (cons (- k) A) (cons 1 A')) A') (vec A' B')). cut (vec (barycentre (cons (- k) A) (cons 1 A')) A' = mult_PP k (vec (barycentre (cons (- k) A) (cons 1 A')) A)); intros. rewrite H5; rewrite H2; Ringvec. apply homothetie_vecteur; auto. Ringvec. unfold homothetie in |- *. replace (1 + - k) with (- k + 1); try ring; auto. apply conversion_PP with (a := 1) (b := 1); auto with real. pattern 1 at 2 in |- *. replace 1 with (k + (- k + 1)); try ring; auto. rewrite <- add_PP_barycentre; auto. rewrite <- add_PP_barycentre; auto. RingPP. red in |- *; intros; apply H4. replace 1 with (k + (- k + 1)). rewrite H5; try ring. ring. replace (k + (- k + 1)) with 1; try ring; auto with real. Qed.HighSchoolGeometry/distance_euclidienne.v0000644000076500007650000001636012073525611020556 0ustar coqcoq00000000000000(* This program is free software; you can redistribute it and/or *) (* modify it under the terms of the GNU Lesser General Public License *) (* as published by the Free Software Foundation; either version 2.1 *) (* of the License, or (at your option) any later version. *) (* *) (* This program is distributed in the hope that it will be useful, *) (* but WITHOUT ANY WARRANTY; without even the implied warranty of *) (* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *) (* GNU General Public License for more details. *) (* *) (* You should have received a copy of the GNU Lesser General Public *) (* License along with this program; if not, write to the Free *) (* Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA *) (* 02110-1301 USA *) Require Export representant_unitaire. Set Implicit Arguments. Unset Strict Implicit. Hint Resolve distance_non_nulle scalaire_positif: geo. Definition distance (A B : PO) := sqrt (scalaire (vec A B) (vec A B)). Lemma distance_pos : forall A B : PO, distance A B >= 0. unfold distance in |- *; intros; auto with geo real. Qed. Lemma distance_sym : forall A B : PO, distance A B = distance B A. unfold distance in |- *; intros; auto. VReplace (vec B A) (mult_PP (-1) (vec A B)). Simplscal. replace (-1 * -1 * scalaire (vec A B) (vec A B)) with (scalaire (vec A B) (vec A B)); try ring. Qed. Lemma distance_refl : forall A B : PO, distance A B = 0 <-> A = B. unfold distance in |- *; intros; red in |- *. split; [ idtac | try assumption ]. intros H; try assumption. apply distance_nulle. RReplace 0 (0 * 0). rewrite <- H; auto. symmetry in |- *. apply def_sqrt; auto with geo real. intros. rewrite <- H; auto. VReplace (vec A A) (mult_PP (-0) (vec A B)). Simplscal. replace (-0 * -0 * scalaire (vec A B) (vec A B)) with 0; try ring. try exact sqrt_0. Qed. Lemma distance_refl1 : forall A B : PO, distance A B = 0 :>R -> A = B :>PO. intros. elim (distance_refl A B); auto. Qed. Lemma distance_refl2 : forall A B : PO, A = B :>PO -> distance A B = 0 :>R. intros. elim (distance_refl A B); auto. Qed. Hint Resolve distance_refl1 distance_refl2: geo. Lemma caract_representant_unitaire : forall A B C : PO, A <> B -> vec A C = representant_unitaire (vec A B) -> vec A C = mult_PP (/ distance A B) (vec A B). unfold distance in |- *; intros. cut (alignes A B C /\ scalaire (vec A C) (vec A C) = 1 /\ scalaire (vec A B) (vec A C) >= 0); intros. elim H1; intros H2 H3; elim H3; intros H4 H5; try clear H3 H1; try exact H5. halignes H2 ipattern:k. rewrite H1 in H4. cut (/ scalaire (vec A B) (vec A B) = k * k); intros. cut (k = sqrt (/ scalaire (vec A B) (vec A B))); intros. rewrite H1; rewrite H6. rewrite sqrt_Rinv; auto with geo real. apply inversion_sqr; auto with geo real. rewrite H1 in H5. replace k with (k * scalaire (vec A B) (vec A B) * / scalaire (vec A B) (vec A B)). replace (k * scalaire (vec A B) (vec A B)) with (scalaire (vec A B) (mult_PP k (vec A B))). apply Rmult_pos; auto with geo real. Simplscal. field; auto with geo. replace (/ scalaire (vec A B) (vec A B)) with (1 * / scalaire (vec A B) (vec A B)). rewrite <- H4. Simplscal. field; auto with geo. field; auto with geo. apply def_representant_unitaire2; auto. Qed. Lemma distance_vecteur : forall A B : PO, A <> B -> vec A B = mult_PP (distance A B) (representant_unitaire (vec A B)). unfold distance in |- *; intros. elim existence_representant_unitaire with (A := A) (B := B); [ intros C H0; try clear existence_unitaire; try exact H0 | auto ]. rewrite <- H0; auto. rewrite (caract_representant_unitaire (A:=A) (B:=B) (C:=C)); auto. unfold distance in |- *. cut (sqrt (scalaire (vec A B) (vec A B)) <> 0); intros. Fieldvec (sqrt (scalaire (vec A B) (vec A B))). auto with *. Qed. Lemma dist_non_nulle : forall A B : PO, distance A B <> 0 -> A <> B. unfold distance in |- *; red in |- *; intros. apply H. rewrite H0. replace (scalaire (vec B B) (vec B B)) with 0. rewrite sqrt_0; ring. replace (vec B B) with (mult_PP 0 (vec A B)). Simplscal. Ringvec. Qed. Hint Resolve distance_pos dist_non_nulle: geo. Lemma distincts_dist_non_nulle : forall A B : PO, A <> B -> distance A B <> 0. unfold distance in |- *; intros; red in |- *; intros. apply H. apply distance_nulle. rewrite <- (def_sqrt (scalaire (vec A B) (vec A B))); auto with geo. rewrite H0; ring. Qed. Hint Resolve distincts_dist_non_nulle: geo. Lemma isometrie_distinct : forall A B A' B' : PO, A <> B -> distance A B = distance A' B' -> A' <> B'. intros. apply dist_non_nulle; rewrite <- H0; auto with geo. Qed. Lemma carre_scalaire_distance : forall A B : PO, scalaire (vec A B) (vec A B) = distance A B * distance A B. unfold distance in |- *; intros. rewrite def_sqrt; auto with geo. Qed. Lemma carre_egalite_distance : forall A B C D : PO, distance A B * distance A B = distance C D * distance C D -> distance A B = distance C D. intros. apply resolution; auto with geo. Qed. Lemma distance_carre : forall A B C D : PO, Rsqr (distance A B) = Rsqr (distance C D) -> distance A B = distance C D. unfold Rsqr in |- *; intros. apply carre_egalite_distance; auto with geo. Qed. Hint Resolve carre_egalite_distance distance_carre: geo. Lemma carre_scalaire_egalite_distance : forall A B C D : PO, scalaire (vec A B) (vec A B) = scalaire (vec C D) (vec C D) -> distance A B = distance C D. intros. apply carre_egalite_distance. repeat rewrite <- carre_scalaire_distance; auto with geo. Qed. Lemma unitaire_distincts2 : forall A B : PO, distance A B = 1 -> A <> B. intros. apply dist_non_nulle. rewrite H. discrR. Qed. Hint Resolve unitaire_distincts2: geo. Lemma distance_1_representant : forall A B : PO, distance A B = 1 -> vec A B = representant_unitaire (vec A B). intros. apply def_representant_unitaire; auto with geo. rewrite carre_scalaire_distance; rewrite H; ring. Qed. Lemma distance_1_carre_scalaire : forall A B : PO, distance A B = 1 -> scalaire (vec A B) (vec A B) = 1. intros. rewrite carre_scalaire_distance. rewrite H; ring. Qed. Lemma carre_scalaire_1_distance : forall A B : PO, scalaire (vec A B) (vec A B) = 1 -> distance A B = 1. intros. unfold distance in |- *. rewrite H. rewrite sqrt_1; auto with geo. Qed. Hint Resolve carre_scalaire_1_distance distance_1_carre_scalaire distance_1_representant: geo. Lemma milieu_distance : forall A B I : PO, I = milieu A B -> distance I A = distance I B. intros. apply carre_scalaire_egalite_distance. rewrite <- (milieu_vecteur (A:=A) (B:=B) (M:=I)); auto with geo. replace (vec I A) with (mult_PP (-1) (vec A I)); [ idtac | Ringvec ]. Simplscal. Qed. Hint Resolve milieu_distance: geo. Lemma egalite_vecteur_distance : forall A B C D : PO, vec A B = vec C D -> distance A B = distance C D :>R. intros. apply carre_scalaire_egalite_distance. rewrite H; auto. Qed. Lemma colinearite_distance : forall (k : R) (A B C D : PO), vec C D = mult_PP k (vec A B) :>PP -> distance C D = Rabs k * distance A B. unfold distance in |- *; intros. rewrite H; Simplscal. replace (k * k) with (Rsqr k); auto with real. rewrite sqrt_mult; auto with real geo. rewrite sqrt_Rsqr_abs; ring. Qed. Hint Resolve colinearite_distance: geo.HighSchoolGeometry/droite_Euler.v0000644000076500007650000001031512073525615017040 0ustar coqcoq00000000000000(* This program is free software; you can redistribute it and/or *) (* modify it under the terms of the GNU Lesser General Public License *) (* as published by the Free Software Foundation; either version 2.1 *) (* of the License, or (at your option) any later version. *) (* *) (* This program is distributed in the hope that it will be useful, *) (* but WITHOUT ANY WARRANTY; without even the implied warranty of *) (* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *) (* GNU General Public License for more details. *) (* *) (* You should have received a copy of the GNU Lesser General Public *) (* License along with this program; if not, write to the Free *) (* Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA *) (* 02110-1301 USA *) Require Export homothetie_plane. Require Export cocyclicite. Require Export orthocentre. Set Implicit Arguments. Unset Strict Implicit. Lemma vec_OAplusOBplusOC_orthogonal : forall A B C A' O M : PO, A' = milieu B C -> circonscrit O A B C -> vec O M = add_PP (vec O A) (add_PP (vec O B) (vec O C)) -> orthogonal (vec A M) (vec B C). intros. cut (orthogonal (vec O A') (vec B C)); intros. replace (vec A M) with (add_PP (mult_PP (-1) (vec O A)) (vec O M)); [ idtac | Ringvec ]. replace (add_PP (mult_PP (-1) (vec O A)) (vec O M)) with (add_PP (vec O B) (vec O C)). rewrite (prop_vecteur_milieu (B:=B) (C:=C) (A':=A') O); auto with geo. rewrite H1; Ringvec. apply milieu_centrecirconscrit_orthogonal_segment with A; auto. Qed. Lemma vec_OAplusOBplusOC_orthocentre : forall A B C O M : PO, triangle A B C -> circonscrit O A B C -> vec O M = add_PP (vec O A) (add_PP (vec O B) (vec O C)) -> M = orthocentre A B C. intros. deroule_triangle A B C. soit_milieu B C ipattern:A'. lapply (vec_OAplusOBplusOC_orthogonal (A:=A) (B:=B) (C:=C) (A':=A') (O:=O) (M:=M)); intros; auto. cut (orthogonal (vec C M) (vec A B)); intros. cut (orthogonal (vec B M) (vec C A)); intros. apply orthocentre_def; auto with geo. cut (orthogonal (vec A M) (vec B C)); intros; auto with geo. soit_milieu A C ipattern:B'. apply (vec_OAplusOBplusOC_orthogonal (A:=B) (B:=C) (C:=A) (A':=B') (O:=O) (M:=M)); auto with geo. apply circonscrit_permute; auto. apply circonscrit_permute; auto. rewrite H1; Ringvec. soit_milieu A B ipattern:C'. apply (vec_OAplusOBplusOC_orthogonal (A:=C) (B:=A) (C:=B) (A':=C') (O:=O) (M:=M)); auto. apply circonscrit_permute; auto. rewrite H1; Ringvec. Qed. Lemma centre_gravite_prop_vecteur : forall A B C G O : PO, G = centre_gravite A B C -> add_PP (vec O A) (add_PP (vec O B) (vec O C)) = mult_PP 3 (vec O G). unfold centre_gravite in |- *; intros. discrimine B C. rewrite <- (prop_vecteur_bary (a:=1) (b:=2) (A:=A) (B:=C) (G:=G) O); auto. Ringvec. discrR. rewrite H; rewrite H0; rewrite <- (milieu_trivial C); auto. soit_milieu B C ipattern:A'. rewrite (prop_vecteur_milieu (B:=B) (C:=C) (A':=A') O); auto. rewrite <- (prop_vecteur_bary (a:=1) (b:=2) (A:=A) (B:=A') (G:=G) O); auto. Ringvec. discrR. rewrite H1; auto. Qed. Hint Resolve centre_gravite_prop_vecteur: geo. Theorem droite_Euler_fort : forall A B C O G H : PO, triangle A B C -> G = centre_gravite A B C -> circonscrit O A B C -> H = orthocentre A B C -> vec O H = mult_PP 3 (vec O G). intros. rewrite <- (centre_gravite_prop_vecteur (A:=A) (B:=B) (C:=C) (G:=G) O); auto. elim existence_representant_som_vecteur with (A := O) (B := B) (C := O) (D := C); intros E H4; try clear existence_representant_som_vecteur; rewrite <- H4. elim existence_representant_som_vecteur with (A := O) (B := A) (C := O) (D := E); intros M H5; try clear existence_representant_som_vecteur; rewrite <- H5. cut (M = H); intros. rewrite <- H6; auto. rewrite H3. apply vec_OAplusOBplusOC_orthocentre with O; auto. rewrite <- H4; auto. Qed. Theorem droite_Euler : forall A B C O G H : PO, triangle A B C -> G = centre_gravite A B C -> circonscrit O A B C -> H = orthocentre A B C -> alignes O G H. intros. apply colineaire_alignes with 3; auto. apply droite_Euler_fort with (1 := H0); auto. Qed.HighSchoolGeometry/equations_cercles.v0000755000076500007650000001552712073525613020141 0ustar coqcoq00000000000000(* This program is free software; you can redistribute it and/or *) (* modify it under the terms of the GNU Lesser General Public License *) (* as published by the Free Software Foundation; either version 2.1 *) (* of the License, or (at your option) any later version. *) (* *) (* This program is distributed in the hope that it will be useful, *) (* but WITHOUT ANY WARRANTY; without even the implied warranty of *) (* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *) (* GNU General Public License for more details. *) (* *) (* You should have received a copy of the GNU Lesser General Public *) (* License along with this program; if not, write to the Free *) (* Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA *) (* 02110-1301 USA *) Require Export equations_droites. Require Export contact. Set Implicit Arguments. Unset Strict Implicit. Lemma cercle_equation : forall (A M : PO) (r a b x y : R), a = abscisse A -> b = ordonnee A -> x = abscisse M -> y = ordonnee M -> cercle A r M -> Rsqr (x + - a) + Rsqr (y + - b) = Rsqr r. icercle. assert (scalaire (vec A M) (vec A M) = Rsqr r). rewrite carre_scalaire_distance; rewrite H3; auto. rewrite <- H4. assert (vec A M = add_PP (mult_PP (x + - a) (vec O I)) (mult_PP (y + - b) (vec O J))). apply composantes_vecAB; auto with geo. rewrite (scalaire_composantes_ABCD (O:=O) (I:=I) (J:=J) (A:=A) (B:=M) (C:=A) (D:=M) (x:=x + - a) (y:=y + - b) (x':=x + - a) (y':=y + - b)) ; auto with geo. Qed. Lemma equation_cartesienne_cercle : forall (M : PO) (x y a b r : R), r >= 0 -> x = abscisse M -> y = ordonnee M -> Rsqr (x + - a) + Rsqr (y + - b) = Rsqr r -> exists A : _, cercle A r M. icercle. assert (vec O M = add_PP (mult_PP x (vec O I)) (mult_PP y (vec O J))); auto with geo. elim existence_representant_comb_lin_vecteur with (A := O) (B := I) (C := O) (D := J) (a := a) (b := b); intros A H4. exists A. assert (vec A M = add_PP (mult_PP (x + - a) (vec O I)) (mult_PP (y + - b) (vec O J))); auto with geo. apply composantes_vecAB; eauto with geo. assert (scalaire (vec A M) (vec A M) = Rsqr r). rewrite (scalaire_composantes_ABCD (O:=O) (I:=I) (J:=J) (A:=A) (B:=M) (C:=A) (D:=M) (x:=x + - a) (y:=y + - b) (x':=x + - a) (y':=y + - b)) ; auto with geo. rewrite carre_scalaire_distance in H6. apply Rsqr_inj; auto with geo real. Qed. Lemma equation_generale_cercle : forall (M : PO) (x y a b c : R), c + (Rsqr a + Rsqr b) >= 0 -> x = abscisse M -> y = ordonnee M -> Rsqr x + (Rsqr y + (2 * (a * x) + 2 * (b * y))) = c -> exists A : _, cercle A (sqrt (c + (Rsqr a + Rsqr b))) M. intros M x y a b c H H0 H1; try assumption. RReplace (Rsqr x + (Rsqr y + (2 * (a * x) + 2 * (b * y)))) (Rsqr x + 2 * (a * x) + (Rsqr y + 2 * (b * y))). replace (Rsqr x + 2 * (a * x)) with (Rsqr (x + a) + - Rsqr a). replace (Rsqr y + 2 * (b * y)) with (Rsqr (y + b) + - Rsqr b). intros; assert (Rsqr (x + - - a) + Rsqr (y + - - b) = c + (Rsqr a + Rsqr b)). RReplace (x + - - a) (x + a). RReplace (y + - - b) (y + b). rewrite <- H2; ring. apply (equation_cartesienne_cercle (M:=M) (x:=x) (y:=y) (a:= - a) (b:=- b) (r:=sqrt (c + (Rsqr a + Rsqr b)))); auto with real. rewrite Rsqr_sqrt; auto with real. rewrite Rsqr_plus; ring. rewrite Rsqr_plus; ring. Qed. Lemma tangente_cercle_equation : forall (A C M : PO) (a b c d x y : R), a = abscisse A -> b = ordonnee A -> c = abscisse C -> d = ordonnee C -> x = abscisse M -> y = ordonnee M -> tangente_cercle A C C M -> (c + - a) * (x + - c) + (d + - b) * (y + - d) = 0. icercle. rewrite <- (scalaire_composantes_ABCD (O:=O) (I:=I) (J:=J) (A:=A) (B:=C) (C:=C) (D:=M) (x:=c + - a) (y:=d + - b) (x':=x + - c) (y':=y + - d)) ; auto with geo. apply composantes_vecAB; eauto with geo. apply composantes_vecAB; eauto with geo. Qed. Lemma equation_tangente_cercle : forall (A C M : PO) (a b c d x y : R), a = abscisse A -> b = ordonnee A -> c = abscisse C -> d = ordonnee C -> x = abscisse M -> y = ordonnee M -> (c + - a) * (x + - c) + (d + - b) * (y + - d) = 0 -> tangente_cercle A C C M. icercle. assert (orthogonal (vec A C) (vec C M)). apply def_orthogonal2. rewrite (scalaire_composantes_ABCD (O:=O) (I:=I) (J:=J) (A:=A) (B:=C) (C:=C) (D:=M) (x:=c + - a) (y:=d + - b) (x':=x + - c) (y':=y + - d)) ; auto with geo. apply composantes_vecAB; eauto with geo. apply composantes_vecAB; eauto with geo. auto with geo. Qed. Lemma cercle_diametre_equation : forall (A A' M : PO) (a b a' b' x y : R), a = abscisse A -> b = ordonnee A -> a' = abscisse A' -> b' = ordonnee A' -> x = abscisse M -> y = ordonnee M -> cercle_diametre A A' M -> (x + - a) * (x + - a') + (y + - b) * (y + - b') = 0. intros. elim (caracterisation_cercle_diametre A A' M); intros. rewrite <- H6; auto. rewrite <- (scalaire_composantes_ABCD (O:=O) (I:=I) (J:=J) (A:=A) (B:=M) (C:=A') (D:=M) (x:=x + - a) (y:=y + - b) (x':=x + - a') (y':=y + - b')) ; auto with geo. VReplace (vec A M) (mult_PP (-1) (vec M A)). VReplace (vec A' M) (mult_PP (-1) (vec M A')). Simplscal. apply composantes_vecAB; eauto with geo. apply composantes_vecAB; eauto with geo. Qed. Lemma equation_cercle_diametre : forall (A A' M : PO) (a b a' b' x y : R), a = abscisse A -> b = ordonnee A -> a' = abscisse A' -> b' = ordonnee A' -> x = abscisse M -> y = ordonnee M -> (x + - a) * (x + - a') + (y + - b) * (y + - b') = 0 -> cercle_diametre A A' M. intros. elim (caracterisation_cercle_diametre A A' M); intros. apply H7. rewrite <- H5. rewrite <- (scalaire_composantes_ABCD (O:=O) (I:=I) (J:=J) (A:=A) (B:=M) (C:=A') (D:=M) (x:=x + - a) (y:=y + - b) (x':=x + - a') (y':=y + - b')) ; auto with geo. VReplace (vec A M) (mult_PP (-1) (vec M A)). VReplace (vec A' M) (mult_PP (-1) (vec M A')). Simplscal. apply composantes_vecAB; eauto with geo. apply composantes_vecAB; eauto with geo. Qed. Lemma equation_k_cercle : forall (A A' K M : PO) (k a b a' b' x y : R), k + Rsqr (distance K A) >= 0 -> a = abscisse A -> b = ordonnee A -> a' = abscisse A' -> b' = ordonnee A' -> x = abscisse M -> y = ordonnee M -> K = milieu A A' -> (x + - a) * (x + - a') + (y + - b) * (y + - b') = k -> cercle K (sqrt (k + Rsqr (distance K A))) M. intros A A' K M k a b a' b' x y H H0 H1 H2 H3 H4 H5 H6; try assumption. rewrite <- (scalaire_composantes_ABCD (O:=O) (I:=I) (J:=J) (A:=A) (B:=M) (C:=A') (D:=M) (x:=x + - a) (y:=y + - b) (x':=x + - a') (y':=y + - b')) ; auto with geo. replace (scalaire (vec A M) (vec A' M)) with (scalaire (vec M A) (vec M A')). intros. apply ligne_niveau_MAMB_k with A'; auto. VReplace (vec M A) (mult_PP (-1) (vec A M)). VReplace (vec M A') (mult_PP (-1) (vec A' M)). Simplscal. apply composantes_vecAB; eauto with geo. apply composantes_vecAB; eauto with geo. Qed.HighSchoolGeometry/equations_droites.v0000644000076500007650000004753712117747636020207 0ustar coqcoq00000000000000(* This program is free software; you can redistribute it and/or *) (* modify it under the terms of the GNU Lesser General Public License *) (* as published by the Free Software Foundation; either version 2.1 *) (* of the License, or (at your option) any later version. *) (* *) (* This program is distributed in the hope that it will be useful, *) (* but WITHOUT ANY WARRANTY; without even the implied warranty of *) (* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *) (* GNU General Public License for more details. *) (* *) (* You should have received a copy of the GNU Lesser General Public *) (* License along with this program; if not, write to the Free *) (* Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA *) (* 02110-1301 USA *) Require Export determinant. Set Implicit Arguments. Unset Strict Implicit. Hint Resolve cart_def not_and_or or_not_and: geo. Parameter vec_directeur : PP -> DR -> Prop. Axiom vec_directeur_def : forall A B C D : PO, A <> B -> C <> D -> vec_directeur (vec A B) (droite C D) -> det (vec A B) (vec C D) = 0. Axiom vec_directeur_def2 : forall A B C D : PO, A <> B -> C <> D -> det (vec A B) (vec C D) = 0 -> vec_directeur (vec A B) (droite C D). Lemma vec_directeur_trivial : forall A B : PO, A <> B -> vec_directeur (vec A B) (droite A B). intros. apply vec_directeur_def2; auto. apply determinant_colinearite with 1; auto. Ringvec. Qed. Lemma existence_vec_directeur : forall A B : PO, A <> B -> exists C : PO, (exists D : PO, vec_directeur (vec C D) (droite A B)). intros. exists A; exists B. apply vec_directeur_trivial; auto. Qed. Lemma vec_directeur_permute : forall A B C D : PO, A <> B -> C <> D -> vec_directeur (vec A B) (droite C D) -> vec_directeur (vec C D) (droite A B). intros. apply vec_directeur_def2; auto. rewrite determinant_antisymetrique. rewrite vec_directeur_def; auto. ring. Qed. Lemma paralleles_vec_directeur : forall A B C D : PO, A <> B -> C <> D -> paralleles (droite A B) (droite C D) -> vec_directeur (vec A B) (droite C D). intros. apply vec_directeur_def2; auto. elim paralleles_vecteur with (A := C) (B := D) (C := A) (D := B); [ intros k H3; try clear paralleles_vecteur; try exact H3 | auto | auto | auto with geo ]. apply determinant_colinearite with k; auto. Qed. Hint Resolve vec_directeur_def vec_directeur_def2 cartvec_def: geo. Hint Immediate vec_directeur_permute: geo. Lemma vec_directeur_paralleles : forall A B C D : PO, A <> B -> C <> D -> vec_directeur (vec A B) (droite C D) -> paralleles (droite A B) (droite C D). intros. elim determinant_nul_colinearite with (A := C) (B := D) (C := A) (D := B); [ intros k H4; try clear determinant_nul_colinearite; try exact H4 | auto | auto with geo ]. apply colineaires_paralleles with k; auto. Qed. Hint Resolve vec_directeur_paralleles paralleles_vec_directeur: geo. Lemma vec_directeur_calcul : forall (A B C D : PO) (x y x0 y0 a b : R), A <> B -> C <> D -> x = abscisse D -> y = ordonnee D -> x0 = abscisse C -> y0 = ordonnee C -> a = absvec (vec A B) -> b = ordvec (vec A B) -> vec_directeur (vec A B) (droite C D) -> b * (x + - x0) + - (a * (y + - y0)) = 0. intros A B C D x y x0 y0 a b H H0 H1 H2 H3 H4 H5 H6 H7; try assumption. cut (vec C D = add_PP (mult_PP (x + - x0) (vec O I)) (mult_PP (y + - y0) (vec O J))); intros. 2: apply composantes_vecAB; eauto with geo. cut (vec A B = add_PP (mult_PP a (vec O I)) (mult_PP b (vec O J))); [ intros | auto with geo ]. RReplace 0 (-0). rewrite <- (vec_directeur_def (A:=A) (B:=B) (C:=C) (D:=D)); auto. rewrite (determinant_def (A:=A) (B:=B) (C:=C) (D:=D) (x:=a) (y:=b) (x':= x + - x0) (y':=y + - y0)); auto. ring. Qed. Lemma equation_droite_parallele : forall (A B C D : PO) (x y x0 y0 a b : R), A <> B -> C <> D -> x = abscisse D -> y = ordonnee D -> x0 = abscisse C -> y0 = ordonnee C -> a = absvec (vec A B) -> b = ordvec (vec A B) -> paralleles (droite A B) (droite C D) -> b * (x + - x0) + - (a * (y + - y0)) = 0. intros. apply vec_directeur_calcul with (1 := H) (2 := H0); auto with geo. Qed. Lemma alignes_equation_cartesienne : forall (A B M : PO) (x y : R), x = abscisse M -> y = ordonnee M -> A <> B -> alignes A B M -> exists a : R, (exists b : R, (exists c : R, a * x + (b * y + c) = 0 /\ ~ (a = 0 /\ b = 0))). intros A B M x y H20 H30 H0 H1; try assumption. cut (vec O M = add_PP (mult_PP x (vec O I)) (mult_PP y (vec O J))); [ intros H | auto with geo ]. elim composantes_vecteur with (O := O) (I := I) (J := J) (M := A) (N := B); [ intros a H2; elim H2; [ intros b H3; try clear H2; try exact H3 ] | auto with geo ]. elim existence_coordonnees with (O := O) (I := I) (J := J) (M := A); [ intros x0 H2; elim H2; [ intros y0 H4; try clear H2; try exact H4 ] | auto with geo ]. cut (vec A M = add_PP (mult_PP (x + - x0) (vec O I)) (mult_PP (y + - y0) (vec O J))); intros. 2: apply composantes_vecAB; eauto with geo. exists (- b); exists a; exists (b * x0 + - (a * y0)). split; [ try assumption | idtac ]. rewrite <- (alignement_determinant (A:=A) (B:=B) (M:=M)); auto. rewrite (determinant_def (A:=A) (B:=B) (C:=A) (D:=M) (x:=a) (y:=b) (x':= x + - x0) (y':=y + - y0)); auto. ring. contrapose H0. applatit_and. apply vecteur_nul_conf. rewrite H3. RReplace b (- - b). rewrite H6; rewrite H7; Ringvec. Qed. Lemma equation_cartesienne_alignes : forall (M : PO) (x y a b c : R), x = abscisse M -> y = ordonnee M -> ~ (a = 0 /\ b = 0) -> a * x + (b * y + c) = 0 -> exists A : _, (exists B : _, A <> B /\ alignes A B M). intros M x y a b c H20 H30 H0 H1; try assumption. cut (vec O M = add_PP (mult_PP x (vec O I)) (mult_PP y (vec O J))); [ intros H | auto with geo ]. cut (a <> 0 \/ b <> 0); intros. elim H2; intros. elim existence_representant_comb_lin_vecteur with (A := O) (B := I) (C := O) (D := J) (a := - c / a) (b := 0); [ intros A H4; try clear existence_representant_comb_lin_vecteur; try exact H4 ]. elim existence_representant_comb_lin_vecteur with (A := O) (B := I) (C := O) (D := J) (a := - b + - c / a) (b := a); [ intros B H6; try clear existence_representant_comb_lin_vecteur; try exact H6 ]. exists A; exists B. cut (vec A B = add_PP (mult_PP (- b) (vec O I)) (mult_PP a (vec O J))); intros. cut (A <> B); intros. split; [ try assumption | idtac ]. apply determinant_nul_alignement; auto. cut (vec A M = add_PP (mult_PP (x + c / a) (vec O I)) (mult_PP y (vec O J))); intros. rewrite (determinant_def (A:=A) (B:=B) (C:=A) (D:=M) (x:=- b) (y:=a) (x':= x + c / a) (y':=y)); auto. RReplace 0 (-0). rewrite <- H1; auto. RReplace (- b * y + - (a * (x + c / a))) (- (b * y + a * (x + c / a))). unfold Rdiv in |- *. RReplace (a * (x + c * / a)) (a * x + c * (a * / a)). RReplace (a * / a) 1. ring. RReplace (x + c / a) (x + - (- c / a)). RReplace y (y + -0). apply composantes_vecAB; eauto with geo. unfold Rdiv in |- *. ring. contrapose H3. rewrite H7 in H4. elim unicite_coordonnees with (O := O) (I := I) (J := J) (M := B) (x := - b + - c / a) (y := a) (x' := - c / a) (y' := 0); [ intros H9 H10; try clear unicite_coordonnees; try exact H10 | auto with geo | auto | auto ]. RReplace (- b) (- b + - c / a + - (- c / a)). pattern a at 3 in |- *. RReplace a (a + -0). apply composantes_vecAB; eauto with geo. elim existence_representant_comb_lin_vecteur with (A := O) (B := I) (C := O) (D := J) (a := 0) (b := - c / b); [ intros A H4; try clear existence_representant_comb_lin_vecteur; try exact H4 ]. elim existence_representant_comb_lin_vecteur with (A := O) (B := I) (C := O) (D := J) (a := - b) (b := a + - c / b); [ intros B H6; try clear existence_representant_comb_lin_vecteur; try exact H6 ]. exists A; exists B. cut (vec A B = add_PP (mult_PP (- b) (vec O I)) (mult_PP a (vec O J))); intros. cut (A <> B); intros. split; [ try assumption | idtac ]. apply determinant_nul_alignement; auto. cut (vec A M = add_PP (mult_PP x (vec O I)) (mult_PP (y + c / b) (vec O J))); intros. rewrite (determinant_def (A:=A) (B:=B) (C:=A) (D:=M) (x:=- b) (y:=a) (x':=x) (y':=y + c / b)); auto. RReplace 0 (-0). rewrite <- H1; auto. RReplace (- b * (y + c / b) + - (a * x)) (- (b * (y + c / b) + a * x)). unfold Rdiv in |- *. RReplace (b * (y + c * / b)) (b * y + c * (b * / b)). RReplace (b * / b) 1. ring. RReplace (y + c / b) (y + - (- c / b)). RReplace x (x + -0). apply composantes_vecAB; eauto with geo. unfold Rdiv in |- *. ring. contrapose H3. rewrite H7 in H4. elim unicite_coordonnees with (O := O) (I := I) (J := J) (M := B) (x := - b) (y := a + - c / b) (x' := 0) (y' := - c / b); [ intros H9 H10; try clear unicite_coordonnees; try exact H10 | auto with geo | auto | auto ]. RReplace 0 (-0). rewrite <- H9; ring. RReplace (- b) (- b + -0). RReplace a (a + - c / b + - (- c / b)). apply composantes_vecAB; eauto with geo. apply not_and_or; auto. Qed. Parameter vec_normal : PP -> DR -> Prop. Axiom vec_normal_def : forall A B C D : PO, A <> B -> C <> D -> vec_normal (vec A B) (droite C D) -> orthogonal (vec A B) (vec C D). Axiom vec_normal_def2 : forall A B C D : PO, A <> B -> C <> D -> orthogonal (vec A B) (vec C D) -> vec_normal (vec A B) (droite C D). Require Export angles_droites. Hint Resolve vec_normal_def vec_normal_def2: geo. Lemma existence_vec_normal : forall A B : PO, A <> B -> exists C : PO, (exists D : PO, vec_normal (vec C D) (droite A B)). intros. soit_orthogonal A B ipattern:D. exists A; exists D; auto with geo. Qed. Lemma vec_normal_permute : forall A B C D : PO, A <> B -> C <> D -> vec_normal (vec A B) (droite C D) -> vec_normal (vec C D) (droite A B). intros. eauto with geo. Qed. Hint Immediate vec_normal_permute: geo. Lemma vec_normal_directeur_orthogonaux : forall A B C D E F : PO, A <> B -> C <> D -> E <> F -> vec_normal (vec C D) (droite A B) -> vec_directeur (vec E F) (droite A B) -> orthogonal (vec C D) (vec E F). intros. apply vec_normal_def; auto. elim determinant_nul_colinearite with (A := A) (B := B) (C := E) (D := F); [ intros k H4; try clear determinant_nul_colinearite; try exact H4 | auto | auto with geo ]. apply vec_normal_def2; auto. apply ortho_sym. rewrite H4; eauto with geo. Qed. Lemma vec_normal_orthogonal_directeur : forall A B C D E F : PO, A <> B -> C <> D -> E <> F -> vec_normal (vec C D) (droite A B) -> orthogonal (vec C D) (vec E F) -> vec_directeur (vec E F) (droite A B). intros. apply paralleles_vec_directeur; auto. elim orthogonal_colineaires with (A := C) (B := D) (C := A) (D := B) (E := E) (F := F); [ intros k H4; try clear orthogonal_colineaires; try exact H4 | auto | auto | auto with geo | auto with geo ]. apply colineaires_paralleles with k; auto. Qed. Lemma vec_directeur_orthogonal_normal : forall A B C D E F : PO, A <> B -> C <> D -> E <> F -> vec_directeur (vec E F) (droite A B) -> orthogonal (vec C D) (vec E F) -> vec_normal (vec C D) (droite A B). intros. apply vec_normal_def2; auto. apply ortho_sym. elim determinant_nul_colinearite with (A := E) (B := F) (C := A) (D := B); [ intros k H4; try clear determinant_nul_colinearite; try exact H4 | auto | auto with geo ]. rewrite H4; auto with geo. Qed. Lemma paralleles_l_vec_normal : forall A B C D E F : PO, A <> B -> C <> D -> E <> F -> paralleles (droite A B) (droite E F) -> vec_normal (vec A B) (droite C D) -> vec_normal (vec E F) (droite C D). intros. elim paralleles_vecteur with (A := E) (B := F) (C := A) (D := B); [ intros k H4; try clear paralleles_vecteur | auto | auto | auto with geo ]. apply vec_normal_def2; auto. rewrite H4; eauto with geo. Qed. Lemma vec_normal_paralleles_l : forall A B C D E F : PO, A <> B -> C <> D -> E <> F -> vec_normal (vec A B) (droite C D) -> vec_normal (vec E F) (droite C D) -> paralleles (droite A B) (droite E F). intros. elim orthogonal_colineaires with (A := C) (B := D) (C := E) (D := F) (E := A) (F := B); [ intros k H4; try clear orthogonal_colineaires; try exact H4 | auto | auto | auto with geo | auto with geo ]. apply colineaires_paralleles with k; auto. Qed. Lemma vec_normal_paralleles_r : forall A B C D E F : PO, A <> B -> C <> D -> E <> F -> vec_normal (vec A B) (droite C D) -> vec_normal (vec A B) (droite E F) -> paralleles (droite C D) (droite E F). intros. elim orthogonal_colineaires with (A := A) (B := B) (C := E) (D := F) (E := C) (F := D); [ intros k H4; try clear orthogonal_colineaires; try exact H4 | auto | auto | auto with geo | auto with geo ]. apply colineaires_paralleles with k; auto. Qed. Lemma paralleles_r_vec_normal : forall A B C D E F : PO, A <> B -> C <> D -> E <> F -> paralleles (droite C D) (droite E F) -> vec_normal (vec A B) (droite C D) -> vec_normal (vec A B) (droite E F). intros. elim paralleles_vecteur with (A := E) (B := F) (C := C) (D := D); [ intros k H4; try clear paralleles_vecteur | auto | auto | auto with geo ]. apply vec_normal_def2; auto. apply ortho_sym. rewrite H4; eauto with geo. Qed. Lemma vec_normal_calcul : forall (A B C D : PO) (x y x0 y0 a b : R), A <> B -> C <> D -> x = abscisse D -> y = ordonnee D -> x0 = abscisse C -> y0 = ordonnee C -> a = absvec (vec A B) -> b = ordvec (vec A B) -> vec_normal (vec A B) (droite C D) -> a * (x + - x0) + b * (y + - y0) = 0. intros A B C D x y x0 y0 a b H H0 H1 H2 H3 H4 H5 H6 H7; try assumption. elim existence_representant_vecteur with (A := O) (B := A) (C := B); [ intros M H10 ]. elim existence_representant_vecteur with (A := O) (B := C) (C := D); [ intros N H20 ]. cut (vec C D = add_PP (mult_PP (x + - x0) (vec O I)) (mult_PP (y + - y0) (vec O J))); intros. 2: apply composantes_vecAB; eauto with geo. cut (vec A B = add_PP (mult_PP a (vec O I)) (mult_PP b (vec O J))); [ intros | auto with geo ]. replace 0 with (scalaire (vec A B) (vec C D)); auto with geo. rewrite <- H10; rewrite <- H20. rewrite (scalaire_coordonnees (O:=O) (I:=I) (J:=J) (M:=M) (N:=N) (x:=a) (y:=b) (x':=x + - x0) (y':=y + - y0)); auto with geo. rewrite H10; auto. rewrite H20; auto. Qed. Lemma equation_droite_orthogonal : forall (A B C D : PO) (x y x0 y0 a b : R), A <> B -> C <> D -> x = abscisse D -> y = ordonnee D -> x0 = abscisse C -> y0 = ordonnee C -> a = absvec (vec A B) -> b = ordvec (vec A B) -> orthogonal (vec A B) (vec C D) -> a * (x + - x0) + b * (y + - y0) = 0. intros. apply vec_normal_calcul with (1 := H) (2 := H0); auto with geo. Qed. Lemma orthogonal_equation_cartesienne : forall (A B M : PO) (x y : R), x = abscisse M -> y = ordonnee M -> A <> B -> orthogonal (vec A B) (vec A M) -> exists a : R, (exists b : R, (exists c : R, a * x + (b * y + c) = 0 /\ ~ (a = 0 /\ b = 0))). intros A B M x y H20 H30 H0 H1; try assumption. cut (vec O M = add_PP (mult_PP x (vec O I)) (mult_PP y (vec O J))); [ intros H | auto with geo ]. elim composantes_vecteur with (O := O) (I := I) (J := J) (M := A) (N := B); [ intros a H2; elim H2; [ intros b H3; try clear H2; try exact H3 ] | auto with geo ]. elim existence_coordonnees with (O := O) (I := I) (J := J) (M := A); [ intros x0 H2; elim H2; [ intros y0 H4; try clear H2; try exact H4 ] | auto with geo ]. cut (vec A M = add_PP (mult_PP (x + - x0) (vec O I)) (mult_PP (y + - y0) (vec O J))); intros. 2: apply composantes_vecAB; eauto with geo. exists a; exists b; exists (- (a * x0) + - (b * y0)). split; [ try assumption | idtac ]. discrimine A M. cut (x = x0 /\ y = y0); intros. applatit_and. rewrite H7; rewrite H8; ring. rewrite H5 in H4. apply unicite_composantes_vecteur with (2 := H) (3 := H4); auto with geo. RReplace (a * x + (b * y + (- (a * x0) + - (b * y0)))) (a * (x + - x0) + b * (y + - y0)). apply vec_normal_calcul with (1 := H0) (2 := H5); eauto with geo. contrapose H0. applatit_and. apply vecteur_nul_conf. rewrite H3. RReplace b (- - b). rewrite H6; rewrite H7; Ringvec. Qed. Lemma equation_cartesienne_orthogonal : forall (M : PO) (x y a b c : R), x = abscisse M -> y = ordonnee M -> ~ (a = 0 /\ b = 0) -> a * x + (b * y + c) = 0 -> exists A : _, (exists B : _, A <> B /\ orthogonal (vec A B) (vec A M)). intros M x y a b c H20 H30 H0 H1; try assumption. cut (vec O M = add_PP (mult_PP x (vec O I)) (mult_PP y (vec O J))); [ intros H | auto with geo ]. cut (a <> 0 \/ b <> 0); intros. elim H2; intros. elim existence_representant_comb_lin_vecteur with (A := O) (B := I) (C := O) (D := J) (a := - c / a) (b := 0); [ intros A H4; try clear existence_representant_comb_lin_vecteur; try exact H4 ]. elim existence_representant_comb_lin_vecteur with (A := O) (B := I) (C := O) (D := J) (a := a + - c / a) (b := b); [ intros B H6; try clear existence_representant_comb_lin_vecteur; try exact H6 ]. exists A; exists B. cut (vec A B = add_PP (mult_PP a (vec O I)) (mult_PP b (vec O J))); intros. cut (A <> B); intros. split; [ try assumption | idtac ]. cut (scalaire (vec A B) (vec A M) = 0); auto with geo. cut (vec A M = add_PP (mult_PP (x + c / a) (vec O I)) (mult_PP y (vec O J))); intros. elim existence_representant_vecteur with (A := O) (B := A) (C := B); [ intros N H21 ]. elim existence_representant_vecteur with (A := O) (B := A) (C := M); [ intros P H22 ]. rewrite <- H21; rewrite <- H22. rewrite (scalaire_coordonnees (O:=O) (I:=I) (J:=J) (M:=N) (N:=P) (x:=a) (y:=b) (x':=x + c / a) (y':=y)); auto with geo. rewrite <- H1; auto. unfold Rdiv in |- *. RReplace (a * (x + c * / a)) (a * x + c * (a * / a)). RReplace (a * / a) 1. ring. rewrite H21; auto. rewrite H22; auto. RReplace (x + c / a) (x + - (- c / a)). RReplace y (y + -0). apply composantes_vecAB; eauto with geo. unfold Rdiv in |- *. ring. contrapose H3. rewrite H7 in H4. RReplace a (a + - c / a + - (- c / a)). cut (a + - c / a = - c / a); intros. rewrite H8. unfold Rdiv in |- *. ring. elim unicite_coordonnees with (O := O) (I := I) (J := J) (M := B) (x := a + - c / a) (y := b) (x' := - c / a) (y' := 0); [ intros H9 H10; try clear unicite_coordonnees; try exact H9 | auto with geo | auto | auto ]. RReplace b (b + -0). RReplace a (a + - c / a + - (- c / a)). apply composantes_vecAB; eauto with geo. elim existence_representant_comb_lin_vecteur with (A := O) (B := I) (C := O) (D := J) (a := 0) (b := - c / b); [ intros A H4; try clear existence_representant_comb_lin_vecteur; try exact H4 ]. elim existence_representant_comb_lin_vecteur with (A := O) (B := I) (C := O) (D := J) (a := a) (b := b + - c / b); [ intros B H6; try clear existence_representant_comb_lin_vecteur; try exact H6 ]. exists A; exists B. cut (vec A B = add_PP (mult_PP a (vec O I)) (mult_PP b (vec O J))); intros. cut (A <> B); intros. split; [ try assumption | idtac ]. cut (scalaire (vec A B) (vec A M) = 0); auto with geo. cut (vec A M = add_PP (mult_PP x (vec O I)) (mult_PP (y + c / b) (vec O J))); intros. elim existence_representant_vecteur with (A := O) (B := A) (C := B); [ intros N H21 ]. elim existence_representant_vecteur with (A := O) (B := A) (C := M); [ intros P H22 ]. rewrite <- H21; rewrite <- H22. rewrite (scalaire_coordonnees (O:=O) (I:=I) (J:=J) (M:=N) (N:=P) (x:=a) (y:=b) (x':=x) (y':=y + c / b)); auto with geo. rewrite <- H1; auto. unfold Rdiv in |- *. RReplace (b * (y + c * / b)) (b * y + c * (b * / b)). RReplace (b * / b) 1. ring. rewrite H21; auto. rewrite H22; auto. RReplace (y + c / b) (y + - (- c / b)). RReplace x (x + -0). apply composantes_vecAB; eauto with geo. unfold Rdiv in |- *. ring. contrapose H3. rewrite H7 in H4. RReplace b (b + - c / b + - (- c / b)). cut (b + - c / b = - c / b); intros. rewrite H8. unfold Rdiv in |- *. ring. elim unicite_coordonnees with (O := O) (I := I) (J := J) (M := B) (x := a) (y := b + - c / b) (x' := 0) (y' := - c / b); [ intros H9 H10; try clear unicite_coordonnees; try exact H10 | auto with geo | auto | auto ]. RReplace a (a + -0). RReplace b (b + - c / b + - (- c / b)). apply composantes_vecAB; eauto with geo. apply not_and_or; auto. Qed.HighSchoolGeometry/euclidien_classiques.v0000755000076500007650000001762212117747636020636 0ustar coqcoq00000000000000(* This program is free software; you can redistribute it and/or *) (* modify it under the terms of the GNU Lesser General Public License *) (* as published by the Free Software Foundation; either version 2.1 *) (* of the License, or (at your option) any later version. *) (* *) (* This program is distributed in the hope that it will be useful, *) (* but WITHOUT ANY WARRANTY; without even the implied warranty of *) (* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *) (* GNU General Public License for more details. *) (* *) (* You should have received a copy of the GNU Lesser General Public *) (* License along with this program; if not, write to the Free *) (* Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA *) (* 02110-1301 USA *) Require Export distance_euclidienne. Set Implicit Arguments. Unset Strict Implicit. Lemma carre_scalaire_somme : forall A B C D : PO, scalaire (add_PP (vec A B) (vec C D)) (add_PP (vec A B) (vec C D)) = 2 * scalaire (vec A B) (vec C D) + (scalaire (vec A B) (vec A B) + scalaire (vec C D) (vec C D)) :>R. intros. VReplace (add_PP (vec A B) (vec C D)) (add_PP (mult_PP 1 (vec A B)) (mult_PP 1 (vec C D))). Simplscal. rewrite (scalaire_sym C D A B); ring. Qed. Lemma difference_Pythagore : forall A B C : PO, scalaire (vec B C) (vec B C) = scalaire (vec A B) (vec A B) + scalaire (vec A C) (vec A C) + -2 * scalaire (vec A B) (vec A C) :>R. intros. VReplace (vec B C) (add_PP (mult_PP (-1) (vec A B)) (mult_PP 1 (vec A C))). Simplscal. rewrite (scalaire_sym A C A B); ring. Qed. Lemma triangle_Pythagore : forall A B C : PO, scalaire (vec A B) (vec A C) = 0 <-> scalaire (vec B C) (vec B C) = scalaire (vec A B) (vec A B) + scalaire (vec A C) (vec A C) :>R. intros; red in |- *. rewrite (difference_Pythagore A B C). split; [ intros H; try assumption | idtac ]. rewrite H. ring. intros H; try assumption. cut (2 * scalaire (vec A B) (vec A C) = 0); intros. elim Rmult_integral with (r1 := 2) (r2 := scalaire (vec A B) (vec A C)); [ intros H1; try clear without_div_Od | intros H1; try clear without_div_Od; try exact H1 | try assumption ]. absurd (2 = 0); try assumption. discrR. replace 0 with (scalaire (vec A B) (vec A B) + scalaire (vec A C) (vec A C) + -1 * (scalaire (vec A B) (vec A B) + scalaire (vec A C) (vec A C))). pattern (scalaire (vec A B) (vec A B) + scalaire (vec A C) (vec A C)) at 2 in |- *. rewrite <- H. ring. ring. Qed. Theorem Pythagore : forall A B C : PO, orthogonal (vec A B) (vec A C) <-> Rsqr (distance B C) = Rsqr (distance A B) + Rsqr (distance A C) :>R. intros. unfold Rsqr in |- *; repeat rewrite <- carre_scalaire_distance. elim (triangle_Pythagore A B C); intros. red in |- *; split; intros. apply H; auto with geo. apply def_orthogonal2; auto. Qed. Lemma longueur_mediane : forall A B C I : PO, I = milieu B C -> Rsqr (distance A B) + Rsqr (distance A C) = R2 * (Rsqr (distance A I) + Rsqr (distance I B)) :>R. intros. unfold Rsqr, R2 in |- *; repeat rewrite <- carre_scalaire_distance. replace (vec A B) with (add_PP (mult_PP 1 (vec A I)) (mult_PP 1 (vec I B))). replace (vec A C) with (add_PP (mult_PP 1 (vec A I)) (mult_PP (-1) (vec I B))). Simplscal. replace (vec I B) with (mult_PP (-1) (vec I C)). Ringvec. rewrite <- (milieu_vecteur H). Ringvec. Ringvec. Qed. Lemma demi_longueur : forall A B I : PO, I = milieu A B -> Rsqr (distance A B) = R4 * Rsqr (distance A I) :>R. intros. unfold Rsqr, R4 in |- *; repeat rewrite <- carre_scalaire_distance. replace (vec A B) with (mult_PP 2 (vec A I)). Simplscal. rewrite <- (milieu_vecteur_double H); auto. Qed. Theorem mediane : forall A B C I : PO, I = milieu B C -> R4 * Rsqr (distance A I) = R2 * (Rsqr (distance A B) + Rsqr (distance A C)) - Rsqr (distance B C) :>R. unfold R2, R4 in |- *; intros. rewrite (longueur_mediane A (B:=B) (C:=C) (I:=I)); auto. rewrite (demi_longueur (A:=B) (B:=C) (I:=I)); unfold R2, R4 in |- *; auto. rewrite (distance_sym B I); auto. ring. Qed. Lemma rectangle_Pythagore : forall A B C : PO, orthogonal (vec A B) (vec A C) <-> scalaire (vec B C) (vec B C) = scalaire (vec A B) (vec A B) + scalaire (vec A C) (vec A C) :>R. intros. generalize (triangle_Pythagore A B C); unfold iff in |- *; intros. elim H; intros H0 H1; try clear H; try exact H0. split; [ intros H; try assumption | idtac ]. apply H0; auto with geo. intros H; try assumption. apply def_orthogonal2; auto. Qed. Require Export projection_orthogonale. Lemma Pythagore_projete_orthogonal : forall A B C H : PO, A <> B :>PO -> H = projete_orthogonal A B C :>PO -> Rsqr (distance A C) = Rsqr (distance H A) + Rsqr (distance H C) :>R /\ Rsqr (distance B C) = Rsqr (distance H B) + Rsqr (distance H C) :>R. intros. elim def_projete_orthogonal2 with (A := A) (B := B) (C := C) (H := H); [ intros; auto | auto | auto ]. halignes H2 ipattern:k. split; [ try assumption | idtac ]. elim (Pythagore H A C); intros. apply H5. replace (vec H A) with (mult_PP (-1) (vec A H)). rewrite H4. replace (mult_PP (-1) (mult_PP k (vec A B))) with (mult_PP (- k) (vec A B)). Simplortho. Ringvec. Ringvec. elim (Pythagore H B C); intros. apply H5. replace (vec H B) with (add_PP (mult_PP 1 (vec A B)) (mult_PP (- k) (vec A B))). Simplortho. replace (mult_PP (- k) (vec A B)) with (mult_PP (-1) (mult_PP k (vec A B))). rewrite <- H4. Ringvec. Ringvec. Qed. Lemma scalaire_difference_carre : forall A B I M : PO, I = milieu A B -> scalaire (vec M A) (vec M B) = Rsqr (distance M I) + - Rsqr (distance I A). intros. unfold Rsqr in |- *; repeat rewrite <- carre_scalaire_distance. VReplace (vec M B) (add_PP (mult_PP 1 (vec M I)) (mult_PP 1 (vec I B))). rewrite <- (milieu_vecteur H); auto. VReplace (mult_PP 1 (vec A I)) (mult_PP (-1) (vec I A)). VReplace (vec M A) (add_PP (mult_PP 1 (vec M I)) (mult_PP 1 (vec I A))). Simplscal. rewrite (scalaire_sym M I I A); ring. Qed. Lemma egalite_scalaire_deux_projetes : forall A B C H K : PO, A <> B -> A <> C -> H = projete_orthogonal A B C -> K = projete_orthogonal A C B -> scalaire (vec A B) (vec A H) = scalaire (vec A K) (vec A C). intros. elim scalaire_deux_projetes with (A := A) (B := B) (C := C) (H := H) (K := K); [ intros H4 H5; try clear scalaire_deux_projetes; try exact H5 | auto | auto | auto | auto ]. rewrite <- H4; auto. Qed. Lemma projete_distance_Rlt : forall A B C H : PO, A <> B -> H <> B -> H = projete_orthogonal A B C -> distance C H < distance C B. intros. elim def_projete_orthogonal2 with (A := A) (B := B) (C := C) (H := H); [ intros | auto | auto ]. elim (Pythagore H B C); intros. assert (Rsqr (distance C H) < Rsqr (distance C B)). rewrite (distance_sym C B). rewrite H5; auto. RReplace (Rsqr (distance C H)) (Rsqr (distance C H) + 0). assert (0 < Rsqr (distance H B)). assert (distance H B <> 0); auto with geo. cut (0 <= distance H B); auto with geo real. RReplace (Rsqr (distance H B) + Rsqr (distance H C)) (Rsqr (distance H C) + Rsqr (distance H B)). rewrite distance_sym; auto with real. halignes H3 ipattern:k. VReplace (vec H B) (add_PP (vec A B) (mult_PP (-1) (vec A H))). rewrite H7. VReplace (add_PP (vec A B) (mult_PP (-1) (mult_PP k (vec A B)))) (mult_PP (1 + - k) (vec A B)). auto with geo. apply Rsqr_incrst_0; auto with real geo. Qed. Parameter distance_droite : PO -> DR -> R. Axiom distance_droite_def : forall A B C H : PO, A <> B -> H = projete_orthogonal A B C -> distance_droite C (droite A B) = distance C H. Lemma existence_distance_droite : forall A B C : PO, A <> B -> exists d : R, d = distance_droite C (droite A B). intros A B C H0; try assumption. elim existence_projete_orthogonal with (A := A) (B := B) (C := C); [ intros H H1; try clear existence_projete_orthogonal; try exact H1 | auto ]. exists (distance C H). rewrite (distance_droite_def (A:=A) (B:=B) (C:=C) (H:=H)); auto. Qed.HighSchoolGeometry/exercice_espace.v0000644000076500007650000003350712073525613017533 0ustar coqcoq00000000000000(* This program is free software; you can redistribute it and/or *) (* modify it under the terms of the GNU Lesser General Public License *) (* as published by the Free Software Foundation; either version 2.1 *) (* of the License, or (at your option) any later version. *) (* *) (* This program is distributed in the hope that it will be useful, *) (* but WITHOUT ANY WARRANTY; without even the implied warranty of *) (* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *) (* GNU General Public License for more details. *) (* *) (* You should have received a copy of the GNU Lesser General Public *) (* License along with this program; if not, write to the Free *) (* Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA *) (* 02110-1301 USA *) Require Export orthogonalite_espace. Require Export affine_classiques. Set Implicit Arguments. Unset Strict Implicit. Definition tetraedre (A B C D : PO) := ~ coplanaires A B C D. Lemma tetraedre_non_alignes : forall A B C D : PO, tetraedre A B C D -> ~ alignes A B C. unfold tetraedre in |- *; intros. elim non_coplanaires_expl with (A := A) (B := B) (C := C) (D := D); [ intros H0 H1; try clear non_coplanaires_expl; try exact H0 | auto ]. Qed. Hint Resolve tetraedre_non_alignes: geo. Lemma deux_milieux_tetraedre : forall A B C D I J K L : PO, tetraedre A B C D -> I = milieu D A -> J = milieu D B -> K = milieu C A -> L = milieu C B -> vec I J = vec K L. intros. cut (mult_PP 2 (vec I J) = vec A B); intros. cut (mult_PP 2 (vec K L) = vec A B); intros. apply mult_PP_regulier with 2; auto with real. rewrite H5; auto. apply droite_milieu with C; auto. apply droite_milieu with D; auto. Qed. Definition parallelepipede (A B C D E F G H : PO) := (vec A B = vec D C /\ vec D C = vec H G) /\ vec H G = vec E F /\ vec E H = vec A D. Definition parallelepipede_rectangle (A B C D E F G H : PO) := parallelepipede A B C D E F G H /\ orthogonal (vec A B) (vec A D) /\ orthogonal (vec A B) (vec A E) /\ orthogonal (vec A D) (vec A E). Definition carre (A B C D : PO) := vec A B = vec D C /\ orthogonal (vec A B) (vec A D) /\ scalaire (vec A B) (vec A B) = 1 /\ scalaire (vec A D) (vec A D) = 1. Definition cube (A B C D E F G H : PO) := parallelepipede_rectangle A B C D E F G H /\ carre A B C D /\ scalaire (vec A E) (vec A E) = 1. Lemma parallelepipede_parallelogramme : forall A B C D E F G H : PO, parallelepipede A B C D E F G H -> vec F G = vec A D. unfold parallelepipede in |- *; intros A B C D E F G H' H. elim H; intros H0 H1; elim H1; intros H2 H3; try clear H1 H; try exact H3. elim H0; intros H H1; try clear H0; try exact H1. rewrite <- H3. apply egalite_vecteur. VReplace (vec F E) (mult_PP (-1) (vec E F)). rewrite <- H2. Ringvec. Qed. Lemma diagonales_carre : forall A B C D : PO, carre A B C D -> orthogonal (vec A C) (vec D B). intros. elim H; clear H; intros. apply def_orthogonal2. elim H0; intros H2 H3; elim H3; intros H4 H5; try clear H3 H0; try exact H5. cut (scalaire (vec A B) (vec A D) = 0); intros. replace (vec A C) with (add_PP (mult_PP 1 (vec A B)) (mult_PP 1 (vec A D))). replace (vec D B) with (add_PP (mult_PP (-1) (vec A D)) (mult_PP 1 (vec A B))). rewrite scalaire_bilineaire. rewrite H4; rewrite H5; rewrite H0. rewrite scalaire_sym; rewrite H0; ring. Ringvec. rewrite H. Ringvec. apply def_orthogonal; auto. Qed. Lemma centre_gravite_coplanaire : forall A B C : PO, ~ alignes A B C -> coplanaires A B C (centre_gravite A B C). unfold centre_gravite, milieu, coplanaires in |- *; intros. right; try assumption. exists (/ 3); exists (/ 3). cut (3 <> 0); intros; auto with real. apply mult_PP_regulier with 3; auto with real. FVReplace (mult_PP 3 (add_PP (cons (/ 3) A) (add_PP (cons (/ 3) B) (cons (1 + - (/ 3 + / 3)) C)))) (add_PP (cons 1 A) (add_PP (cons 1 B) (cons 1 C))) 3. VReplace (mult_PP 3 (cons 1 (barycentre (cons 1 A) (cons 2 (barycentre (cons 1 B) (cons 1 C)))))) (cons 3 (barycentre (cons 1 A) (cons 2 (barycentre (cons 1 B) (cons 1 C))))). repeat rewrite <- add_PP_barycentre; auto with real. Qed. Hint Resolve centre_gravite_coplanaire: geo. Lemma exercice : forall A B C D E F G H I : PO, D <> F -> ~ alignes E B G -> parallelepipede A B C D E F G H -> I = centre_gravite E B G -> coplanaires E B G I /\ alignes F D I. intros A B C D E F G H I H20 H0 H1 H51; try assumption. rewrite H51. split; [ auto with geo | idtac ]. cut (vec F G = vec A D). intros H10. unfold parallelepipede in H1. elim H1; intros H2 H3; elim H2; intros H4 H5; try clear H2 H1; try exact H4. elim H3; intros H2 H12; try clear H3. cut (vec F D = mult_PP 3 (vec F (centre_gravite E B G))); intros. cut (3 <> 0); intros; auto with real. apply colineaire_alignes with (/ 3); auto. rewrite H1. Fieldvec 3; auto. cut (add_PP (mult_PP 3 (vec (centre_gravite E B G) F)) (vec F D) = zero); intros. VReplace (vec F D) (add_PP (vec F D) (mult_PP (-1) zero)). rewrite <- H1. Ringvec. VReplace (vec F D) (add_PP (vec F B) (add_PP (vec B A) (vec A D))). replace (vec B A) with (vec F E); auto. replace (vec A D) with (vec F G); auto. VReplace (add_PP (vec F B) (add_PP (vec F E) (vec F G))) (add_PP (vec F E) (add_PP (vec F B) (vec F G))). replace (add_PP (vec F E) (add_PP (vec F B) (vec F G))) with (mult_PP 3 (vec F (barycentre (cons 1 E) (cons 2 (barycentre (cons 1 B) (cons 1 G)))))); auto. unfold vec, centre_gravite, milieu in |- *; RingPP. VReplace (add_PP (vec F B) (vec F G)) (add_PP (mult_PP 1 (vec F B)) (mult_PP 1 (vec F G))). rewrite (prop_vecteur_bary (a:=1) (b:=1) (A:=B) (B:=G) (G:=barycentre (cons 1 B) (cons 1 G)) F); auto. VReplace (vec F E) (mult_PP 1 (vec F E)). rewrite (prop_vecteur_bary (a:=1) (b:=2) (A:=E) (B:=barycentre (cons 1 B) (cons 1 G)) (G:=barycentre (cons 1 E) (cons 2 (barycentre (cons 1 B) (cons 1 G)))) F) ; auto. discrR. discrR. cut (vec A B = vec E F); intros; auto. VReplace (vec B A) (mult_PP (-1) (vec A B)). rewrite H1. Ringvec. rewrite H4. rewrite H5; auto. apply parallelepipede_parallelogramme with (1 := H1). Qed. Lemma exercice_cube : forall A B C D E F G H I : PO, D <> F -> ~ alignes E B G -> cube A B C D E F G H -> I = centre_gravite E B G -> alignes F D I /\ orthogonaux (droite F D) (plan E B G). intros A B C D E F G H I H0 H1 H2 H51; try assumption. elim H2; intros; clear H2. elim H3; intros; clear H3. elim H5; intros H3 H6; elim H6; intros H7 H8; try clear H6 H5; try exact H8. elim H4; intros H5 H6; try clear H4; try exact H6. split; [ try assumption | idtac ]. elim exercice with (A := A) (B := B) (C := C) (D := D) (E := E) (F := F) (G := G) (H := H) (I := I); [ try clear exercice; auto | auto | auto | auto | auto ]. elim H5; intros; clear H5. elim H9; intros H5 H10; elim H10; intros H11 H12; try clear H10 H9; try exact H12. elim H2; intros. elim H10; intros H13 H14; try clear H10; try exact H14. elim H9; intros H10 H15; try clear H9; try exact H15. cut (scalaire (vec A B) (vec A E) = 0); intros. cut (scalaire (vec A B) (vec A D) = 0); intros. cut (scalaire (vec A D) (vec A E) = 0); intros. cut (E <> B); intros. cut (E <> G); intros. cut (vec F D = add_PP (vec F A) (vec A D)); intros. apply def_orthogonaux; auto. apply def_orthogonales; auto. apply def_orthogonal2. rewrite scalaire_sym. rewrite H20. rewrite scalaire_somme_g. replace (scalaire (vec F A) (vec E B)) with 0. replace (scalaire (vec A D) (vec E B)) with 0. ring. replace (vec E B) with (add_PP (mult_PP (-1) (vec A E)) (mult_PP 1 (vec A B))). rewrite scalaire_lineaire_d. rewrite H17. rewrite scalaire_sym. rewrite H16. ring. Ringvec. replace (vec E B) with (add_PP (mult_PP (-1) (vec A E)) (mult_PP 1 (vec A B))). replace (vec F A) with (add_PP (mult_PP (-1) (vec A E)) (mult_PP (-1) (vec A B))). rewrite scalaire_bilineaire. rewrite H11; rewrite H6; rewrite H9. rewrite scalaire_sym. rewrite H9. ring. rewrite H10; rewrite H15; rewrite H13. Ringvec. Ringvec. apply def_orthogonales; auto. apply def_orthogonal2. replace (vec E G) with (add_PP (vec A B) (vec A D)). rewrite scalaire_somme_g. rewrite scalaire_sym. rewrite (scalaire_sym A D F D). rewrite H20. rewrite scalaire_somme_g. rewrite scalaire_somme_g. rewrite H12. rewrite (scalaire_sym A D A B). rewrite H16. replace (vec F A) with (add_PP (mult_PP (-1) (vec A E)) (mult_PP (-1) (vec A B))). rewrite scalaire_lineaire_g. rewrite scalaire_lineaire_g. rewrite H11; rewrite H16. rewrite scalaire_sym. rewrite H9. rewrite scalaire_sym. rewrite H17. ring. rewrite H10; rewrite H15; rewrite H13. Ringvec. replace (vec E G) with (add_PP (vec E F) (vec F G)). rewrite H10; rewrite H15; rewrite H13. rewrite parallelepipede_parallelogramme with (1 := H2); auto. Ringvec. Ringvec. apply distance_non_nulle. replace (vec E G) with (add_PP (mult_PP 1 (vec A B)) (mult_PP 1 (vec A D))). rewrite scalaire_bilineaire. rewrite H11; rewrite H12; rewrite H16. rewrite scalaire_sym; rewrite H16. replace (1 * 1 * 1 + 1 * 1 * 0 + (1 * 1 * 0 + 1 * 1 * 1)) with 2. discrR. ring. replace (vec E G) with (add_PP (vec E F) (vec F G)). rewrite H10; rewrite H15; rewrite H13. rewrite parallelepipede_parallelogramme with (1 := H2); auto. Ringvec. Ringvec. apply distance_non_nulle. replace (vec E B) with (add_PP (mult_PP (-1) (vec A E)) (mult_PP 1 (vec A B))). rewrite scalaire_bilineaire. rewrite H11; rewrite H9; rewrite H6. rewrite scalaire_sym; rewrite H9. replace (-1 * -1 * 1 + -1 * 1 * 0 + (1 * -1 * 0 + 1 * 1 * 1)) with 2. discrR. ring. Ringvec. apply def_orthogonal; auto. apply def_orthogonal; auto. apply def_orthogonal; auto. Qed. Lemma equilateral_non_alignes : forall A B C : PO, A <> B -> scalaire (vec A B) (vec A B) = scalaire (vec A C) (vec A C) -> scalaire (vec A B) (vec A B) = scalaire (vec B C) (vec B C) -> ~ alignes A B C. intros A B C H H0 H1; red in |- *; intros H2; try exact H2. halignes H2 ipattern:k. rewrite H3 in H0. cut (vec B C = mult_PP (k + -1) (vec A B)); intros. rewrite H4 in H1. cut (k * k = 1); intros. cut ((k + -1) * (k + -1) = 1); intros. cut (k = 1 \/ k = -1); intros. elim H7; [ intros H8; try clear H7; try exact H8 | intros H8; try clear H7 ]. rewrite H8 in H6. absurd (0 = 1); auto with *. rewrite <- H6; ring. rewrite H8 in H6. absurd ((-1 + -1) * (-1 + -1) = 1). try discrR. try assumption. cut (k + -1 = 0 \/ k + 1 = 0); intros. elim H7; [ intros H8; try clear H7; try exact H8 | intros H8; try clear H7 ]. left; try assumption. replace k with (k + -1 + 1). rewrite H8; ring. ring. right; try assumption. replace k with (k + 1 + -1). rewrite H8; ring. ring. apply Rmult_integral. replace 0 with (k * k + -1). ring. rewrite H5; ring. apply Rmult_eq_reg_l with (scalaire (vec A B) (vec A B)). replace (scalaire (vec A B) (vec A B) * 1) with (scalaire (vec A B) (vec A B)). pattern (scalaire (vec A B) (vec A B)) at 2 in |- *. rewrite H1. rewrite scalaire_mult_mult; ring. ring. unfold not in |- *; intros; apply H. apply distance_nulle; auto. apply Rmult_eq_reg_l with (scalaire (vec A B) (vec A B)). replace (scalaire (vec A B) (vec A B) * 1) with (scalaire (vec A B) (vec A B)). pattern (scalaire (vec A B) (vec A B)) at 2 in |- *. rewrite H0. rewrite scalaire_mult_mult; ring. ring. unfold not in |- *; intros; apply H. apply distance_nulle; auto. replace (vec B C) with (add_PP (vec A C) (mult_PP (-1) (vec A B))). rewrite H3. Ringvec. Ringvec. Qed. Theorem the_cube : forall A B C D E F G H I : PO, cube A B C D E F G H -> I = centre_gravite E B G -> alignes F D I /\ orthogonaux (droite F D) (plan E B G). intros A B C D E F G H I H0 H51; try assumption. elim H0; intros. elim H1; intros. elim H3; intros. elim H6; intros H7 H8; try clear H6; try exact H8. elim H5; intros H6 H9; try clear H5; try exact H9. elim H4; intros H5 H10; elim H10; intros H11 H12; try clear H10 H4; try exact H12. elim H2; intros H4 H10; try clear H2; try exact H10. elim H4; intros. elim H13; intros H14 H15; elim H15; intros H16 H17; try clear H15 H13; try exact H16. cut (vec A F = add_PP (mult_PP 1 (vec A B)) (mult_PP 1 (vec A E))); intros. cut (scalaire (vec A B) (vec A E) = 0); intros. cut (scalaire (vec A B) (vec A D) = 0); intros. cut (scalaire (vec A D) (vec A E) = 0); intros. apply exercice_cube with (3 := H0); auto. apply distance_non_nulle. replace (vec D F) with (add_PP (mult_PP 1 (vec A F)) (mult_PP (-1) (vec A D))). rewrite scalaire_bilineaire. replace (scalaire (vec A F) (vec A F)) with 2. cut (scalaire (vec A F) (vec A D) = 0); intros. rewrite H20; rewrite H17. rewrite scalaire_sym; rewrite H20. try discrR. rewrite H13. rewrite scalaire_lineaire_g. rewrite H18. rewrite scalaire_sym; rewrite H19. ring. rewrite H13. rewrite scalaire_bilineaire. rewrite H15; rewrite H10; rewrite H16. rewrite scalaire_sym; rewrite H15. ring. Ringvec. cut (vec E B = add_PP (mult_PP 1 (vec A B)) (mult_PP (-1) (vec A E))); intros. cut (vec E G = add_PP (mult_PP 1 (vec A B)) (mult_PP 1 (vec A D))); intros. apply equilateral_non_alignes; auto. apply distance_non_nulle. rewrite H20. rewrite scalaire_bilineaire. rewrite H15; rewrite H10; rewrite H16. rewrite scalaire_sym; rewrite H15. try discrR. rewrite H20. rewrite scalaire_bilineaire. rewrite H21. rewrite scalaire_bilineaire. rewrite H15; rewrite H10; rewrite H16. rewrite scalaire_sym; rewrite H15. rewrite H17; rewrite H18. rewrite scalaire_sym; rewrite H18. ring. replace (vec B G) with (add_PP (mult_PP 1 (vec E G)) (mult_PP (-1) (vec E B))). rewrite scalaire_bilineaire. rewrite H20. rewrite scalaire_bilineaire. rewrite H21. repeat rewrite scalaire_bilineaire. rewrite H15; rewrite H10; rewrite H16. rewrite scalaire_sym; rewrite H15. rewrite H17; rewrite H18. rewrite scalaire_sym; rewrite H18. rewrite H19; rewrite scalaire_sym; rewrite H19. ring. Ringvec. rewrite <- H8. rewrite H6; rewrite H9. Ringvec. Ringvec. apply def_orthogonal; auto. apply def_orthogonal; auto. apply def_orthogonal; auto. rewrite H6; rewrite H9; rewrite H7. Ringvec. Qed.HighSchoolGeometry/field.patch0000644000076500007650000000062312073525613016332 0ustar coqcoq0000000000000026c26 < Let AT = Eval Cbv Beta Delta [A] Iota in (A FT) --- > Let AT = Eval Cbv Beta Delta [A] Iota in (Field_Theory.A FT) 51c51 < Let AT = Eval Cbv Beta Delta [A] Iota in (A FT) In --- > Let AT = Eval Cbv Beta Delta [A] Iota in (Field_Theory.A FT) In 76c76 < Let AT = Eval Cbv Beta Delta [A] Iota in (A FT) --- > Let AT = Eval Cbv Beta Delta [A] Iota in (Field_Theory.A FT) HighSchoolGeometry/formes_complexes.v0000644000076500007650000004422612117747636020010 0ustar coqcoq00000000000000(* This program is free software; you can redistribute it and/or *) (* modify it under the terms of the GNU Lesser General Public License *) (* as published by the Free Software Foundation; either version 2.1 *) (* of the License, or (at your option) any later version. *) (* *) (* This program is distributed in the hope that it will be useful, *) (* but WITHOUT ANY WARRANTY; without even the implied warranty of *) (* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *) (* GNU General Public License for more details. *) (* *) (* You should have received a copy of the GNU Lesser General Public *) (* License along with this program; if not, write to the Free *) (* Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA *) (* 02110-1301 USA *) Require Export complexes. Set Implicit Arguments. Unset Strict Implicit. Parameter partie_reelle : C -> R. Parameter partie_imaginaire : C -> R. Axiom partie_reelle_def : forall (z : C) (a b : R), z = cons_cart a b -> a = partie_reelle z. Axiom partie_imaginaire_def : forall (z : C) (a b : R), z = cons_cart a b -> b = partie_imaginaire z. Axiom forme_algebrique_def : forall (z : C) (a b : R), a = partie_reelle z -> b = partie_imaginaire z -> z = cons_cart a b. Lemma car_image_forme_algebrique : forall (z : C) (M : PO), M = image z -> partie_reelle z = abscisse M /\ partie_imaginaire z = ordonnee M. intros. elim existence_coordonnees with (O := O) (I := I) (J := J) (M := M); [ intros x H2; elim H2; intros y H3 | auto with geo ]. cut (z = cons_cart x y); intros. rewrite <- (partie_reelle_def H0). rewrite <- (partie_imaginaire_def H0). split; eauto with geo. eauto with geo. Qed. Lemma coordonnees_affixe : forall M : PO, cons_cart (abscisse M) (ordonnee M) = affixe M :>C. intros. elim existence_affixe_point with (M := M); intros z H; try clear existence_affixe_point; try exact H. elim car_image_forme_algebrique with (z := z) (M := M); [ intros; try exact H1 | eauto with geo ]. rewrite <- H1; rewrite <- H0; rewrite <- H. symmetry in |- *; eauto with geo. Qed. Hint Resolve coordonnees_affixe: geo. Lemma absvec_ordvec_affixe : forall (a b : R) (A B : PO), a = absvec (vec A B) -> b = ordvec (vec A B) -> cons_cart a b = affixe_vec (vec A B). intros a b A B. elim existence_representant_vecteur with (A := O) (B := A) (C := B); intros D H1; try exact H1. rewrite <- H1; intros. apply affixe_point_vecteur. rewrite H0; rewrite H; rewrite (ordvec_ordonnee (O:=O) (I:=I) (J:=J) D); auto with geo. rewrite (absvec_abscisse (O:=O) (I:=I) (J:=J) D); auto with geo. Qed. Parameter module : C -> R. Parameter argument : C -> AV. Axiom module_def : forall (z : C) (M : PO), M = image z -> module z = distance O M. Axiom argument_def : forall (M : PO) (z : C), O <> M -> M = image z -> argument z = cons_AV (vec O I) (vec O M). Hint Resolve module_def argument_def: geo. Lemma module_def2 : forall (z : C) (M : PO), z = affixe M -> module z = distance O M. intros; eauto with geo. Qed. Lemma argument_def2 : forall (M : PO) (z : C), O <> M -> z = affixe M -> argument z = cons_AV (vec O I) (vec O M). intros; eauto with geo. Qed. Lemma existence_module : forall z : C, exists r : R, module z = r. intros. elim existence_image_complexe with (z := z); intros M H1; try clear existence_image_complexe; try exact H1. exists (distance O M); eauto with geo. Qed. Definition zeroC := cons_cart 0 0. Lemma image_zeroC : image zeroC = O. elim existence_image_complexe with (z := zeroC); unfold zeroC in |- *; intros M H1; try exact H1. cut (vec O M = add_PP (mult_PP 0 (vec O I)) (mult_PP 0 (vec O J))); intros; eauto with geo. rewrite <- H1. symmetry in |- *. apply vecteur_nul_conf. rewrite H. Ringvec. Qed. Hint Resolve image_zeroC: geo. Lemma affixe_origine : zeroC = affixe O. eauto with geo. Qed. Hint Resolve affixe_origine: geo. Lemma module_zeroC : module zeroC = 0. rewrite (module_def (z:=zeroC) (M:=O)); auto with geo. Qed. Lemma module_nul_zeroC : forall z : C, module z = 0 -> z = zeroC. intros. elim existence_image_complexe with (z := z); intros M H1; try clear existence_image_complexe; try exact H1. cut (O = M); intros. rewrite (affixe_image H1). rewrite <- H0; auto with geo. apply distance_refl1. rewrite <- H; symmetry in |- *; auto with geo. Qed. Hint Resolve module_zeroC module_nul_zeroC: geo. Lemma module_non_zero : forall z : C, z <> zeroC -> module z <> 0. red in |- *; intros. apply H; auto with geo. Qed. Lemma nonzero_module : forall z : C, module z <> 0 -> z <> zeroC. red in |- *; intros. apply H; rewrite H0; auto with geo. Qed. Hint Resolve module_non_zero nonzero_module: geo. Lemma image_nonzero_nonorigine : forall (M : PO) (z : C), z <> zeroC :>C -> M = image z -> O <> M. intros. red in |- *; intros; apply H. replace z with (affixe M). rewrite <- H1; auto with geo. symmetry in |- *; auto with geo. Qed. Hint Resolve image_nonzero_nonorigine: geo. Lemma nonorigine_image_nonzero : forall (M : PO) (z : C), O <> M -> M = image z -> z <> zeroC :>C. intros. red in |- *; intros; apply H. rewrite H0; rewrite H1. symmetry in |- *; auto with geo. Qed. Hint Resolve nonorigine_image_nonzero: geo. Lemma existence_argument : forall z : C, z <> zeroC -> exists a : R, argument z = image_angle a. intros. elim existence_image_complexe with (z := z); intros M H1; try clear existence_image_complexe; try exact H1. cut (O <> M); intros; eauto with geo. mesure O I O M. exists x. rewrite H2; eauto with geo. Qed. Lemma existence_forme_polaire : forall z : C, z <> zeroC -> exists r : R, (exists a : R, module z = r /\ argument z = image_angle a). intros. elim existence_module with (z := z); intros r H0; try clear existence_module; try exact H0. elim existence_argument with (z := z); [ intros a H1; try clear existence_argument; try exact H1 | auto ]. exists r; exists a; auto. Qed. Parameter cons_pol : R -> R -> C. Axiom forme_polaire_def : forall (z : C) (r a : R), z <> zeroC -> module z = r -> argument z = image_angle a -> z = cons_pol r a. Axiom complexe_polaire_module : forall r a : R, module (cons_pol r a) = r. Axiom complexe_polaire_argument : forall r a : R, r <> 0 -> argument (cons_pol r a) = image_angle a. Lemma polaire_non_nul : forall r a : R, r <> 0 -> cons_pol r a <> zeroC. intros. apply nonzero_module. rewrite complexe_polaire_module; auto. Qed. Lemma complexe_pol_module : forall (z : C) (r a : R), z <> zeroC -> z = cons_pol r a -> module z = r. intros. rewrite H0; rewrite complexe_polaire_module; auto. Qed. Lemma complexe_pol_argument : forall (z : C) (r a : R), z <> zeroC -> z = cons_pol r a -> argument z = image_angle a. intros. rewrite H0; rewrite complexe_polaire_argument; auto. rewrite <- (complexe_pol_module (z:=z) (r:=r) (a:=a)); auto with geo. Qed. Hint Resolve forme_polaire_def complexe_pol_module complexe_pol_argument polaire_non_nul complexe_polaire_module complexe_polaire_module: geo. Lemma pol_complexe_module : forall (z : C) (r a : R) (M : PO), z <> zeroC -> z = cons_pol r a -> M = image z -> distance O M = r. intros. rewrite <- (module_def H1); eauto with geo. Qed. Lemma pol_complexe_argument : forall (z : C) (r a : R) (M : PO), z <> zeroC -> z = cons_pol r a -> M = image z -> cons_AV (vec O I) (vec O M) = image_angle a. intros. rewrite <- (argument_def (M:=M) (z:=z)); eauto with geo. Qed. Hint Resolve pol_complexe_argument pol_complexe_module: geo. Lemma image_forme_polaire : forall (z : C) (M : PO), O <> M -> M = image z -> module z = distance O M /\ argument z = cons_AV (vec O I) (vec O M). intros. split; eauto with geo. Qed. Lemma unicite_forme_polaire_nonzero : forall (z : C) (r a r' a' : R), z <> zeroC -> z = cons_pol r a -> z = cons_pol r' a' -> r = r' /\ image_angle a = image_angle a'. intros. split. rewrite <- (complexe_pol_module (z:=z) (r:=r) (a:=a)); eauto with geo. rewrite <- (complexe_pol_argument (z:=z) (r:=r) (a:=a)); eauto with geo. Qed. Hint Resolve unicite_forme_polaire_nonzero image_forme_polaire: geo. Lemma passage_polaire_algebrique : forall (z : C) (r a x y : R), z <> zeroC -> z = cons_cart x y -> z = cons_pol r a -> x = r * cos a /\ y = r * sin a. intros. elim existence_image_complexe with (z := z); intros M H2; try clear existence_image_complexe; try exact H2. elim coordonnees_polaires_cartesiennes with (x := x) (y := y) (a := a) (r := r) (O := O) (I := I) (J := J) (M := M); [ intros; eauto with geo | eauto with geo | eauto with geo | eauto with geo | eauto with geo | eauto with geo ]. symmetry in |- *; eauto with geo. symmetry in |- *; eauto with geo. Qed. Lemma passage_algebrique_module : forall (z : C) (x y : R), z = cons_cart x y -> module z = sqrt (Rsqr x + Rsqr y). intros. elim existence_image_complexe with (z := z); intros M H2; try clear existence_image_complexe; try exact H2. replace (module z) with (distance O M); auto. rewrite (distance_coordonnees (O:=O) (I:=I) (J:=J) (M:=M) (x:=x) (y:=y)); eauto with geo. symmetry in |- *; eauto with geo. Qed. Lemma passage_algebrique_argument : forall (z : C) (r x y a : R), z <> zeroC -> z = cons_cart x y -> z = cons_pol r a -> cos a = / r * x /\ sin a = / r * y. intros. elim passage_polaire_algebrique with (z := z) (r := r) (a := a) (x := x) (y := y); [ intros | eauto with geo | eauto with geo | eauto with geo ]. cut (r <> 0); intros. split; [ try assumption | idtac ]. rewrite H2. field; auto. rewrite H3. field; auto. replace r with (module z); eauto with geo. Qed. Lemma egalite_forme_polaire : forall z z' : C, z <> zeroC -> z' <> zeroC -> module z = module z' -> argument z = argument z' -> z = z'. intros. elim existence_forme_polaire with (z := z); [ intros r H3; elim H3; intros a H4; elim H4; intros H5 H6; try clear H4 H3 existence_forme_polaire; try exact H6 | auto ]. elim existence_forme_polaire with (z := z'); [ intros r0 H7; elim H7; intros a0 H8; elim H8; intros H9 H10; try clear H8 H7 existence_forme_polaire; try exact H10 | auto ]. rewrite (forme_polaire_def (z:=z) (r:=r) (a:=a)); auto. rewrite (forme_polaire_def (z:=z') (r:=r) (a:=a)); auto. rewrite <- H5; auto. rewrite <- H6; auto. Qed. Hint Resolve passage_algebrique_module passage_algebrique_argument egalite_forme_polaire: geo. Lemma algebrique_zeroC : forall a b : R, cons_cart a b = zeroC :>C -> a = 0 /\ b = 0. intros. apply unicite_parties_relles_imaginaires with zeroC; auto. Qed. Lemma polaire_calcul_algebrique : forall (z : C) (r a : R), z <> zeroC :>C -> z = cons_pol r a :>C -> z = cons_cart (r * cos a) (r * sin a) :>C. intros. elim existence_parties_relles_imaginaires with (z := z); intros a0 H1; elim H1; intros b H2; try clear H1 existence_parties_relles_imaginaires; try exact H2. elim passage_polaire_algebrique with (z := z) (r := r) (a := a) (x := a0) (y := b); [ intros; try exact H4 | auto | auto | auto ]. rewrite H2; rewrite H3; rewrite H4; auto. Qed. Hint Resolve polaire_calcul_algebrique: geo. Definition Rinj (x : R) := cons_cart x 0. Definition oneC := cons_cart 1 0. Hint Unfold oneC zeroC Rinj: geo. Lemma Rinj_zero : Rinj 0 = zeroC. unfold Rinj, zeroC in |- *; auto. Qed. Lemma Rinj_un : Rinj 1 = oneC. unfold Rinj, oneC in |- *; auto. Qed. Lemma module_oneC : module oneC = 1. intros. rewrite (passage_algebrique_module (z:=oneC) (x:=1) (y:=0)). replace (Rsqr 1 + Rsqr 0) with 1 by (unfold Rsqr; ring). exact sqrt_1. unfold oneC in |- *; auto. Qed. Lemma oneC_nonzero : oneC <> zeroC. apply nonzero_module. rewrite module_oneC; auto with real. Qed. Hint Resolve module_oneC oneC_nonzero: geo. Lemma argument_oneC : argument oneC = image_angle 0. elim existence_forme_polaire with (z := oneC); [ intros r H; elim H; intros a H0; elim H0; intros H1 H2; try clear H0 H existence_forme_polaire; try exact H2 | auto with geo ]. rewrite module_oneC in H1. rewrite H2. elim passage_algebrique_argument with (z := oneC) (r := 1) (x := 1) (y := 0) (a := a); [ intros | auto with geo | auto with geo | auto with geo ]. apply egalite_angle_trigo. rewrite sin_zero; rewrite H4; ring. rewrite H3; rewrite cos_zero; field. Qed. Hint Resolve argument_oneC: geo. Definition i := cons_cart 0 1. Hint Unfold i: geo. Lemma module_i : module i = 1. intros. rewrite (passage_algebrique_module (z:=i) (x:=0) (y:=1)). replace (Rsqr 0 + Rsqr 1) with 1 by (unfold Rsqr; ring). exact sqrt_1. unfold i in |- *; auto. Qed. Lemma i_nonzero : i <> zeroC. apply nonzero_module. rewrite module_i; auto with real. Qed. Hint Resolve module_i i_nonzero: geo. Lemma argument_i : argument i = image_angle pisurdeux. elim existence_forme_polaire with (z := i); [ intros r H; elim H; intros a H0; elim H0; intros H1 H2; try clear H0 H existence_forme_polaire; try exact H2 | auto with geo ]. elim passage_algebrique_argument with (z := i) (r := 1) (x := 0) (y := 1) (a := a); [ intros | auto with geo | auto with geo | auto with geo ]. rewrite module_i in H1. rewrite H2. elim passage_algebrique_argument with (z := i) (r := 1) (x := 0) (y := 1) (a := a); [ intros | auto with geo | auto with geo | auto with geo ]. apply egalite_angle_trigo. rewrite sin_pisurdeux; rewrite H4; field. rewrite H3; rewrite cos_pisurdeux; ring. Qed. Hint Resolve argument_i: geo. Lemma forme_polaire_oneC : oneC = cons_pol 1 0. apply forme_polaire_def; auto with geo. Qed. Lemma forme_polaire_i : i = cons_pol 1 pisurdeux. apply forme_polaire_def; auto with geo. Qed. Hint Resolve forme_polaire_oneC forme_polaire_i: geo. Lemma egalite_cart_pol : forall x y r a : R, r <> 0 -> module (cons_cart x y) = r -> argument (cons_cart x y) = image_angle a :>AV -> cons_cart x y = cons_pol r a :>C. intros. rewrite <- (forme_polaire_def (z:=cons_cart x y) (r:=r) (a:=a)); auto with geo. apply nonzero_module. rewrite H0; auto. Qed. Lemma module_opp_un : module (Rinj (-1)) = 1. unfold Rinj in |- *. rewrite (passage_algebrique_module (z:=cons_cart (-1) 0) (x:=-1) (y:=0)); auto with geo. replace (Rsqr (-1) + Rsqr 0) with 1 by (unfold Rsqr; ring). exact sqrt_1. Qed. Lemma opp_un_nonzero : Rinj (-1) <> zeroC :>C. apply nonzero_module. rewrite module_opp_un; auto with real. Qed. Hint Resolve opp_un_nonzero module_opp_un: geo. Lemma argument_opp_un : argument (Rinj (-1)) = image_angle pi. elim existence_forme_polaire with (z := Rinj (-1)); [ intros r H1; elim H1; intros a H2; elim H2; intros H3 H4; try clear H2 H1; try exact H4 | auto with geo ]. rewrite module_opp_un in H3. elim passage_algebrique_argument with (z := Rinj (-1)) (r := 1) (x := -1) (y := 0) (a := a); [ intros | auto with geo | auto with geo | auto with geo ]. rewrite H4. apply egalite_angle_trigo. rewrite sin_pi; rewrite H0; ring. rewrite H; rewrite cos_pi; field. Qed. Hint Resolve argument_opp_un: geo. Lemma forme_polaire_opp_un : Rinj (-1) = cons_pol 1 pi. apply forme_polaire_def; auto with geo. Qed. Lemma module_reel : forall x : R, module (Rinj x) = Rabs x. unfold Rinj in |- *; intros. rewrite (passage_algebrique_module (z:=cons_cart x 0) (x:=x) (y:=0)); auto with geo. replace (Rsqr x + Rsqr 0) with (Rsqr x) by (unfold Rsqr; ring). rewrite sqrt_Rsqr_abs; auto. Qed. Lemma module_reel_pos : forall x : R, 0 <= x -> module (Rinj x) = x. unfold Rinj in |- *; intros. rewrite (passage_algebrique_module (z:=cons_cart x 0) (x:=x) (y:=0)); auto with geo. replace (Rsqr x + Rsqr 0) with (Rsqr x) by (unfold Rsqr in |- *; ring). rewrite sqrt_Rsqr; auto. Qed. Lemma reel_non_nul : forall x : R, x <> 0 -> Rinj x <> zeroC. intros. apply nonzero_module. rewrite module_reel. apply Rabs_no_R0; auto. Qed. Hint Resolve reel_non_nul module_reel_pos module_reel: geo. Lemma argument_reel_pos : forall x : R, 0 < x -> argument (Rinj x) = image_angle 0. intros. cut (x <> 0); intros. elim existence_forme_polaire with (z := Rinj x); [ intros r H1; elim H1; intros a H2; elim H2; intros H3 H4; try clear H2 H1; try exact H4 | auto with geo ]. cut (x = r); intros. elim passage_algebrique_argument with (z := Rinj x) (r := r) (x := x) (y := 0) (a := a); [ intros | auto with geo | auto with geo | auto with geo ]. rewrite H4. apply egalite_angle_trigo. rewrite sin_zero; rewrite H5; ring. rewrite H2; rewrite <- H1; rewrite cos_zero; field; trivial. rewrite module_reel_pos in H3; auto. fourier. auto with real. Qed. Hint Resolve argument_reel_pos: geo. Lemma forme_pol_reel_pos : forall x : R, 0 < x -> Rinj x = cons_pol x 0 :>C. intros. apply forme_polaire_def; auto with geo. apply reel_non_nul; auto with real. apply module_reel_pos; auto with real. Qed. Lemma module_reel_neg : forall x : R, 0 > x -> module (Rinj x) = - x. intros. rewrite module_reel; auto. apply Rabs_left1; auto with real. Qed. Hint Resolve module_reel_neg: geo. Lemma argument_reel_neg : forall x : R, 0 > x -> argument (Rinj x) = image_angle pi. intros. cut (x <> 0); intros. elim existence_forme_polaire with (z := Rinj x); [ intros r H1; elim H1; intros a H2; elim H2; intros H3 H4; try clear H2 H1; try exact H4 | auto with geo ]. elim passage_algebrique_argument with (z := Rinj x) (r := r) (x := x) (y := 0) (a := a); [ intros | auto with geo | auto with geo | auto with geo ]. rewrite H4. apply egalite_angle_trigo. rewrite sin_pi; rewrite H2; ring. cut (r = - x); intros. rewrite H1; rewrite H5; rewrite cos_pi; field; trivial. rewrite <- H3. rewrite module_reel_neg in |- *; [ ring | auto with geo ]. auto with real. Qed. Hint Resolve argument_reel_neg: geo. Lemma forme_pol_reel_neg : forall x : R, 0 > x -> Rinj x = cons_pol (- x) pi :>C. intros. apply forme_polaire_def; auto with geo. apply reel_non_nul; auto with real. Qed. Lemma module_pos : forall z : C, module z >= 0. intros. elim existence_image_complexe with (z := z); intros M H; try clear existence_image_complexe; try exact H. rewrite (module_def H); auto with geo. Qed. Hint Resolve module_pos: geo. Lemma module_stric_pos : forall z : C, z <> zeroC :>C -> module z > 0. intros. cut (module z >= 0); intros; auto with geo. elim H0; intros; auto. absurd (module z = 0); auto with geo. Qed. Hint Resolve module_stric_pos: geo. Lemma abs_module : forall z : C, module z = Rabs (module z). intros. cut (module z >= 0); intros; auto with geo. rewrite Rabs_right; auto. Qed. Hint Resolve abs_module: geo. HighSchoolGeometry/geometrie_complexes.v0000755000076500007650000000222212073525612020453 0ustar coqcoq00000000000000(* This program is free software; you can redistribute it and/or *) (* modify it under the terms of the GNU Lesser General Public License *) (* as published by the Free Software Foundation; either version 2.1 *) (* of the License, or (at your option) any later version. *) (* *) (* This program is distributed in the hope that it will be useful, *) (* but WITHOUT ANY WARRANTY; without even the implied warranty of *) (* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *) (* GNU General Public License for more details. *) (* *) (* You should have received a copy of the GNU Lesser General Public *) (* License along with this program; if not, write to the Free *) (* Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA *) (* 02110-1301 USA *) Require Export complexes_transformations. Require Export complexes_analytique. Require Export complexes_exercice. Require Export geometrie_plane. HighSchoolGeometry/geometrie_plane.v0000755000076500007650000000236712073525615017570 0ustar coqcoq00000000000000(* This program is free software; you can redistribute it and/or *) (* modify it under the terms of the GNU Lesser General Public License *) (* as published by the Free Software Foundation; either version 2.1 *) (* of the License, or (at your option) any later version. *) (* *) (* This program is distributed in the hope that it will be useful, *) (* but WITHOUT ANY WARRANTY; without even the implied warranty of *) (* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *) (* GNU General Public License for more details. *) (* *) (* You should have received a copy of the GNU Lesser General Public *) (* License along with this program; if not, write to the Free *) (* Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA *) (* 02110-1301 USA *) Require Export composee_dilatations. Require Export composee_transformations. Require Export similitudes_directes. Require Export equations_cercles. Require Export homoth_Euler. Require Export transformations_contact. Require Export inversion. HighSchoolGeometry/geometrie_spaciale.v0000755000076500007650000000204312073525612020236 0ustar coqcoq00000000000000(* This program is free software; you can redistribute it and/or *) (* modify it under the terms of the GNU Lesser General Public License *) (* as published by the Free Software Foundation; either version 2.1 *) (* of the License, or (at your option) any later version. *) (* *) (* This program is distributed in the hope that it will be useful, *) (* but WITHOUT ANY WARRANTY; without even the implied warranty of *) (* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *) (* GNU General Public License for more details. *) (* *) (* You should have received a copy of the GNU Lesser General Public *) (* License along with this program; if not, write to the Free *) (* Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA *) (* 02110-1301 USA *) Require Export exercice_espace. HighSchoolGeometry/homoth_Euler.v0000644000076500007650000003104512073525613017051 0ustar coqcoq00000000000000(* This program is free software; you can redistribute it and/or *) (* modify it under the terms of the GNU Lesser General Public License *) (* as published by the Free Software Foundation; either version 2.1 *) (* of the License, or (at your option) any later version. *) (* *) (* This program is distributed in the hope that it will be useful, *) (* but WITHOUT ANY WARRANTY; without even the implied warranty of *) (* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *) (* GNU General Public License for more details. *) (* *) (* You should have received a copy of the GNU Lesser General Public *) (* License along with this program; if not, write to the Free *) (* Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA *) (* 02110-1301 USA *) Require Export droite_Euler. Require Export applications_cocyclicite. Set Implicit Arguments. Unset Strict Implicit. Lemma homothetique_orthocentre : forall A B C O G H : PO, triangle A B C -> G = centre_gravite A B C -> circonscrit O A B C -> H = orthocentre A B C -> O = homothetie (- / 2) G H. intros. apply vecteur_homothetie. cut (vec O H = mult_PP 3 (vec O G)); intros. 2: apply droite_Euler_fort with (1 := H0); auto. replace (vec G H) with (add_PP (mult_PP (-1) (vec O G)) (vec O H)); [ idtac | Ringvec ]. rewrite H4. cut (2 <> 0); intros; auto with real. replace (mult_PP (- / 2) (add_PP (mult_PP (-1) (vec O G)) (mult_PP 3 (vec O G)))) with (mult_PP (/ 2) (mult_PP 2 (vec G O))); [ idtac | Ringvec ]. replace (mult_PP (/ 2) (mult_PP 2 (vec G O))) with (mult_PP (/ 2 * 2) (vec G O)); [ idtac | Ringvec ]. replace (/ 2 * 2) with 1; auto with real. Ringvec. Qed. Lemma homothetique_centre_circonscrit : forall A B C O G H I : PO, triangle A B C -> G = centre_gravite A B C -> circonscrit O A B C -> H = orthocentre A B C -> I = milieu O H -> I = homothetie (- / 2) G O. intros. apply vecteur_homothetie. cut (vec O H = mult_PP 3 (vec O G)); intros. 2: apply droite_Euler_fort with (1 := H0); auto. cut (2 <> 0); intros; auto with real. apply mult_PP_regulier with 2; auto. replace (mult_PP 2 (vec G I)) with (add_PP (vec G O) (vec G H)). replace (vec G H) with (add_PP (vec G O) (vec O H)); [ idtac | Ringvec ]. rewrite H5. replace (mult_PP 2 (mult_PP (- / 2) (vec G O))) with (mult_PP (2 * / 2) (vec O G)); [ idtac | Ringvec ]. replace (2 * / 2) with 1; auto with real. Ringvec. rewrite (prop_vecteur_milieu (B:=O) (C:=H) (A':=I) G); auto. Qed. Lemma centre_circonscrit_triangle_homothetique : forall A B C A' B' C' O G H I : PO, triangle A B C -> A' = milieu B C -> B' = milieu A C -> C' = milieu A B -> G = centre_gravite A B C -> circonscrit O A B C -> H = orthocentre A B C -> I = milieu O H -> circonscrit I A' B' C'. intros. generalize H5; unfold circonscrit, isocele in |- *; intros. elim H8; intros H9 H10; try clear H8; try exact H10. split; apply carre_scalaire_egalite_distance. rewrite (homothetie_bipoint (k:=- / 2) (I:=G) (A:=O) (B:=A) (A':=I) (B':=A')); auto. Simplscal. rewrite (homothetie_bipoint (k:=- / 2) (I:=G) (A:=O) (B:=B) (A':=I) (B':=B')); auto. Simplscal. repeat rewrite carre_scalaire_distance. rewrite H9; ring. apply (homothetique_centre_circonscrit (A:=A) (B:=B) (C:=C) (O:=O) (G:=G) (H:=H) (I:=I)); auto. apply centre_gravite_homothetie with (1 := H2); auto. rewrite H4. rewrite centre_gravite_ordre_permute. rewrite centre_gravite_ordre_cycle2; auto. apply (homothetique_centre_circonscrit (A:=A) (B:=B) (C:=C) (O:=O) (G:=G) (H:=H) (I:=I)); auto. apply centre_gravite_homothetie with (1 := H1); auto. rewrite (homothetie_bipoint (k:=- / 2) (I:=G) (A:=O) (B:=A) (A':=I) (B':=A')); auto. Simplscal. rewrite (homothetie_bipoint (k:=- / 2) (I:=G) (A:=O) (B:=C) (A':=I) (B':=C')); auto. Simplscal. repeat rewrite carre_scalaire_distance. rewrite H10; ring. apply (homothetique_centre_circonscrit (A:=A) (B:=B) (C:=C) (O:=O) (G:=G) (H:=H) (I:=I)); auto. apply centre_gravite_homothetie with (1 := H3); auto. rewrite H4. rewrite centre_gravite_ordre_cycle2; auto. apply (homothetique_centre_circonscrit (A:=A) (B:=B) (C:=C) (O:=O) (G:=G) (H:=H) (I:=I)); auto. apply centre_gravite_homothetie with (1 := H1); auto. Qed. Comments Image "file://C:/Documents and Settings/Frédérique Guilhot/.pcoq/figures/f1043165035.gif". Lemma symetrique_milieu_cercle : forall A B C A' B' C' O G H I J : PO, triangle A B C -> A' = milieu B C -> B' = milieu A C -> C' = milieu A B -> G = centre_gravite A B C -> circonscrit O A B C -> H = orthocentre A B C -> I = milieu O H -> J = symetrie I A' -> sont_cocycliques A' B' C' J. unfold symetrie in |- *; intros. unfold sont_cocycliques, circonscrit, isocele in |- *. exists I. cut (circonscrit I A' B' C'); intros. 2: apply (centre_circonscrit_triangle_homothetique (A:=A) (B:=B) (C:=C) (A':=A') (B':=B') (C':=C') (O:=O) (G:=G) (H:=H) (I:=I)); auto. generalize H9; unfold circonscrit, isocele in |- *; intros. split; [ try assumption | idtac ]. elim H10; intros H11 H12; try clear H10; try exact H11. split; [ try assumption | idtac ]. apply carre_scalaire_egalite_distance. rewrite (homothetie_vecteur (k:=-1) (I:=I) (A:=A') (A':=J)); auto. Simplscal. Qed. Lemma symetrique_milieu_milieu : forall A B C A' B' C' O G H I J : PO, triangle A B C -> A' = milieu B C -> B' = milieu A C -> C' = milieu A B -> G = centre_gravite A B C -> circonscrit O A B C -> H = orthocentre A B C -> I = milieu O H -> J = milieu A H -> J = symetrie I A'. unfold symetrie in |- *; intros. Comments Image "file://C:/Documents and Settings/Frédérique Guilhot/.pcoq/figures/f1043312519.gif". elim existence_homothetique with (k := -1) (I := I) (A := A'); intros L H13. rewrite <- H13. apply vecteur_nul_conf. Comments Image "file://C:/Documents and Settings/Frédérique Guilhot/.pcoq/figures/f1043312668.gif". cut (vec H L = vec H J); intros. replace (vec J L) with (add_PP (vec H L) (mult_PP (-1) (vec H J))); [ idtac | Ringvec ]. rewrite <- H9; Ringvec. rewrite (homothetie_bipoint (k:=-1) (I:=I) (A:=O) (B:=A') (A':=H) (B':=L)); auto with geo. rewrite (homothetie_bipoint (k:=- / 2) (I:=G) (A:=H) (B:=A) (A':=O) (B':=A')); auto. cut (2 <> 0); intros; auto with real. replace (mult_PP (-1) (mult_PP (- / 2) (vec H A))) with (mult_PP (-1 * - / 2) (vec H A)); [ idtac | Ringvec ]. replace (-1 * - / 2) with (/ 2); [ idtac | ring ]. rewrite (milieu_vecteur2 (A:=H) (B:=A) (M:=J)); auto with geo. apply (homothetique_orthocentre (A:=A) (B:=B) (C:=C) (O:=O) (G:=G) (H:=H)); auto. apply centre_gravite_homothetie with (1 := H1); auto. Qed. Lemma milieu_sommet_orthocentre_cercle : forall A B C A' B' C' O G H I J : PO, triangle A B C -> A' = milieu B C -> B' = milieu A C -> C' = milieu A B -> G = centre_gravite A B C -> circonscrit O A B C -> H = orthocentre A B C -> I = milieu O H -> J = milieu A H -> sont_cocycliques A' B' C' J. intros. apply (symetrique_milieu_cercle (A:=A) (B:=B) (C:=C) (A':=A') (B':=B') (C':=C') (O:=O) (G:=G) (H:=H) (I:=I) (J:=J)); auto. apply (symetrique_milieu_milieu (A:=A) (B:=B) (C:=C) (A':=A') (B':=B') (C':=C') (O:=O) (G:=G) (H:=H) (I:=I) (J:=J)); auto. Qed. Lemma pied_hauteur_cercle : forall A B C A' B' C' O G H I J HA : PO, triangle A B C -> A' = milieu B C -> B' = milieu A C -> C' = milieu A B -> G = centre_gravite A B C -> circonscrit O A B C -> H = orthocentre A B C -> I = milieu O H -> J = milieu A H -> HA = projete_orthogonal B C A -> sont_cocycliques A' B' C' HA. intros. generalize (orthogonal_diametre_cercle (A:=A') (B:=B') (C:=C') (A':=J) (O:=I)); intros H14; apply H14. apply triangle_triangle_milieux with (1 := H0); auto with geo. generalize (centre_circonscrit_triangle_homothetique (A:=A) (B:=B) (C:=C) (A':=A') (B':=B') (C':=C') (O:=O) (G:=G) (H:=H)); intros H19; apply H19; auto. apply symetrie_milieu. generalize (symetrique_milieu_milieu (A:=A) (B:=B) (C:=C) (A':=A') (B':=B') (C':=C') (O:=O) (G:=G) (H:=H)); intros H19; apply H19; auto. deroule_triangle A B C. elim def_projete_orthogonal2 with (A := B) (B := C) (C := A) (H := HA); [ intros | auto | auto ]. halignes H15 ipattern:k. cut (alignes B C A'); intros; auto with geo. halignes H18 ipattern:k0. cut (orthogonal (vec B C) (vec HA J)); intros. replace (vec HA A') with (add_PP (vec B A') (mult_PP (-1) (vec B HA))); [ idtac | Ringvec ]. rewrite H19; rewrite H17. replace (mult_PP (-1) (mult_PP k (vec B C))) with (mult_PP (- k) (vec B C)); [ idtac | Ringvec ]. Simplortho. apply ortho_sym. cut (alignes A H J); intros; auto with geo. cut (alignes A HA H); intros. halignes H20 ipattern:x. assert (J = A). rewrite H8; rewrite <- H20; auto with geo. rewrite H22; auto with geo. halignes H21 ipattern:y. absurd (A = HA); auto. red in |- *; intros; apply H10. rewrite H21; auto with geo. replace (vec HA J) with (add_PP (vec HA A) (vec A J)); [ idtac | Ringvec ]. rewrite H22; rewrite H23. replace (add_PP (vec HA A) (mult_PP x (mult_PP y (vec A HA)))) with (mult_PP (1 + - (x * y)) (vec HA A)); [ idtac | Ringvec ]. Simplortho. elim orthocentre_def2 with (A := A) (B := B) (C := C) (H := H); [ intros; elim H21; intros H23 H24; try clear H21 orthocentre_def2; try exact H24 | auto ]. discrimine H A. elim orthogonal_colineaires with (A := B) (B := C) (C := H) (D := A) (E := HA) (F := A); [ intros k1 H26; try clear orthogonal_colineaires | auto with geo | auto with geo | auto with geo | auto with geo ]. cut (alignes A H HA); intros. apply alignes_ordre_permute; try trivial. apply colineaire_alignes with k1. replace (vec A HA) with (mult_PP (-1) (vec HA A)); [ idtac | Ringvec ]. rewrite H26; Ringvec. Qed. Hint Resolve orthocentre_ordre: geo. Theorem cercle_neuf_points : forall A B C A' B' C' O G H I J K L H1 H2 H3 : PO, triangle A B C -> A' = milieu B C -> B' = milieu A C -> C' = milieu A B -> G = centre_gravite A B C -> circonscrit O A B C -> H = orthocentre A B C -> I = milieu O H -> J = milieu A H -> K = milieu B H -> L = milieu C H -> H1 = projete_orthogonal B C A -> H2 = projete_orthogonal C A B -> H3 = projete_orthogonal A B C -> (sont_cocycliques A' B' C' J /\ sont_cocycliques A' B' C' H1) /\ (sont_cocycliques A' B' C' K /\ sont_cocycliques A' B' C' H2) /\ sont_cocycliques A' B' C' L /\ sont_cocycliques A' B' C' H3. intros. split; [ try assumption | idtac ]. split; [ try assumption | idtac ]. apply (symetrique_milieu_cercle (A:=A) (B:=B) (C:=C) (A':=A') (B':=B') (C':=C') (O:=O) (G:=G) (H:=H) (I:=I)); auto. apply (symetrique_milieu_milieu (A:=A) (B:=B) (C:=C) (A':=A') (B':=B') (C':=C') (O:=O) (G:=G) (H:=H) (I:=I) (J:=J)); auto. Comments Image "file://C:/Documents and Settings/Frédérique Guilhot/.pcoq/figures/f1043314145.gif". apply (pied_hauteur_cercle (A:=A) (B:=B) (C:=C) (A':=A') (B':=B') (C':=C') (O:=O) (G:=G) (H:=H) (I:=I) (J:=J) (HA:=H1)); auto. split; [ split; [ try assumption | idtac ] | idtac ]. cut (sont_cocycliques B' C' A' K); intros; auto with geo. apply (symetrique_milieu_cercle (A:=B) (B:=C) (C:=A) (A':=B') (B':=C') (C':=A') (O:=O) (G:=G) (H:=H) (I:=I)); auto with geo. rewrite H7; apply centre_gravite_ordre_cycle. apply circonscrit_permute; apply circonscrit_permute; auto with geo. apply (symetrique_milieu_milieu (A:=B) (B:=C) (C:=A) (A':=B') (B':=C') (C':=A') (O:=O) (G:=G) (H:=H) (I:=I) (J:=K)); auto with geo. rewrite H7; apply centre_gravite_ordre_cycle. apply circonscrit_permute; apply circonscrit_permute; auto. cut (sont_cocycliques B' C' A' H2); intros; auto with geo. apply (pied_hauteur_cercle (A:=B) (B:=C) (C:=A) (A':=B') (B':=C') (C':=A') (O:=O) (G:=G) (H:=H) (I:=I) (J:=K) (HA:=H2)); auto with geo. rewrite H7; apply centre_gravite_ordre_cycle. apply circonscrit_permute; apply circonscrit_permute; auto. split; [ try assumption | idtac ]. cut (sont_cocycliques C' A' B' L); intros. apply cocycliques_ordre_cycle2; auto. apply (symetrique_milieu_cercle (A:=C) (B:=A) (C:=B) (A':=C') (B':=A') (C':=B') (O:=O) (G:=G) (H:=H) (I:=I) (J:=L)); auto with geo. rewrite H7; apply centre_gravite_ordre_cycle2. apply circonscrit_permute; auto. apply (symetrique_milieu_milieu (A:=C) (B:=A) (C:=B) (A':=C') (B':=A') (C':=B') (O:=O) (G:=G) (H:=H) (I:=I) (J:=L)); auto with geo. rewrite H7; apply centre_gravite_ordre_cycle2. apply circonscrit_permute; auto. cut (sont_cocycliques C' A' B' H3); intros. apply cocycliques_ordre_cycle2; auto with geo. apply (pied_hauteur_cercle (A:=C) (B:=A) (C:=B) (A':=C') (B':=A') (C':=B') (O:=O) (G:=G) (H:=H) (I:=I) (J:=L) (HA:=H3)); auto with geo. rewrite H7; apply centre_gravite_ordre_cycle2. apply circonscrit_permute; auto. Qed.HighSchoolGeometry/homothetie_plane.v0000644000076500007650000002105612073525612017743 0ustar coqcoq00000000000000(* This program is free software; you can redistribute it and/or *) (* modify it under the terms of the GNU Lesser General Public License *) (* as published by the Free Software Foundation; either version 2.1 *) (* of the License, or (at your option) any later version. *) (* *) (* This program is distributed in the hope that it will be useful, *) (* but WITHOUT ANY WARRANTY; without even the implied warranty of *) (* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *) (* GNU General Public License for more details. *) (* *) (* You should have received a copy of the GNU Lesser General Public *) (* License along with this program; if not, write to the Free *) (* Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA *) (* 02110-1301 USA *) Require Export dilatations. Require Export affine_classiques. Require Export cercle. Require Export rotation_plane. Set Implicit Arguments. Unset Strict Implicit. Lemma homothetie_conserve_angle : forall (I A B C A' B' C' : PO) (k : R), k <> 0 -> A <> B -> A <> C -> A' = homothetie k I A -> B' = homothetie k I B -> C' = homothetie k I C -> cons_AV (vec A B) (vec A C) = cons_AV (vec A' B') (vec A' C'). intros. cut (vec A' B' = mult_PP k (vec A B)); intros. cut (vec A' C' = mult_PP k (vec A C)); intros. cut (A' <> B'); intros. cut (A' <> C'); intros. rewrite H5. elim Rtotal_order with (r1 := k) (r2 := 0); intros. rewrite angle_produit_negatif_l; auto. rewrite H6. rewrite angle_produit_negatif_r2; auto. rewrite <- plus_associative. rewrite <- add_mes_compatible. replace (pi + pi) with deuxpi; auto. rewrite pi_plus_pi. rewrite plus_angle_zero; auto. elim H9; [ intros H10; try clear H9 | intros H10; try clear H9; try exact H10 ]. absurd (k = 0); auto with real. rewrite angle_produit_positif_l; auto. rewrite H6. rewrite angle_produit_positif_r2; auto. apply image_homothetie_distincts with (3 := H2) (4 := H4); auto. apply image_homothetie_distincts with (3 := H2) (4 := H3); auto. apply homothetie_bipoint with I; auto. apply homothetie_bipoint with I; auto. Qed. Lemma distance_homothetie : forall (k : R) (I A A' B B' : PO), A' = homothetie k I A :>PO -> B' = homothetie k I B :>PO -> distance A' B' = Rabs k * distance A B. unfold distance in |- *; intros. rewrite <- sqrt_Rsqr_abs. rewrite <- sqrt_mult; intros. apply Rsqr_inj; auto with real geo. generalize (homothetie_bipoint (k:=k) (I:=I) (A:=A) (B:=B) (A':=A') (B':=B')); intros. replace (Rsqr k * scalaire (vec A B) (vec A B)) with (scalaire (mult_PP k (vec A B)) (mult_PP k (vec A B))). rewrite H1; auto. unfold Rsqr; Simplscal. auto with real. generalize scalaire_positif; intros; auto with real. Qed. Lemma intersection_homothetie : forall (k : R) (I A A' B B' C C' D D' K K' : PO), k <> 0 :>R -> A <> B -> C <> D -> ~ alignes A B C \/ ~ alignes A B D -> K = pt_intersection (droite A B) (droite C D) :>PO -> A' = homothetie k I A :>PO -> B' = homothetie k I B -> C' = homothetie k I C :>PO -> D' = homothetie k I D :>PO -> K' = pt_intersection (droite A' B') (droite C' D') :>PO -> K' = homothetie k I K :>PO. intros. elim existence_homothetique with (k := k) (I := I) (A := K); intros L H13. rewrite <- H13; rewrite H8; symmetry in |- *. apply (homothetie_intersection (k:=k) (I:=I) (A:=A) (A':=A') (B:=B) (B':=B') (C:=C) (C':=C') (D:=D) (D':=D') (K:=K) (K':=L)); auto. Qed. Theorem paralleles_homothetie : forall A B C I J : PO, triangle A B C -> I <> J :>PO -> alignes A B I -> paralleles (droite B C) (droite I J) -> alignes A C J -> exists k : R, I = homothetie k A B :>PO /\ J = homothetie k A C :>PO. intros. deroule_triangle A B C. halignes H1 ipattern:x. cut (triangle B C A); intros; auto with geo. elim (classic (x = 0)); intros. cut (A = I); intros. absurd (paralleles (droite I J) (droite B C)); auto with geo. rewrite (droite_permute (A:=I) (B:=J)); auto. apply concours_non_paralleles; auto. rewrite <- H11; auto. apply def_concours with C; auto with geo. rewrite <- H11; auto. apply alignes_ordre_cycle; auto with geo. apply vecteur_nul_conf. rewrite H8; rewrite H10; Ringvec. exists x; split; apply vecteur_homothetie; auto. generalize (Thales_concours (k:=x) (A:=A) (B:=B) (C:=C) (I:=I)); intros H18; apply H18; auto. Qed. Lemma centre_gravite_homothetie : forall A B C I G : PO, I = milieu B C :>PO -> G = centre_gravite A B C :>PO -> I = homothetie (- / 2) G A :>PO. intros. apply vecteur_homothetie. replace (vec G A) with (mult_PP (-1) (vec A G)). replace (vec G I) with (add_PP (vec A I) (mult_PP (-1) (vec A G))). rewrite (centre_gravite_mediane_vecteur (A:=A) (B:=B) (C:=C) (I:=I) (G:=G)); auto. cut (3 <> 0); intros; auto with real. cut (2 <> 0); intros; auto with real. apply mult_PP_regulier with 2; auto. replace (mult_PP 2 (mult_PP (- / 2) (mult_PP (-1) (mult_PP (/ 3) (mult_PP 2 (vec A I)))))) with (mult_PP (2 * / 2) (mult_PP (/ 3 * 2) (vec A I))). replace (2 * / 2) with 1; auto with real. Fieldvec 3. repeat rewrite mult_mult_vec. replace (2 * / 2 * (/ 3 * 2)) with (2 * (- / 2 * (-1 * (/ 3 * 2)))); auto. field. discrR. Ringvec. Ringvec. Qed. Lemma homothetie_mediatrice_hauteur : forall A B C I G J H : PO, triangle A B C -> I <> J -> I = milieu B C :>PO -> mediatrice B C J -> G = centre_gravite A B C :>PO -> H = homothetie (-2) G J :>PO -> orthogonal (vec A H) (vec B C). intros. deroule_triangle A B C. cut (-2 <> 0); intros. cut (A = homothetie (-2) G I); intros. cut (A <> H); intros. cut (paralleles (droite I J) (droite A H)); intros. apply paralleles_orthogonal with (3 := H13); auto. apply mediatrice_orthogonale_segment; auto. apply milieu_mediatrice; auto. apply paralleles_sym; auto. apply homothetie_droite with (3 := H11) (4 := H5); auto. apply image_homothetie_distincts with (3 := H11) (4 := H5); auto. replace (-2) with (/ - / 2). apply homothetie_inverse; auto with real. apply centre_gravite_homothetie with (2 := H4); auto. rewrite Ropp_inv_permute; auto with real. discrR. Qed. Lemma homothetie_cercle : forall (k : R) (I A A' O O' M M' : PO), k <> 0 :>R -> O' = homothetie k I O :>PO -> A' = homothetie k I A :>PO -> M' = homothetie k I M :>PO -> cercle O (distance O A) M -> cercle O' (distance O' A') M'. unfold cercle in |- *; intros. generalize (homothetie_bipoint (k:=k) (I:=I) (A:=O) (B:=M) (A':=O') (B':=M')); intros H5. generalize (homothetie_bipoint (k:=k) (I:=I) (A:=O) (B:=A) (A':=O') (B':=A')); intros. apply carre_scalaire_egalite_distance. rewrite H5; auto. rewrite H4; auto. Simplscal. repeat rewrite carre_scalaire_distance; auto. rewrite H3; ring. Qed. Lemma symetrie_rotation : forall A B I : PO, B = symetrie I A :>PO -> B = rotation I pi A :>PO. intros. generalize symetrie_milieu; intros. discrimine I A. rewrite <- rotation_def_centre. rewrite H; rewrite H1. symmetry in |- *. apply milieu_symetrie; auto with geo. apply rotation_def2; auto with geo. rewrite <- (milieu_vecteur (A:=A) (B:=B) (M:=I)). apply angle_plat; auto. apply H0; auto. Qed. Lemma rotation_symetrie : forall A B I : PO, B = rotation I pi A :>PO -> B = symetrie I A :>PO. intros. apply milieu_symetrie; auto. discrimine I A. rewrite H; rewrite <- H0; rewrite <- rotation_def_centre; auto with geo. elim rotation_def with (I := I) (A := A) (B := B) (a := pi); [ try clear rotation_def; intros | auto | auto ]. cut (A <> B); intros. apply alignes_mediatrice_milieu; auto. cut (alignes I A B); intros; [ auto with geo | idtac ]. apply alignes_angle; auto with geo. apply image_distinct_centre with (2 := H); auto. unfold double_AV in |- *. rewrite <- H2; rewrite <- pi_plus_pi; auto. rewrite <- add_mes_compatible; auto. red in |- *; intros; apply H0. cut (Rsqr (distance A B) = (2 + 2) * Rsqr (distance I A)); intros. apply distance_nulle; auto. rewrite carre_scalaire_distance. replace (distance I A * distance I A) with (/ (2 + 2) * (distance A B * distance A B)). rewrite <- carre_scalaire_distance. apply Rmult_eq_0_compat. right; try assumption. rewrite H3. replace (vec B B) with (mult_PP 0 (vec B B)); [ idtac | Ringvec ]. Simplscal. replace (distance A B * distance A B) with (Rsqr (distance A B)); auto with real. rewrite H4. cut (2 + 2 <> 0); intros. replace (/ (2 + 2) * ((2 + 2) * Rsqr (distance I A))) with (/ (2 + 2) * (2 + 2) * Rsqr (distance I A)); [ idtac | ring ]. replace (/ (2 + 2) * (2 + 2)) with 1; auto with real. discrR. rewrite (Al_Kashi (A:=I) (B:=A) (C:=B) (a:=pi)); auto. rewrite cos_pi; auto. rewrite <- H1. unfold Rsqr; ring. apply image_distinct_centre with (2 := H); auto. Qed. HighSchoolGeometry/inversion.v0000755000076500007650000004704112117747636016453 0ustar coqcoq00000000000000(* This program is free software; you can redistribute it and/or *) (* modify it under the terms of the GNU Lesser General Public License *) (* as published by the Free Software Foundation; either version 2.1 *) (* of the License, or (at your option) any later version. *) (* *) (* This program is distributed in the hope that it will be useful, *) (* but WITHOUT ANY WARRANTY; without even the implied warranty of *) (* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *) (* GNU General Public License for more details. *) (* *) (* You should have received a copy of the GNU Lesser General Public *) (* License along with this program; if not, write to the Free *) (* Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA *) (* 02110-1301 USA *) Require Export puissance_cercle. Set Implicit Arguments. Unset Strict Implicit. Parameter inversion : PO -> R -> PO -> PO. Axiom inversion_def : forall (I A B : PO) (k : R), k <> 0 -> I <> A -> B = inversion I k A -> alignes I A B /\ scalaire (vec I A) (vec I B) = k. Axiom inversion_def2 : forall (I A B : PO) (k : R), k <> 0 -> I <> A -> alignes I A B -> scalaire (vec I A) (vec I B) = k -> B = inversion I k A. Lemma definition_inversion : forall (I A B : PO) (k : R), k <> 0 -> I <> A -> (B = inversion I k A <-> alignes I A B /\ scalaire (vec I A) (vec I B) = k). intros; red in |- *; try split; intros. apply inversion_def; auto. apply inversion_def2; tauto. Qed. Lemma image_distinct_pole : forall (I A B : PO) (k : R), k <> 0 -> I <> A -> B = inversion I k A -> I <> B. intros. elim (inversion_def (I:=I) (A:=A) (B:=B) (k:=k)); intros; auto. red in |- *; intros; apply H. rewrite <- H3; rewrite <- H4; Simplscal. VReplace (vec I I) (mult_PP 0 (vec I A)). Simplscal. Qed. Ltac deroule_inversion I A B k := elim (inversion_def (I:=I) (A:=A) (B:=B) (k:=k)); intros; auto; assert (I <> B); [ apply (image_distinct_pole (I:=I) (A:=A) (B:=B) (k:=k)); auto | idtac ]. Lemma inversion_involution : forall (I A B : PO) (k : R), k <> 0 -> I <> A -> B = inversion I k A -> A = inversion I k B. intros. deroule_inversion I A B k. apply inversion_def2; auto. auto with geo. rewrite <- H3; auto with geo. apply scalaire_sym. Qed. Hint Immediate inversion_involution: geo. Lemma inversion_droite_pole : forall (A A' M M' I : PO) (k : R), k <> 0 -> I <> A -> I <> M -> alignes I A M -> A' = inversion I k A -> M' = inversion I k M -> alignes I A A' /\ alignes I A' M'. intros. deroule_inversion I M M' k. deroule_inversion I A A' k. assert (A = inversion I k A'); auto with geo. deroule_inversion I A' A k. split; [ try assumption | idtac ]. halignes H12 ipattern:a. halignes H5 ipattern:b. halignes H2 ipattern:c. apply colineaire_alignes with (a * (b * c)). rewrite H16; rewrite H17; rewrite H15. Ringvec. Qed. Lemma inversion_homothetie : forall (I A B : PO) (k : R), k <> 0 -> I <> A -> B = inversion I k A -> B = homothetie (/ Rsqr (distance I A) * k) I A. intros. deroule_inversion I A B k. apply vecteur_homothetie. halignes H2 ipattern:k0. assert (k0 = / Rsqr (distance I A) * k). apply Rmult_eq_reg_l with (scalaire (vec I A) (vec I A)); auto with geo. replace (scalaire (vec I A) (vec I A) * k0) with (scalaire (vec I A) (vec I B)). unfold Rsqr in |- *; rewrite <- carre_scalaire_distance. rewrite <- H3. field; auto with geo. rewrite H5; Simplscal. rewrite H5; rewrite H6; auto. Qed. Lemma homothetie_inversion : forall (I A B : PO) (k : R), k <> 0 -> I <> A -> B = homothetie (/ Rsqr (distance I A) * k) I A -> B = inversion I k A. intros. generalize (homothetie_vecteur H1); intros. apply inversion_def2; auto. apply colineaire_alignes with (/ Rsqr (distance I A) * k); auto. rewrite H2; Simplscal. unfold Rsqr in |- *; rewrite <- carre_scalaire_distance. field; auto with geo. Qed. Lemma inversion_est_homothetie : forall (I A B : PO) (k : R), k <> 0 -> I <> A -> (B = inversion I k A <-> B = homothetie (/ Rsqr (distance I A) * k) I A). intros; red in |- *; try split; intros. apply inversion_homothetie; auto. apply homothetie_inversion; auto. Qed. Lemma inversion_pole_vecteur : forall (k : R) (O M M' : PO), k <> 0 -> O <> M -> M' = inversion O k M :>PO -> vec O M' = mult_PP (/ Rsqr (distance O M) * k) (vec O M) :>PP. intros. apply homothetie_vecteur. apply inversion_homothetie; auto. Qed. Lemma existence_inversion : forall (I A : PO) (k : R), k <> 0 -> I <> A -> exists A' : PO, A' = inversion I k A. intros. elim existence_homothetique with (k := / Rsqr (distance I A) * k) (I := I) (A := A); [ intros A' H1; try clear existence_homothetique; try exact H1 ]. exists A'. apply homothetie_inversion; auto. Qed. Lemma inversion_oppose_puissance : forall (I A B C : PO) (k : R), k <> 0 -> I <> A -> B = inversion I k A -> C = symetrie I A -> B = inversion I (- k) C. intros. generalize H2; unfold symetrie in |- *; intros. assert (I <> C). assert (I = homothetie (-1) I I); auto with geo. apply (image_homothetie_distincts (k:=-1) (I:=I) (A:=I) (A':=I) (B:=A) (B':=C)); auto with real. generalize (inversion_homothetie (I:=I) (A:=A) (B:=B) (k:=k)); intros. apply homothetie_inversion; auto with real. generalize (homothetie_vecteur (k:=/ Rsqr (distance I A) * k) (I:=I) (A:=A) (A':=B)); intros. apply vecteur_homothetie. rewrite (homothetie_vecteur (k:=/ Rsqr (distance I A) * k) (I:=I) (A:=A) (A':=B)) ; auto. assert (I = milieu A C); auto with geo. replace (distance I A) with (distance I C); auto with geo. rewrite (homothetie_vecteur H3). assert (Rsqr (distance I C) <> 0). assert (distance I C <> 0); auto with geo. unfold Rsqr in |- *; auto with real. Ringvec. Qed. Theorem inversion_cocyclicite : forall (A B C D I : PO) (k : R), k <> 0 -> I <> A -> I <> C -> C <> D -> triangle A B C -> B = inversion I k A -> D = inversion I k C -> sont_cocycliques A B C D. intros. deroule_inversion I A B k. deroule_inversion I C D k. apply egalite_puissance_cocycliques with I; auto. deroule_triangle A B C. apply alignes_ordre_cycle; auto. apply alignes_ordre_cycle; auto. rewrite H10; auto. Qed. Definition droite_perpendiculaire (A B C D : PO) := orthogonal (vec C D) (vec A B). Theorem inversion_cercle_diametre_pole : forall (A M A' M' I : PO) (k : R), k <> 0 -> triangle I A M -> A' = inversion I k A -> M' = inversion I k M -> cercle_diametre I A M -> droite_perpendiculaire I A A' M'. unfold droite_perpendiculaire in |- *; intros A M A' M' I k H H0 H2 H3 H1. generalize H1; unfold cercle_diametre in |- *; intros. elim H4; [ intros O H5; elim H5; [ intros H6 H7; try clear H5 H4; try exact H7 ] ]. assert (orthogonal (vec M I) (vec M A)). apply triangle_diametre with O; auto with geo. hcercle H6. rewrite <- H8; auto. deroule_triangle I A M. deroule_inversion I A A' k. deroule_inversion I M M' k. elim existence_projete_orthogonal with (A := I) (B := A) (C := M'); [ intros H' H17; try clear existence_projete_orthogonal; try exact H16 | auto ]. elim def_projete_orthogonal2 with (A := I) (B := A) (C := M') (H := H'); [ intros; try clear def_projete_orthogonal2; try exact H17 | auto | auto ]. halignes H14 ipattern:x. halignes H18 ipattern:y. assert (scalaire (vec I M') (vec I A) = scalaire (vec I M') (vec I M)). apply (scalaire_avec_projete (A:=I) (B:=M') (C:=A) (H:=M)); auto with geo. rewrite H20; Simplortho. assert (scalaire (vec I A) (vec I M') = scalaire (vec I A) (vec I H')). apply (scalaire_avec_projete (A:=I) (B:=A) (C:=M') (H:=H')); auto with geo. assert (scalaire (vec I A) (vec I A') = scalaire (vec I A) (vec I H')). rewrite H12; rewrite <- H15. rewrite scalaire_sym; rewrite <- H22. rewrite scalaire_sym; rewrite H23; auto. assert (A' = H'). apply egalite_scalaire_alignes with (4 := H24); auto with geo. rewrite H25; auto with geo. Qed. Ltac image_inversion I A B k := elim (existence_inversion (I:=I) (A:=A) (k:=k)); intros B; intros; auto; deroule_inversion I A B k. Hint Resolve inversion_involution: geo. Require Export applications_cocyclicite. Theorem inversion_droite_non_pole : forall (A B M M' I : PO) (k : R), k <> 0 -> triangle A B I -> I <> M -> alignes A B M -> M' = inversion I k M -> exists C : PO, orthogonal (vec A B) (vec I C) /\ cercle_diametre I C M'. intros. deroule_triangle A B I. soit_projete A B I ipattern:K. assert (I <> K). red in |- *; intros; apply H4. rewrite H11; auto. image_inversion I K ipattern:K' k. exists K'. unfold cercle_diametre in |- *. soit_milieu I K' ipattern:D. deroule_inversion I M M' k. soit_projete I M K' ipattern:L. halignes H2 ipattern:x. halignes H9 ipattern:y. assert (vec K M = mult_PP (x + - y) (vec A B)). VReplace (vec K M) (add_PP (vec A M) (mult_PP (-1) (vec A K))). rewrite H26; rewrite H25; Ringvec. halignes H13 ipattern:z. assert (orthogonal (vec I K') (vec A B)). rewrite H28; Simplortho. split; [ auto with geo | idtac ]. exists D; (split; auto). assert (scalaire (vec I M) (vec I K') = scalaire (vec I M) (vec I L)). apply (scalaire_avec_projete (A:=I) (B:=M) (C:=K') (H:=L)); auto with geo. assert (scalaire (vec I K') (vec I M) = scalaire (vec I K') (vec I K)). apply (scalaire_avec_projete (A:=I) (B:=K') (C:=M) (H:=K)); auto with geo. apply ortho_sym. rewrite H27; Simplortho. assert (scalaire (vec I M) (vec I L) = scalaire (vec I M) (vec I M')). rewrite <- H30; rewrite scalaire_sym; rewrite H31; rewrite scalaire_sym; rewrite H14; auto. assert (L = M'). apply egalite_scalaire_alignes with (4 := H32); auto. rewrite <- H33; auto with geo. discrimine L K'. icercle. assert (orthogonal (vec L I) (vec L K')). halignes H23 ipattern:t. VReplace (vec L I) (mult_PP (-1) (vec I L)). rewrite H35. VReplace (mult_PP (-1) (mult_PP t (vec I M))) (mult_PP (- t) (vec I M)). auto with geo. assert (triangle L I K'). unfold triangle in |- *. apply orthogonal_non_alignes; auto. rewrite H33; auto. elim existence_cercle_circonscrit with (A := I) (B := K') (C := L); [ intros O H37 | auto with geo ]. cut (O = D); intros. rewrite <- H38; auto. apply (centre_circonscrit_rectangle_milieu (A:=I) (B:=K') (C:=L) (C':=D) (O:=O)); auto with geo. Qed. Lemma cercle_inversion_homothetie : forall (A A' B B' I A1 B1 : PO) (k : R), k <> 0 -> triangle A B I -> B <> B' -> I <> A' -> triangle A A' B -> sont_cocycliques A A' B B' -> alignes A A' I -> alignes B B' I -> A1 = inversion I k A -> B1 = inversion I k B -> A1 = homothetie (k * / scalaire (vec I A) (vec I A')) I A' /\ B1 = homothetie (k * / scalaire (vec I A) (vec I A')) I B'. intros. assert (scalaire (vec I A) (vec I A') = scalaire (vec I B) (vec I B')). apply puissance_cercle; auto. deroule_triangle A B I. deroule_triangle A A' B. assert (alignes I A A'); auto with geo. assert (alignes I B B'); auto with geo. halignes H18 ipattern:x. absurd (I = A); auto. halignes H19 ipattern:y. absurd (I = B); auto. assert (distance I A <> 0); auto with geo real. assert (distance I A * distance I A <> 0). unfold Rsqr in |- *; auto with real. assert (scalaire (vec I A) (vec I A') <> 0). red in |- *; intros; apply H2. apply (produit_zero_conf H20). apply Rmult_eq_reg_l with (scalaire (vec I A) (vec I A)). RReplace (scalaire (vec I A) (vec I A) * 0) 0. rewrite <- H24. rewrite H20; Simplscal. rewrite carre_scalaire_distance; auto. assert (x <> 0). contrapose H24. rewrite H20; rewrite H25; Simplscal. split; [ try assumption | idtac ]. apply vecteur_homothetie. rewrite (inversion_pole_vecteur (k:=k) (O:=I) (M:=A) (M':=A1)); auto. rewrite H20; Simplscal. rewrite carre_scalaire_distance. unfold Rsqr in |- *. RReplace (/ (x * (distance I A * distance I A))) (/ x * / (distance I A * distance I A)). VReplace (mult_PP (k * (/ x * / (distance I A * distance I A))) (mult_PP x (vec I A))) (mult_PP (k * (/ (distance I A * distance I A) * (/ x * x))) (vec I A)). replace (/ (distance I A * distance I A) * k) with (k * (/ (distance I A * distance I A) * (/x * x))); auto. field; auto. field; auto. apply vecteur_homothetie. rewrite (inversion_pole_vecteur (k:=k) (O:=I) (M:=B) (M':=B1)); auto. rewrite H9. rewrite H21; Simplscal. rewrite carre_scalaire_distance. unfold Rsqr in |- *. assert (distance I B <> 0); auto with geo real. assert (distance I B * distance I B <> 0). unfold Rsqr in |- *; auto with real. assert (scalaire (vec I B) (vec I B') <> 0). rewrite <- H9; auto. assert (y <> 0). contrapose H26. rewrite H21; rewrite H29; Simplscal. RReplace (/ (y * (distance I B * distance I B))) (/ y * / (distance I B * distance I B)). VReplace (mult_PP (k * (/ y * / (distance I B * distance I B))) (mult_PP y (vec I B))) (mult_PP (k * (/ (distance I B * distance I B) * (/ y * y))) (vec I B)). replace (/ (distance I B * distance I B) * k) with (k * (/ (distance I B * distance I B) * (/ y * y))); auto. field;auto. field;auto. Qed. Lemma cercle_tangente_inversion_homothetie : forall (A A' B M I M' O : PO) (k : R), k <> 0 -> A <> B -> I <> A -> I <> M -> cercle_diametre A B M -> O = milieu A B -> orthogonal (vec M O) (vec M I) -> alignes A B I -> A' = inversion I k A -> M' = inversion I k M -> A' = homothetie (k * / scalaire (vec I A) (vec I B)) I B /\ M' = homothetie (k * / scalaire (vec I A) (vec I B)) I M. intros. assert (scalaire (vec I A) (vec I B) = Rsqr (distance I O) + - Rsqr (distance O A)). apply scalaire_diametre with B; auto with geo. elim (Pythagore M I O); intros. assert (scalaire (vec I A) (vec I B) = Rsqr (distance I M)). rewrite H9. rewrite H10; auto with geo. rewrite (distance_sym M O). replace (Rsqr (distance O M)) with (Rsqr (distance O A)). rewrite distance_sym; ring. hcercle H3. elim H12; [ intros O0 H13; elim H13; [ intros H14 H15; elim H14; [ intros H16 H17; try clear H14 H13 H12; try exact H17 ] ] ]. assert (O0 = O). rewrite H4; auto. rewrite <- H12; rewrite H17; auto. assert (alignes I A B); auto with geo. halignes H13 ipattern:x. assert (distance I A <> 0); auto with geo real. assert (distance I A * distance I A <> 0). unfold Rsqr in |- *; auto with real. assert (distance I M <> 0); auto with geo real. assert (distance I M * distance I M <> 0). unfold Rsqr in |- *; auto with real. assert (scalaire (vec I A) (vec I B) <> 0). rewrite H12. unfold Rsqr in |- *; auto. assert (x <> 0). contrapose H18. rewrite H14; rewrite H20; Simplscal. split; [ try assumption | idtac ]. apply vecteur_homothetie. rewrite (inversion_pole_vecteur (k:=k) (O:=I) (M:=A) (M':=A')); auto. rewrite H14; Simplscal. rewrite carre_scalaire_distance. unfold Rsqr in |- *. RReplace (/ (x * (distance I A * distance I A))) (/ x * / (distance I A * distance I A)). VReplace (mult_PP (k * (/ x * / (distance I A * distance I A))) (mult_PP x (vec I A))) (mult_PP (k * (/ (distance I A * distance I A) * (/ x * x))) (vec I A)). RReplace (/ x * x) 1. RReplace (/ (distance I A * distance I A) * k) (k * (/ (distance I A * distance I A) * 1)); auto. rewrite <- Rinv_mult_distr; auto. RReplace (distance I A * distance I A * x) (x * (distance I A * distance I A)); auto. apply vecteur_homothetie. rewrite (inversion_pole_vecteur (k:=k) (O:=I) (M:=M) (M':=M')); auto. rewrite H12. unfold Rsqr in |- *. Ringvec. Qed. Theorem inversion_cercle_non_pole : forall (A B M A' B' M' I : PO) (k : R), k <> 0 -> A <> B -> ~ cercle_diametre A B I -> alignes A B I -> A' = inversion I k A -> B' = inversion I k B -> M' = inversion I k M -> cercle_diametre A B M -> cercle_diametre A' B' M'. intros A B M A' B' M' I k H H50 H0 H1 H2 H3 H4 H5; try assumption. assert (I <> A). red in |- *; intros; apply H0. rewrite H6; auto with geo. assert (I <> B). red in |- *; intros; apply H0. rewrite H7; auto with geo. assert (I <> M). red in |- *; intros; apply H0. rewrite H8; auto with geo. elim (classic (alignes A B M)); intros. assert (M = A \/ M = B). apply alignes_diametre; auto. elim H10; [ intros H11; try clear H10 | intros H11; try clear H10; try exact H11 ]. rewrite H4; rewrite H11; rewrite <- H2; auto with geo. rewrite H4; rewrite H11; rewrite <- H3; auto with geo. generalize H5. unfold cercle_diametre, circonscrit, isocele in H5; intros. elim H5; [ intros O H11; elim H11; [ intros H12 H13; elim H12; [ intros H14 H15; try clear H12 H11 H5; try exact H15 ] ] ]. soit_projete M I O ipattern:K. assert (scalaire (vec I A) (vec I B) <> 0); [ idtac | auto with real ]. assert (alignes I A B); auto with geo. halignes H16 ipattern:x. rewrite H17. Simplscal. apply integre_not; auto with geo. apply (distinct_col_nonzero (A:=I) (B:=B) (C:=I) (D:=A)); auto. discrimine M K. 2: assert (distance O K < distance O M). rewrite <- H17 in H12. elim cercle_tangente_inversion_homothetie with (A := A) (A' := A') (B := B) (M := M) (I := I) (M' := M') (O := O) (k := k); [ intros | auto | auto | auto | auto | auto with geo | auto | auto with geo | auto | auto | auto ]. elim cercle_tangente_inversion_homothetie with (A := B) (A' := B') (B := A) (M := M) (I := I) (M' := M') (O := O) (k := k); (intros; auto with geo). apply (homothetie_cercle_diametre (k:=k * / scalaire (vec I A) (vec I B)) (I:=I) (A:=B) (A':=A') (B:=A) (B':=B') (M:=M) (M':=M')); auto with geo. apply integre_not; auto with real. rewrite scalaire_sym; auto. apply projete_distance_Rlt with I; auto. apply def_projete_orthogonal; auto with geo. elim intersection2_cercle_droite with (A := M) (B := I) (O := O) (H := K); [ intros C H19; elim H19; [ intros H21 H20; elim H20; [ intros; try clear H20 H19 ] ] | auto | auto | auto | auto ]. assert (triangle A B M). unfold triangle in |- *; auto. halignes H1 ipattern:y. assert (triangle A M I); unfold triangle in |- *. red in |- *; intros; apply H9. assert (alignes A I M); auto with geo. halignes H25 ipattern:x. absurd (A = I); auto. apply colineaire_alignes with (x * y). rewrite H26; rewrite H20; Ringvec. assert (sont_cocycliques A B M C). hcercle H23. hcercle H10. elim H26; [ intros O0 H28; elim H28; [ intros H29 H30; elim H29; [ intros H31 H32; try clear H29 H28 H27; try exact H32 ] ] ]. exists O; split; try split; auto with geo. assert (O0 = O). rewrite H30; auto. rewrite H15; rewrite H25; auto. assert (alignes M C I). apply alignes_ordre_permute; auto. elim cercle_inversion_homothetie with (A := A) (A' := B) (B := M) (B' := C) (I := I) (A1 := A') (B1 := M') (k := k); [ intros | auto | auto | auto | auto | auto | auto | auto | auto | auto | auto ]. elim cercle_inversion_homothetie with (A := B) (A' := A) (B := M) (B' := C) (I := I) (A1 := B') (B1 := M') (k := k); [ intros | auto | auto | auto | auto | auto | auto | auto | auto | auto | auto ]. apply (homothetie_cercle_diametre (k:=k * / scalaire (vec I B) (vec I A)) (I:=I) (A:=B) (A':=A') (B:=A) (B':=B') (M:=C) (M':=M')); auto. rewrite scalaire_sym; apply integre_not; auto with real. rewrite scalaire_sym; auto. hcercle H23. hcercle H10. elim H32; [ intros O0 H33; elim H33; [ intros H34 H35; elim H34; [ intros H36 H37; try clear H34 H33 H32; try exact H37 ] ] ]. exists O; split; try split; auto with geo. assert (O0 = O). rewrite H35; auto. rewrite <- H14; rewrite <- H31; rewrite <- H32; auto. unfold triangle in |- *. red in |- *; intros; apply H9. assert (alignes I B M); auto with geo. halignes H30 ipattern:x. apply colineaire_alignes with (x * (1 + - y) + y). VReplace (vec A M) (add_PP (vec A I) (vec I M)). rewrite H31. VReplace (vec I B) (add_PP (vec A B) (mult_PP (-1) (vec A I))). rewrite H20; Ringvec. auto with geo. auto with geo. auto with geo. auto with geo. elim circonscrit_triangle_non_point with (O := O) (A := A) (B := B) (C := M); [ intros H27 H28; elim H28; [ intros H29 H30; try clear H28; try exact H30 ] | auto | auto ]. hcercle H10. Qed. HighSchoolGeometry/isocele.v0000644000076500007650000001630712073525612016045 0ustar coqcoq00000000000000(* This program is free software; you can redistribute it and/or *) (* modify it under the terms of the GNU Lesser General Public License *) (* as published by the Free Software Foundation; either version 2.1 *) (* of the License, or (at your option) any later version. *) (* *) (* This program is distributed in the hope that it will be useful, *) (* but WITHOUT ANY WARRANTY; without even the implied warranty of *) (* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *) (* GNU General Public License for more details. *) (* *) (* You should have received a copy of the GNU Lesser General Public *) (* License along with this program; if not, write to the Free *) (* Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA *) (* 02110-1301 USA *) Require Export mediatrice. Set Implicit Arguments. Unset Strict Implicit. Definition isocele (A B C : PO) : Prop := distance A B = distance A C. Lemma isocele_permute : forall A B C : PO, isocele A B C -> isocele A C B. unfold isocele in |- *; intros; auto. Qed. Hint Immediate isocele_permute: geo. Lemma isocele_mediatrice : forall A B C : PO, isocele A B C -> mediatrice B C A. unfold isocele, mediatrice in |- *; intros; auto. Qed. Lemma mediatrice_isocele : forall A B C : PO, mediatrice B C A -> isocele A B C. unfold isocele, mediatrice in |- *; intros; auto. Qed. Lemma mediane_hauteur_isocele : forall A B C I : PO, I = milieu B C -> orthogonal (vec B C) (vec I A) -> isocele A B C. intros. apply mediatrice_isocele. discrimine B C. unfold mediatrice in |- *; auto with geo. apply orthogonale_segment_milieu_mediatrice with I; auto. Qed. Lemma mediane_isocele_hauteur : forall A B C I : PO, I = milieu B C -> isocele A B C -> orthogonal (vec I A) (vec B C). intros. discrimine B C. VReplace (vec C C) zero. auto with geo. apply mediatrice_orthogonale_segment; auto. apply milieu_mediatrice; auto. Qed. Lemma hauteur_isocele_mediane : forall A B C I : PO, B <> C -> orthogonal (vec B C) (vec I A) -> isocele A B C -> alignes B C I -> I = milieu B C. intros A B C I H0 H1 H2 H3; try assumption. soit_projete B C A ipattern:H. apply mediatrice_projete_milieu with A; auto. rewrite <- H4. apply unicite_projete_orthogonal with (3 := H1); auto. Qed. Lemma isocele_mediane_bissectrice : forall A B C I : PO, A <> I -> B <> C -> I = milieu B C -> isocele A B C -> cons_AV (vec A B) (vec A I) = cons_AV (vec A I) (vec A C). intros. apply mediatrice_milieu_angles; auto. Qed. Lemma isocele_angles_base : forall A B C : PO, A <> B -> A <> C -> B <> C -> isocele A B C -> cons_AV (vec B C) (vec B A) = cons_AV (vec C A) (vec C B). intros A B C H H0 H1; try assumption. soit_milieu B C ipattern:K. elim (classic (A = K)); intros. apply permute_angles; auto. rewrite <- H6 in H5. rewrite <- H6 in H2. rewrite <- (angles_milieu (A:=C) (B:=B) (C:=C) (I:=A)); auto. rewrite <- (angles_milieu2 (A:=B) (B:=B) (C:=C) (I:=A)); auto with geo. cut (orthogonal (vec B C) (vec K A)); intros. cut (cons_AV (vec K B) (vec K A) = cons_AV (vec K A) (vec K C)); intros. cut (cons_AV (vec A B) (vec A K) = cons_AV (vec A K) (vec A C)); intros. rewrite (angles_milieu (A:=A) (B:=B) (C:=C) (I:=K)); auto. generalize (somme_triangle (A:=A) (B:=B) (C:=K)); auto; intros. generalize (somme_triangle (A:=A) (B:=K) (C:=C)); auto; intros. rewrite (angles_milieu2 (A:=A) (B:=B) (C:=C) (I:=K)); auto. replace (cons_AV (vec B K) (vec B A)) with (plus (image_angle pi) (opp (plus (cons_AV (vec A B) (vec A K)) (cons_AV (vec K A) (vec K B))))). replace (cons_AV (vec C A) (vec C K)) with (plus (image_angle pi) (opp (plus (cons_AV (vec A K) (vec A C)) (cons_AV (vec K C) (vec K A))))). rewrite H9. replace (cons_AV (vec K C) (vec K A)) with (cons_AV (vec K A) (vec K B)); auto with geo. rewrite <- H11; auto. mesure A K A C. mesure K C K A. mesure C A C K. replace (x + (x0 + x1) + - (x + x0)) with x1; auto. ring. rewrite <- H10; auto. mesure K A K B. mesure A B A K. mesure B K B A. replace (x0 + (x1 + x) + - (x0 + x)) with x1; auto. ring. generalize (isocele_mediane_bissectrice (A:=A) (B:=B) (C:=C) (I:=K)); auto; intros. generalize (milieu_angles_orthogonaux (A:=B) (B:=C) (M:=K) (N:=A)); auto; intros. generalize (mediane_isocele_hauteur (A:=A) (B:=B) (C:=C) (I:=K)); auto with geo; intros. Qed. Lemma diametre_rectangle : forall A B C C' : PO, A <> B -> C' = milieu A B -> distance C' C = distance C' A -> orthogonal (vec C A) (vec C B). intros. discrimine C A. apply ortho_sym. replace (vec A A) with zero. apply zero_ortho_tout. Ringvec. discrimine C B. replace (vec B B) with zero. apply zero_ortho_tout. Ringvec. cut (B <> C'); intros. cut (A <> C'); intros. cut (C <> C'); intros. apply angles_orthogonal; auto. cut (isocele C' C A); intros. cut (isocele C' B C); intros. generalize (isocele_angles_base (A:=C') (B:=C) (C:=A)); auto; intros. generalize (isocele_angles_base (A:=C') (B:=B) (C:=C)); auto; intros. generalize (somme_triangle (A:=C') (B:=C) (C:=A)); intros. generalize (somme_triangle (A:=C') (B:=B) (C:=C)); intros. replace (double_AV (cons_AV (vec C A) (vec C B))) with (plus (double_AV (cons_AV (vec C A) (vec C C'))) (double_AV (cons_AV (vec C C') (vec C B)))). replace (double_AV (cons_AV (vec C A) (vec C C'))) with (plus (cons_AV (vec C A) (vec C C')) (cons_AV (vec A C') (vec A C))). replace (double_AV (cons_AV (vec C C') (vec C B))) with (plus (cons_AV (vec B C) (vec B C')) (cons_AV (vec C C') (vec C B))). replace (plus (cons_AV (vec B C) (vec B C')) (cons_AV (vec C C') (vec C B))) with (plus (image_angle pi) (opp (cons_AV (vec C' B) (vec C' C)))). replace (plus (cons_AV (vec C A) (vec C C')) (cons_AV (vec A C') (vec A C))) with (plus (image_angle pi) (opp (cons_AV (vec C' C) (vec C' A)))). rewrite def_opp; auto. rewrite def_opp; auto. mesure C' A C' C. mesure C' C C' B. replace (pi + x + (pi + x0)) with (pi + pi + (x + x0)). replace (pi + pi) with deuxpi; auto. rewrite add_mes_compatible; rewrite pi_plus_pi; rewrite <- add_mes_compatible. replace (0 + (x + x0)) with (x + x0); auto. rewrite add_mes_compatible. rewrite H14; rewrite H13. replace (plus (cons_AV (vec C' A) (vec C' C)) (cons_AV (vec C' C) (vec C' B))) with (cons_AV (vec C' A) (vec C' B)). rewrite <- (milieu_vecteur (A:=A) (B:=B) (M:=C')); auto. rewrite <- angle_plat; auto. rewrite Chasles; auto. ring. ring. rewrite <- H11; auto. rewrite <- H9; auto. mesure C' C C' A. mesure C A C C'. replace (x + (x0 + x0) + - x) with (x0 + x0); auto. ring. rewrite <- H12; auto. rewrite <- H10; auto. mesure C' B C' C. mesure B C B C'. replace (x + (x0 + x0) + - x) with (x0 + x0); auto. ring. rewrite H10; auto. rewrite H9; auto. rewrite double_Chasles; auto. unfold isocele in |- *. rewrite H1. apply carre_scalaire_egalite_distance. rewrite <- (milieu_vecteur (A:=A) (B:=B) (M:=C')); auto. replace (vec A C') with (mult_PP (-1) (vec C' A)); auto. Simplscal. Ringvec. unfold isocele in |- *. rewrite H1; auto. apply isometrie_distinct with (1 := H5). rewrite distance_sym. rewrite <- H1; rewrite distance_sym; auto. rewrite H0. apply milieu_distinct; auto. rewrite H0. apply milieu_distinct2; auto. Qed.HighSchoolGeometry/mediatrice.v0000644000076500007650000002547712073525612016540 0ustar coqcoq00000000000000(* This program is free software; you can redistribute it and/or *) (* modify it under the terms of the GNU Lesser General Public License *) (* as published by the Free Software Foundation; either version 2.1 *) (* of the License, or (at your option) any later version. *) (* *) (* This program is distributed in the hope that it will be useful, *) (* but WITHOUT ANY WARRANTY; without even the implied warranty of *) (* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *) (* GNU General Public License for more details. *) (* *) (* You should have received a copy of the GNU Lesser General Public *) (* License along with this program; if not, write to the Free *) (* Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA *) (* 02110-1301 USA *) Require Export angles_droites. Require Export metrique_triangle. Set Implicit Arguments. Unset Strict Implicit. Definition mediatrice (A B M : PO) := distance M A = distance M B :>R. Lemma mediatrice_permute : forall A B M : PO, mediatrice A B M -> mediatrice B A M. unfold mediatrice in |- *; intros. rewrite H; auto. Qed. Hint Immediate mediatrice_permute: geo. Lemma milieu_mediatrice : forall A B M : PO, M = milieu A B :>PO -> mediatrice A B M. red in |- *; intros. cut (vec A M = vec M B); intros; auto with geo. Qed. Lemma alignes_mediatrice_milieu : forall A B M : PO, A <> B -> alignes A B M -> mediatrice A B M -> M = milieu A B :>PO. unfold mediatrice in |- *; intros. halignes H0 ipattern:k. cut (k = / 2); intros. rewrite H3 in H2. apply vecteur_milieu; auto. cut (vec M B = mult_PP (1 + - k) (vec A B)); intros. cut (scalaire (vec A M) (vec A M) = scalaire (vec M B) (vec M B)); intros. rewrite H2 in H4. rewrite H3 in H4. cut (k * k = (1 + - k) * (1 + - k)); intros; auto with real. apply resolution2 with (x := scalaire (vec A B) (vec A B)) (y := scalaire (vec A B) (vec A B)); auto with geo. replace (scalaire (vec A B) (vec A B) * (k * k)) with (scalaire (mult_PP k (vec A B)) (mult_PP k (vec A B))). rewrite H4. Simplscal. ring_simplify. Simplscal. replace (scalaire (vec A M) (vec A M)) with (scalaire (vec M A) (vec M A)). repeat rewrite carre_scalaire_distance; rewrite H1; auto. replace (vec M A) with (mult_PP (-1) (vec A M)). Simplscal. Ringvec. replace (vec M B) with (add_PP (vec A B) (mult_PP (-1) (vec A M))). rewrite H2. Ringvec. Ringvec. Qed. Lemma mediatrice_projete_orthogonal : forall A B M H : PO, A <> B :>PO -> H = projete_orthogonal A B M :>PO -> mediatrice A B M -> distance H A = distance H B :>R. unfold mediatrice in |- *; intros. generalize (Pythagore_projete_orthogonal (A:=A) (B:=B) (C:=M) (H:=H)); intros. elim H3; [ try clear H3; intros | auto | auto ]. apply distance_carre. replace (Rsqr (distance H A)) with (Rsqr (distance A M) + - Rsqr (distance H M)). replace (Rsqr (distance H M)) with (Rsqr (distance B M) + - Rsqr (distance H B)). rewrite (distance_sym A M); auto. rewrite (distance_sym B M); auto. rewrite H2; ring. rewrite H4; ring. rewrite H3; ring. Qed. Lemma mediatrice_projete_milieu : forall A B M H : PO, A <> B :>PO -> H = projete_orthogonal A B M :>PO -> mediatrice A B M -> H = milieu A B :>PO. intros. generalize (def_projete_orthogonal2 (A:=A) (B:=B) (C:=M) (H:=H)); intros. elim H3; [ intros; clear H3 | auto | auto ]. apply alignes_mediatrice_milieu; auto. red in |- *. apply mediatrice_projete_orthogonal with M; auto. Qed. Lemma mediatrice_orthogonale_segment_milieu : forall A B M N : PO, A <> B :>PO -> M <> N :>PO -> M = milieu A B :>PO -> mediatrice A B N -> orthogonal (vec A B) (vec M N). intros A B M N H3 H0 H1 H2; try assumption. elim existence_projete_orthogonal with (A := A) (B := B) (C := N); [ intros H H4; try clear existence_projete_orthogonal; auto | auto ]. generalize (mediatrice_projete_milieu (A:=A) (B:=B) (M:=N) (H:=H)); intros H7. rewrite H1; rewrite <- H7; auto. generalize (def_projete_orthogonal2 (A:=A) (B:=B) (C:=N) (H:=H)); intros. elim H5; [ intros; auto | auto | auto ]. Qed. Lemma mediatrice_orthogonale_segment : forall A B M N : PO, A <> B :>PO -> mediatrice A B M -> mediatrice A B N -> orthogonal (vec M N) (vec A B). intros. discrimine M N. VReplace (vec N N) zero. auto with geo. elim (classic (milieu A B = M)); intros. rewrite <- H3; rewrite <- H3 in H0. apply ortho_sym. apply mediatrice_orthogonale_segment_milieu; auto. rewrite H3; auto. elim (classic (milieu A B = N)); intros. rewrite <- H4; rewrite <- H4 in H2. replace (vec M (milieu A B)) with (add_PP (mult_PP 0 (vec (milieu A B) M)) (mult_PP (-1) (vec (milieu A B) M))). apply ortho_combinaison_lineaire; auto. apply ortho_sym; apply mediatrice_orthogonale_segment_milieu; auto. apply ortho_sym; apply mediatrice_orthogonale_segment_milieu; auto. Ringvec. cut (orthogonal (vec (milieu A B) N) (vec A B)); intros. cut (orthogonal (vec (milieu A B) M) (vec A B)); intros. replace (vec M N) with (add_PP (mult_PP 1 (vec (milieu A B) N)) (mult_PP (-1) (vec (milieu A B) M))). apply ortho_combinaison_lineaire; auto with geo. Ringvec. apply ortho_sym; apply mediatrice_orthogonale_segment_milieu; auto with geo. apply ortho_sym; apply mediatrice_orthogonale_segment_milieu; auto with geo. Qed. Lemma orthogonale_segment_milieu_mediatrice : forall A B M N : PO, A <> B :>PO -> M = milieu A B :>PO -> orthogonal (vec A B) (vec M N) -> mediatrice A B N. unfold mediatrice in |- *; intros. apply carre_egalite_distance. repeat rewrite <- carre_scalaire_distance. generalize (rectangle_Pythagore M N A); unfold iff in |- *; intros. generalize (rectangle_Pythagore M N B); unfold iff in |- *; intros. elim H2; [ intros H4 H7; try clear H2 ]. elim H3; [ intros H5 H6; try clear H3 ]. cut (orthogonal (vec M N) (vec M A)); intros. rewrite H4; auto. rewrite H5. replace (scalaire (vec M A) (vec M A)) with (scalaire (vec A M) (vec A M)). rewrite (milieu_vecteur H0); auto. replace (vec M A) with (mult_PP (-1) (vec A M)). Simplscal. Ringvec. rewrite <- (milieu_vecteur H0); auto. auto with geo. apply ortho_sym. replace (vec M A) with (mult_PP (- / 2) (vec A B)). auto with geo. replace (vec M A) with (mult_PP (-1) (mult_PP (/ 2) (vec A B))). cut (2 <> 0); intros; auto with real. Fieldvec 2. rewrite <- (milieu_vecteur2 H0); auto. Ringvec. Qed. Lemma mediatrice_distinct_extremite : forall A B M : PO, A <> B -> mediatrice A B M -> M <> A /\ M <> B. unfold mediatrice in |- *; intros. cut (~ (M = A \/ M = B)); intros. intuition. unfold not in |- *; intros; apply H. elim H1; [ intros H2; try clear H1; rewrite <- H2; rewrite <- H2 in H0 | intros H2; try clear H1; rewrite <- H2; rewrite <- H2 in H0 ]. apply distance_nulle; auto. rewrite carre_scalaire_distance; rewrite <- H0; rewrite <- carre_scalaire_distance. replace (vec M M) with (mult_PP 0 (vec A B)). Simplscal. Ringvec. apply distance_nulle. replace (vec A M) with (mult_PP (-1) (vec M A)). Simplscal. rewrite carre_scalaire_distance; rewrite H0; rewrite <- carre_scalaire_distance. replace (vec M M) with (mult_PP 0 (vec A B)). Simplscal. Ringvec. Ringvec. Qed. Lemma existence_mediatrice : forall A B : PO, A <> B :>PO -> ex (fun J : PO => milieu A B <> J :>PO /\ mediatrice A B J). intros. soit_milieu A B ipattern:M. soit_orthogonal M A ipattern:J. exists J. split; [ try assumption | idtac ]. apply orthogonale_segment_milieu_mediatrice with M; auto. apply orthogonal_milieu with M; auto. Qed. Comments " " "soit_mediatrice" "pose" "IJ" "mediatrice" "de" "[AB]" "avec" "I" "milieu" "de" "AB" "et" "echoue" "si" "A=B" "et" "ajoute" "des" "hypotheses". Ltac soit_mediatrice A B I J := soit_milieu A B I; match goal with | h:(I = milieu A B) |- _ => elim (existence_mediatrice (A:=A) (B:=B)); [ intros J; intros HME; rewrite <- h in HME; elim HME; clear HME; intros; generalize h; intros; clear h; lapply (mediatrice_distinct_extremite (A:=A) (B:=B) (M:=J)); try assumption; intros toto; elim toto; try assumption; clear toto; intros | auto ] end. Lemma mediatrice_milieu_angles : forall A B M N : PO, A <> B -> M <> N -> M = milieu A B -> mediatrice A B N -> cons_AV (vec N A) (vec N M) = cons_AV (vec N M) (vec N B) :>AV. intros. elim mediatrice_distinct_extremite with (A := A) (B := B) (M := N); (auto; intros). cut (M <> A); intros. cut (M <> B); intros. elim cas_egalite_triangle_indirect with (A := M) (B := N) (C := A) (A' := M) (B' := N) (C' := B); (auto with geo; intros). elim H8; intros H9 H10; try clear H8; try exact H9. symmetry in |- *. generalize (milieu_angles_orthogonaux (A:=A) (B:=B) (M:=M) (N:=N)); intros. mesure M A M N. rewrite <- (mes_oppx (A:=M) (B:=A) (C:=M) (D:=N) (x:=x)); auto. rewrite <- (mes_oppx (A:=M) (B:=N) (C:=M) (D:=B) (x:=x)); auto. rewrite H8; rewrite H7; auto. apply mediatrice_orthogonale_segment_milieu; auto. lapply (milieu_distinct2 (A:=A) (B:=B)); auto; intros. rewrite H1; auto. lapply (milieu_distinct (A:=A) (B:=B)); auto; intros. rewrite H1; auto. Qed. Require Export Droite_espace. Lemma mediatrices_triangle_concours : forall A B C I J K L : PO, triangle A B C -> I = milieu A B :>PO -> J = milieu B C :>PO -> I <> K :>PO -> J <> L :>PO -> mediatrice A B K -> mediatrice B C L -> concours (droite I K) (droite J L). intros. deroule_triangle A B C. lapply (position_relative_droites_coplanaires (A:=I) (B:=K) (C:=J) (D:=L)); auto with geo; intros. elim H10; auto with geo; intros. absurd (paralleles (droite J L) (droite I K)); auto with geo. cut (double_AV (cons_AV (vec I K) (vec J L)) = double_AV (cons_AV (vec B A) (vec B C))); intros. apply angle_non_paralleles; auto. rewrite H12. red in |- *; intros. apply H6; auto with geo. apply angles_droites_orthogonales; auto. cut (orthogonal (vec I K) (vec A B)); intros; auto with geo. apply mediatrice_orthogonale_segment; auto. apply milieu_mediatrice; auto. apply ortho_sym; auto. apply mediatrice_orthogonale_segment; auto. apply milieu_mediatrice; auto. Qed. Lemma mediatrice_droite : forall A B I J K : PO, A <> B :>PO -> I = milieu A B :>PO -> mediatrice A B J -> mediatrice A B K -> alignes I J K. intros. discrimine I J. discrimine J K. discrimine I K. lapply (milieu_mediatrice (A:=A) (B:=B) (M:=I)); auto; intros. lapply (mediatrice_orthogonale_segment (A:=A) (B:=B) (M:=I) (N:=J)); auto; intros. lapply (mediatrice_orthogonale_segment (A:=A) (B:=B) (M:=I) (N:=K)); auto; intros. elim (orthogonal_paralleles (A:=I) (B:=B) (C:=J) (E:=I) (F:=K)); auto; intros. apply colineaire_alignes with x; auto. lapply (milieu_distinct2 (A:=A) (B:=B)); auto. rewrite <- H0; auto. lapply (orthogonal_segment_milieu (A:=A) (B:=B) (C:=I) (D:=J) (I:=I)); auto; intros. elim H9; auto with geo; intros. apply ortho_sym. lapply (orthogonal_segment_milieu (A:=A) (B:=B) (C:=I) (D:=K) (I:=I)); auto; intros. elim H9; auto with geo; intros. Qed. HighSchoolGeometry/mesure_algebrique.v0000644000076500007650000001242212117747636020127 0ustar coqcoq00000000000000(* This program is free software; you can redistribute it and/or *) (* modify it under the terms of the GNU Lesser General Public License *) (* as published by the Free Software Foundation; either version 2.1 *) (* of the License, or (at your option) any later version. *) (* *) (* This program is distributed in the hope that it will be useful, *) (* but WITHOUT ANY WARRANTY; without even the implied warranty of *) (* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *) (* GNU General Public License for more details. *) (* *) (* You should have received a copy of the GNU Lesser General Public *) (* License along with this program; if not, write to the Free *) (* Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA *) (* 02110-1301 USA *) Require Export barycentre. Set Implicit Arguments. Unset Strict Implicit. Parameter mes_alg : PO -> PO -> R. Axiom def_mes_alg : forall (A B C D : PO) (k : R), vec C D = mult_PP k (vec A B) :>PP -> mes_alg C D = k * mes_alg A B :>R. Axiom def_mes_alg2 : forall (A B C D : PO) (k : R), mes_alg C D = k * mes_alg A B :>R -> col_vec A B C D -> vec C D = mult_PP k (vec A B) :>PP. Lemma mes_alg_BA : forall A B : PO, mes_alg B A = - mes_alg A B :>R. intros. RReplace (- mes_alg A B) (-1 * mes_alg A B). apply def_mes_alg. Ringvec. Qed. Lemma mes_alg_nulle : forall A B : PO, mes_alg A B = 0 :>R -> A = B. intros. apply vecteur_nul_conf. replace zero with (mult_PP 0 (vec A B)). apply def_mes_alg2. rewrite H; ring. unfold col_vec in |- *. exists 1. Ringvec. Ringvec. Qed. Lemma mes_alg_conf : forall A B : PO, A = B -> mes_alg A B = 0 :>R. intros. rewrite H. replace 0 with (0 * mes_alg A A). apply def_mes_alg. Ringvec. ring. Qed. Hint Resolve mes_alg_conf mes_alg_nulle: geo. Lemma Chasles_mes_alg : forall A B C : PO, alignes A B C -> mes_alg A B + mes_alg B C = mes_alg A C. intros. halignes H ipattern:k. rewrite (mes_alg_conf (A:=B) (B:=B)); auto; ring. replace (mes_alg A B) with (1 * mes_alg A B). replace (mes_alg B C) with ((k + -1) * mes_alg A B). replace (mes_alg A C) with (k * mes_alg A B). ring. symmetry in |- *; apply def_mes_alg; auto. symmetry in |- *; apply def_mes_alg; auto. VReplace (vec B C) (add_PP (vec A C) (mult_PP (-1) (vec A B))). rewrite H0; Ringvec. symmetry in |- *; apply def_mes_alg; Ringvec. Qed. Lemma existence_mes_algebrique : forall (k : R) (A B : PO), exists C : PO, alignes A B C /\ mes_alg A C = k * mes_alg A B. intros. elim existence_representant_mult_vecteur with (A := A) (B := A) (C := B) (k := k); [ intros C H; try clear existence_representant_mult_vecteur; try exact H ]. exists C. cut (mes_alg A C = k * mes_alg A B); intros. split; [ idtac | try assumption ]. apply colineaire_alignes with k; auto. apply def_mes_alg; auto. Qed. Lemma vecteur_quotient_mes_algebrique : forall (A B C D : PO) (k : R), A <> B -> vec C D = mult_PP k (vec A B) -> mes_alg C D / mes_alg A B = k. intros. rewrite (def_mes_alg H0); auto. field. contrapose H. apply mes_alg_nulle; auto. Qed. Lemma quotient_mes_algebrique_vecteur : forall (A B C D : PO) (k : R), A <> B -> col_vec A B C D -> mes_alg C D / mes_alg A B = k -> vec C D = mult_PP k (vec A B). intros. apply def_mes_alg2; auto. assert (mes_alg A B <> 0). contrapose H. apply mes_alg_nulle; auto. RReplace (mes_alg C D) (mes_alg C D / mes_alg A B * mes_alg A B). rewrite H1; auto. field; auto. Qed. Hint Resolve def_mes_alg2 def_mes_alg: geo. Lemma colineaire_mes_alg_conf : forall (A B C D : PO) (k : R), A <> B -> col_vec A B A C -> col_vec A B A D -> mes_alg A C = k * mes_alg A B -> mes_alg A D = k * mes_alg A B -> C = D. intros. assert (vec A C = mult_PP k (vec A B)); auto with geo. assert (vec A D = mult_PP k (vec A B)); auto with geo. apply vecteur_nul_conf. VReplace (vec C D) (add_PP (vec A D) (mult_PP (-1) (vec A C))). rewrite H5; rewrite H4; Ringvec. Qed. Lemma barycentre_mes_alg : forall (a b : R) (A B G : PO), a + b <> 0 :>R -> G = barycentre (cons a A) (cons b B) :>PO -> a * mes_alg G A + b * mes_alg G B = 0 :>R. intros. cut (a <> 0 \/ b <> 0); intros. elim H1; [ intros H2; try clear H1 | intros H2; try clear H1; try exact H2 ]. cut (mes_alg G A = / a * - b * mes_alg G B); intros. rewrite H1. RReplace (a * (/ a * - b * mes_alg G B)) (a * / a * (- b * mes_alg G B)). RReplace (a * / a) 1. ring. apply def_mes_alg. apply mult_PP_regulier with a; auto. replace (mult_PP a (mult_PP (/ a * - b) (vec G B))) with (add_PP (mult_PP (- b) (vec G B)) zero). rewrite <- (def_vecteur_bary (a:=a) (b:=b) (A:=A) (B:=B) (G:=G)); auto. Ringvec. Fieldvec a. cut (mes_alg G B = / b * - a * mes_alg G A); intros. rewrite H1. RReplace (b * (/ b * - a * mes_alg G A)) (b * / b * (- a * mes_alg G A)). RReplace (b * / b) 1. ring. apply def_mes_alg. apply mult_PP_regulier with b; auto. replace (mult_PP b (mult_PP (/ b * - a) (vec G A))) with (add_PP (mult_PP (- a) (vec G A)) zero). rewrite <- (def_vecteur_bary (a:=a) (b:=b) (A:=A) (B:=B) (G:=G)); auto. Ringvec. Fieldvec b. apply not_and_or. red in |- *; intros; apply H. elim H1; intros H2 H3; try clear H1; try exact H3. rewrite H2; rewrite H3; ring. Qed.HighSchoolGeometry/metrique_triangle.v0000644000076500007650000007005312073525614020142 0ustar coqcoq00000000000000(* This program is free software; you can redistribute it and/or *) (* modify it under the terms of the GNU Lesser General Public License *) (* as published by the Free Software Foundation; either version 2.1 *) (* of the License, or (at your option) any later version. *) (* *) (* This program is distributed in the hope that it will be useful, *) (* but WITHOUT ANY WARRANTY; without even the implied warranty of *) (* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *) (* GNU General Public License for more details. *) (* *) (* You should have received a copy of the GNU Lesser General Public *) (* License along with this program; if not, write to the Free *) (* Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA *) (* 02110-1301 USA *) Require Export euclidien_classiques. Require Export trigo. Set Implicit Arguments. Unset Strict Implicit. Lemma produit_scalaire_Cosinus : forall A B C : PO, A <> B -> A <> C -> scalaire (vec A B) (vec A C) = distance A B * (distance A C * Cos (cons_AV (vec A B) (vec A C))). intros. elim existence_representant_unitaire with (A := A) (B := B); [ intros B' H2; try clear existence_representant_unitaire; try exact H2 | auto ]. elim existence_representant_unitaire with (A := A) (B := C); [ intros C' H3; try clear existence_representant_unitaire; try exact H3 | auto ]. elim existence_ROND_AB with (A := A) (B := B'); [ intros D H10 | auto ]. elim H10; intros. elim H4; intros H6 H7; try clear H4; try exact H7. rewrite angles_representants_unitaires; auto with geo. pattern (vec A B) at 1 in |- *. rewrite distance_vecteur; auto. pattern (vec A C) at 1 in |- *. rewrite distance_vecteur; auto. rewrite <- H3; rewrite <- H2. pattern (vec A C') at 1 in |- *. rewrite (coordonnees_Cos_Sin (O:=A) (I:=B') (J:=D) (M:=C')); auto. replace (mult_PP (distance A C) (add_PP (mult_PP (Cos (cons_AV (vec A B') (vec A C'))) (vec A B')) (mult_PP (Sin (cons_AV (vec A B') (vec A C'))) (vec A D)))) with (add_PP (mult_PP (distance A C * Cos (cons_AV (vec A B') (vec A C'))) (vec A B')) (mult_PP (distance A C * Sin (cons_AV (vec A B') (vec A C'))) (vec A D))). replace (mult_PP (distance A B) (vec A B')) with (add_PP (mult_PP (distance A B) (vec A B')) (mult_PP 0 (vec A D))). Simplscal. replace (scalaire (vec A B') (vec A D)) with 0. rewrite H6; ring. symmetry in |- *; auto with geo. Ringvec. Ringvec. elim def_representant_unitaire2 with (A := A) (B := C) (C := C'); auto with geo; intros. elim H5; auto with geo. elim def_representant_unitaire2 with (A := A) (B := B) (C := B'); auto; intros. elim H4; auto with geo. Qed. Lemma produit_scalaire_cosinus : forall (A B C : PO) (a : R), A <> B -> A <> C -> image_angle a = cons_AV (vec A B) (vec A C) -> scalaire (vec A B) (vec A C) = distance A B * (distance A C * cos a). intros. rewrite produit_scalaire_Cosinus; auto. rewrite (egalite_cos_Cos (A:=A) (B:=B) (C:=C) (x:=a)); auto. Qed. Hint Resolve carre_scalaire_distance: geo. Lemma triangle_rectangle_Cos : forall (A B C : PO) (a : R), A <> B -> A <> C -> orthogonal (vec B A) (vec B C) -> distance A B = distance A C * Cos (cons_AV (vec A B) (vec A C)). intros. cut (scalaire (vec A B) (vec A C) = distance A B * (distance A C * Cos (cons_AV (vec A B) (vec A C)))); intros. 2: apply produit_scalaire_Cosinus; auto. apply Rmult_eq_reg_l with (distance A B); auto with geo. rewrite <- H2. rewrite (scalaire_avec_projete (A:=A) (B:=B) (C:=C) (H:=B)); auto with geo. Qed. Lemma triangle_rectangle_cos : forall (A B C : PO) (a : R), A <> B -> A <> C -> orthogonal (vec B A) (vec B C) -> image_angle a = cons_AV (vec A B) (vec A C) -> distance A B = distance A C * cos a. intros. rewrite (triangle_rectangle_Cos (A:=A) (B:=B) (C:=C)); auto. rewrite (egalite_cos_Cos (A:=A) (B:=B) (C:=C) (x:=a)); auto. Qed. Lemma triangle_rectangle_absolu_cos : forall (A B C : PO) (a : R), A <> B -> A <> C -> orthogonal (vec B A) (vec B C) -> image_angle a = cons_AV (vec A B) (vec A C) -> distance A B = distance A C * Rabs (cos a). intros. cut (/ distance A C >= 0); intros; auto with geo. cut (distance A B >= 0); intros; auto with geo. cut (cos a >= 0); intros. rewrite Rabs_right; auto with real. apply triangle_rectangle_cos; auto. replace (cos a) with (distance A B * / distance A C). RReplace 0 (0 * / distance A C). apply Rmult_ge_compat_r; auto. rewrite (triangle_rectangle_cos (A:=A) (B:=B) (C:=C) (a:=a)); intros; auto with geo. field. auto with geo. apply Rinv_le_pos; auto with geo. Qed. Lemma orthogonal_distincts : forall A B C : PO, A <> B -> A <> C -> orthogonal (vec A B) (vec A C) -> B <> C. intros. apply non_alignes_distincts2 with A; auto. apply orthogonal_non_alignes; auto with geo. Qed. Lemma triangle_rectangle_direct_sinus : forall (A B C : PO) (a : R), A <> B -> A <> C -> B <> C -> image_angle pisurdeux = cons_AV (vec B C) (vec B A) -> image_angle a = cons_AV (vec A B) (vec A C) -> distance C B = distance C A * sin a. intros. cut (image_angle (pisurdeux + - a) = cons_AV (vec C A) (vec C B)); intros. rewrite sin_cos_pisurdeux_moins_x. rewrite <- cos_paire. rewrite <- (triangle_rectangle_cos (A:=C) (B:=B) (C:=A) (a:=- (pisurdeux + - a))) ; auto with geo. apply mes_oppx; auto. replace (cons_AV (vec C A) (vec C B)) with (plus (image_angle pi) (opp (plus (cons_AV (vec A B) (vec A C)) (cons_AV (vec B C) (vec B A))))); auto with geo. rewrite opp_plus_plus_opp; auto. rewrite <- H3; rewrite <- H2. repeat rewrite <- mes_opp. repeat rewrite <- add_mes_compatible. replace (pisurdeux + - a) with (pi + (- a + - pisurdeux)); auto. unfold pi in |- *; ring. Qed. Lemma triangle_rectangle_indirect_sinus : forall (A B C : PO) (a : R), A <> B -> A <> C -> B <> C -> image_angle (- pisurdeux) = cons_AV (vec B C) (vec B A) -> image_angle a = cons_AV (vec A B) (vec A C) -> distance C B = distance C A * - sin a. intros A B C a H H0 H1 H2 H3; try assumption. elim pisurdeux_plus_x with (x := a); [ intros H5 H6; try clear pisurdeux_plus_x; try rewrite <- H5 ]. rewrite <- (triangle_rectangle_cos (A:=C) (B:=B) (C:=A) (a:=pisurdeux + a)); auto with geo. cut (orthogonal (vec B A) (vec B C)); auto with geo. apply pisurdeux_droit. RReplace pisurdeux (- - pisurdeux). apply mes_oppx; auto with geo. RReplace (pisurdeux + a) (- - (pisurdeux + a)). apply mes_oppx; auto with geo. replace (cons_AV (vec C A) (vec C B)) with (plus (image_angle pi) (opp (plus (cons_AV (vec A B) (vec A C)) (cons_AV (vec B C) (vec B A))))); auto with geo. rewrite opp_plus_plus_opp; auto. rewrite <- H3; rewrite <- H2. repeat rewrite <- mes_opp. repeat rewrite <- add_mes_compatible. rewrite <- (plus_angle_zero (image_angle (- (pisurdeux + a)))). rewrite <- pi_plus_pi. repeat rewrite <- add_mes_compatible. replace (- (pisurdeux + a) + deuxpi) with (pi + (- a + - - pisurdeux)); auto. unfold deuxpi, pi in |- *; ring. Qed. Lemma triangle_rectangle_absolu_sinus : forall (A B C : PO) (a : R), A <> B -> A <> C -> B <> C -> orthogonal (vec B A) (vec B C) -> image_angle a = cons_AV (vec A B) (vec A C) -> distance C B = distance C A * Rabs (sin a). intros. cut (/ distance C A >= 0); intros; auto with geo. 2: apply Rinv_le_pos; auto with geo. cut (distance C B >= 0); intros; auto with geo. elim orthogonal_pisurdeux_or with (A := B) (B := C) (C := B) (D := A); [ intros H10; try clear orthogonal_pisurdeux_or | intros H10; try clear orthogonal_pisurdeux_or | auto | auto | auto with geo ]. cut (sin a >= 0); intros. rewrite Rabs_right; auto with real. apply triangle_rectangle_direct_sinus; auto. replace (sin a) with (distance C B * / distance C A). RReplace 0 (0 * / distance C A). apply Rmult_ge_compat_r; auto with geo. rewrite (triangle_rectangle_direct_sinus (A:=A) (B:=B) (C:=C) (a:=a)); intros; auto with geo. field. auto with geo. cut (- sin a >= 0); intros. elim H6; clear H6; intros. rewrite Rabs_left; auto with real. apply triangle_rectangle_indirect_sinus; auto. fourier. rewrite Rabs_right; auto with real. replace (sin a) with (- sin a). apply triangle_rectangle_indirect_sinus; auto. rewrite H6. RReplace (sin a) (- - sin a). rewrite H6; ring. RReplace (sin a) (- - sin a). rewrite H6; auto with real. replace (- sin a) with (distance C B * / distance C A). RReplace 0 (0 * / distance C A). apply Rmult_ge_compat_r; auto. rewrite (triangle_rectangle_indirect_sinus (A:=A) (B:=B) (C:=C) (a:=a)); intros; auto with geo. field. auto with geo. Qed. Lemma triangle_rectangle_direct_Sin : forall A B C : PO, A <> B -> A <> C -> B <> C -> image_angle pisurdeux = cons_AV (vec B C) (vec B A) -> distance C B = distance C A * Sin (cons_AV (vec A B) (vec A C)). intros. mes (cons_AV (vec A B) (vec A C)). rewrite <- H3. rewrite <- (egalite_sin_Sin (A:=A) (B:=B) (C:=C) (x:=x)); auto. apply triangle_rectangle_direct_sinus; auto. Qed. Lemma triangle_rectangle_indirect_Sin : forall A B C : PO, A <> B -> A <> C -> B <> C -> image_angle (- pisurdeux) = cons_AV (vec B C) (vec B A) -> distance C B = distance C A * - Sin (cons_AV (vec A B) (vec A C)). intros. mes (cons_AV (vec A B) (vec A C)). rewrite <- H3. rewrite <- (egalite_sin_Sin (A:=A) (B:=B) (C:=C) (x:=x)); auto. apply triangle_rectangle_indirect_sinus; auto. Qed. Lemma triangle_rectangle_absolu_Sin : forall A B C : PO, A <> B -> A <> C -> B <> C -> orthogonal (vec B A) (vec B C) -> distance C B = distance C A * Rabs (Sin (cons_AV (vec A B) (vec A C))). intros. mes (cons_AV (vec A B) (vec A C)). rewrite <- H3. rewrite <- (egalite_sin_Sin (A:=A) (B:=B) (C:=C) (x:=x)); auto. apply triangle_rectangle_absolu_sinus; auto. Qed. Lemma projete_negatif_cos : forall (A B C H : PO) (a k : R), A <> B -> A <> C -> H = projete_orthogonal A B C -> vec A H = mult_PP k (vec A B) -> k < 0 -> image_angle a = cons_AV (vec A B) (vec A C) -> cos a < 0. intros. cut (scalaire (vec A B) (vec A C) < 0); intros. replace (cos a) with (/ distance A B * / distance A C * scalaire (vec A B) (vec A C)). RReplace 0 (/ distance A B * / distance A C * 0). apply Rmult_lt_compat_l; auto with real. apply Rmult_lt_0_compat; auto with real. apply Rinv_0_lt_compat; auto with real. cut (distance A B >= 0); intros; auto with geo. elim H7; auto with real; intros. absurd (distance A B = 0); auto with geo. apply Rinv_0_lt_compat; auto with real. cut (distance A C >= 0); intros; auto with geo. elim H7; auto with real; intros. absurd (distance A C = 0); auto with geo. rewrite (produit_scalaire_cosinus (A:=A) (B:=B) (C:=C) (a:=a)); auto. field; split; auto with geo. elim def_projete_orthogonal2 with (A := A) (B := B) (C := C) (H := H); [ intros; auto | auto | auto ]. rewrite (scalaire_avec_projete (A:=A) (B:=B) (C:=C) (H:=H)); auto with geo. rewrite H3. RReplace (scalaire (vec A B) (mult_PP k (vec A B))) (- (- k * scalaire (vec A B) (vec A B))). apply Ropp_lt_gt_0_contravar; auto with real. apply Rmult_gt_0_compat; auto with real. cut (scalaire (vec A B) (vec A B) >= 0); intros; auto with geo. elim H8; auto with real; intros. absurd (scalaire (vec A B) (vec A B) = 0); auto with geo. Simplscal. Qed. Lemma projete_absolu_cos : forall (A B C H : PO) (a : R), A <> B -> A <> C -> H = projete_orthogonal A B C -> image_angle a = cons_AV (vec A B) (vec A C) -> distance A H = distance A C * Rabs (cos a). intros. elim def_projete_orthogonal2 with (A := A) (B := B) (C := C) (H := H); [ intros; auto | auto | auto ]. halignes H4 ipattern:k. cut (orthogonal (vec H A) (vec H C)); intros; auto with geo. elim Rtotal_order with (r1 := k) (r2 := 0); [ intros H8; try clear total_order | intros H8; elim H8; [ intros H9; try clear H8 | intros H9; try clear H8; try exact H9 ] ]. replace (Rabs (cos a)) with (Rabs (cos (a + pi))). apply triangle_rectangle_absolu_cos; auto. apply distinct_produit_vecteur with (3 := H6); auto with real. rewrite H6; auto. rewrite angle_produit_negatif_l; auto. rewrite add_mes_compatible; rewrite <- H3; auto. RReplace (a + pi) (pi + a). elim pi_plus_x with (x := a); [ intros H9 H10; try clear pi_plus_x; rewrite H9 ]. rewrite Rabs_Ropp; auto. cut (A = H); intros. rewrite <- H8 in H5; auto. elim droit_direct_ou_indirect with (A := A) (B := B) (C := C); [ intros H10; try clear droit_direct_ou_indirect | intros H10; try clear droit_direct_ou_indirect; try exact H10 | auto | auto | auto ]. replace (cos a) with (cos pisurdeux). rewrite cos_pisurdeux; rewrite Rabs_R0; ring_simplify. rewrite <- H8; auto with geo. apply cos_deux_mes. rewrite H10; auto. replace (cos a) with (cos (- pisurdeux)). rewrite cos_paire; rewrite cos_pisurdeux; rewrite Rabs_R0; ring_simplify. rewrite <- H8; auto with geo. apply cos_deux_mes. rewrite H10; auto. apply produit_zero_conf with (1 := H6); auto. apply triangle_rectangle_absolu_cos; auto. apply distinct_produit_vecteur with (3 := H6); auto with real. rewrite H6; auto. rewrite angle_produit_positif_l; auto. replace (vec H A) with (mult_PP (- k) (vec A B)). Simplortho. VReplace (vec H A) (mult_PP (-1) (vec A H)). rewrite H6; Ringvec. Qed. Lemma projete_absolu_sin : forall (A B C H : PO) (a : R), triangle A B C -> H = projete_orthogonal A B C -> image_angle a = cons_AV (vec A B) (vec A C) -> distance C H = distance C A * Rabs (sin a). intros. deroule_triangle A B C. elim def_projete_orthogonal2 with (A := A) (B := B) (C := C) (H := H); [ intros; auto | auto | auto ]. halignes H7 ipattern:k. cut (orthogonal (vec H A) (vec H C)); intros; auto with geo. elim Rtotal_order with (r1 := k) (r2 := 0); [ intros H11; try clear total_order | intros H11; elim H11; [ intros H12; try clear H11 total_order | intros H12; try clear H11 total_order; try exact H12 ] ]. replace (Rabs (sin a)) with (Rabs (sin (a + pi))). apply triangle_rectangle_absolu_sinus; auto. apply distinct_produit_vecteur with (3 := H9); auto with real. red in |- *; intros; apply H3. rewrite <- H12; auto with geo. rewrite H9. rewrite angle_produit_negatif_l; auto. rewrite add_mes_compatible; rewrite <- H2; auto. RReplace (a + pi) (pi + a). elim pi_plus_x with (x := a); [ intros H12 H13; try clear pi_plus_x; rewrite H13 ]. rewrite Rabs_Ropp; auto. cut (A = H); intros. rewrite <- H13 in H8; auto. elim droit_direct_ou_indirect with (A := A) (B := B) (C := C); [ intros H14; try clear droit_direct_ou_indirect | intros H14; try clear droit_direct_ou_indirect; try exact H14 | auto | auto | auto ]. replace (sin a) with (sin pisurdeux). rewrite sin_pisurdeux; rewrite Rabs_R1; ring_simplify. rewrite <- H13; auto. apply sin_deux_mes. rewrite H14; auto. replace (sin a) with (sin (- pisurdeux)). rewrite sin_impaire; rewrite sin_pisurdeux. rewrite Rabs_Ropp; rewrite Rabs_R1; ring_simplify. rewrite <- H13; auto. apply sin_deux_mes. rewrite H14; auto. apply produit_zero_conf with (1 := H9); auto. apply triangle_rectangle_absolu_sinus; auto. apply distinct_produit_vecteur with (3 := H9); auto with real. red in |- *; intros; apply H3. rewrite <- H13; auto with geo. rewrite H9; auto. rewrite angle_produit_positif_l; auto. replace (vec H A) with (mult_PP (- k) (vec A B)). Simplortho. VReplace (vec H A) (mult_PP (-1) (vec A H)). rewrite H9; Ringvec. Qed. Lemma projete_absolu_Sin : forall A B C H : PO, triangle A B C -> H = projete_orthogonal A B C -> distance C H = distance C A * Rabs (Sin (cons_AV (vec A B) (vec A C))). intros. deroule_triangle A B C. mes (cons_AV (vec A B) (vec A C)). rewrite <- H6. rewrite <- (egalite_sin_Sin (A:=A) (B:=B) (C:=C) (x:=x)); auto. apply projete_absolu_sin with B; auto. Qed. Lemma projete_absolu_Cos : forall A B C H : PO, A <> B -> A <> C -> H = projete_orthogonal A B C -> distance A H = distance A C * Rabs (Cos (cons_AV (vec A B) (vec A C))). intros. mes (cons_AV (vec A B) (vec A C)). rewrite <- H3. rewrite <- (egalite_cos_Cos (A:=A) (B:=B) (C:=C) (x:=x)); auto. apply projete_absolu_cos with B; auto. Qed. Theorem Al_Kashi_Cos : forall A B C : PO, A <> B -> A <> C -> Rsqr (distance B C) = Rsqr (distance A B) + Rsqr (distance A C) + - (2 * (distance A B * (distance A C * Cos (cons_AV (vec A B) (vec A C))))). unfold Rsqr in |- *; intros. repeat rewrite <- carre_scalaire_distance. rewrite (difference_Pythagore A B C). rewrite (produit_scalaire_Cosinus (A:=A) (B:=B) (C:=C)); auto. ring. Qed. Theorem Al_Kashi : forall (A B C : PO) (a : R), A <> B -> A <> C -> image_angle a = cons_AV (vec A B) (vec A C) -> Rsqr (distance B C) = Rsqr (distance A B) + Rsqr (distance A C) + - (2 * (distance A B * (distance A C * cos a))). unfold Rsqr in |- *; intros. repeat rewrite <- carre_scalaire_distance. rewrite (difference_Pythagore A B C). rewrite (produit_scalaire_cosinus (A:=A) (B:=B) (C:=C) (a:=a)); auto. ring. Qed. Lemma triangles_isometriques : forall (A B C A' B' C' : PO) (x x' y y' : R), A <> B :>PO -> A <> C :>PO -> B <> C :>PO -> distance A' B' = distance A B -> distance A' C' = distance A C -> cons_AV (vec A B) (vec A C) = cons_AV (vec A' B') (vec A' C') :>AV -> image_angle x = cons_AV (vec B C) (vec B A) :>AV -> image_angle x' = cons_AV (vec B' C') (vec B' A') :>AV -> image_angle y = cons_AV (vec C A) (vec C B) :>AV -> image_angle y' = cons_AV (vec C' A') (vec C' B') :>AV -> distance B' C' = distance B C /\ cos x = cos x' /\ cos y = cos y'. intros. mesure A B A C. cut (A' <> B' /\ A' <> C'); intros. elim H10; intros H22 H23; try clear H10. cut (distance B' C' = distance B C); intros. cut (B' <> C'). intros H21. cut (2 <> 0). intros H24. split; [ try assumption | idtac ]. split; [ try assumption | idtac ]. cut (Rsqr (distance C A) = Rsqr (distance B C) + Rsqr (distance B A) + - (2 * (distance B C * (distance B A * cos x)))); intros. cut (Rsqr (distance C' A') = Rsqr (distance B' C') + Rsqr (distance B' A') + - (2 * (distance B' C' * (distance B' A' * cos x')))); intros. cut (2 * (distance B C * distance B A) * cos x = 2 * (distance B' C' * distance B' A') * cos x'); intros. apply resolution2 with (x := 2 * (distance B C * distance B A)) (y := 2 * (distance B' C' * distance B' A')); auto with geo real. rewrite (distance_sym B' A'); rewrite H10; rewrite H2; rewrite (distance_sym B A); ring. replace (2 * (distance B' C' * distance B' A') * cos x') with (Rsqr (distance B' C') + Rsqr (distance B' A') + - Rsqr (distance C' A')). replace (2 * (distance B C * distance B A) * cos x) with (Rsqr (distance B C) + Rsqr (distance B A) + - Rsqr (distance C A)). rewrite (distance_sym B' A'); rewrite (distance_sym C' A'); rewrite H10; rewrite H2; rewrite H3; rewrite (distance_sym B A); rewrite (distance_sym C A); ring. rewrite H11; ring. rewrite H12; ring. apply Al_Kashi; auto. apply Al_Kashi; auto. cut (Rsqr (distance A B) = Rsqr (distance C A) + Rsqr (distance C B) + - (2 * (distance C A * (distance C B * cos y)))); intros. cut (Rsqr (distance A' B') = Rsqr (distance C' A') + Rsqr (distance C' B') + - (2 * (distance C' A' * (distance C' B' * cos y')))); intros. cut (2 * (distance C A * distance C B) * cos y = 2 * (distance C' A' * distance C' B') * cos y'); intros. apply resolution2 with (x := 2 * (distance C A * distance C B)) (y := 2 * (distance C' A' * distance C' B')); auto with geo real. rewrite (distance_sym C' A'); rewrite H3; rewrite (distance_sym C' B'); rewrite H10; rewrite (distance_sym C B); rewrite (distance_sym C A); ring. replace (2 * (distance C A * distance C B) * cos y) with (Rsqr (distance C A) + Rsqr (distance C B) + - Rsqr (distance A B)). replace (2 * (distance C' A' * distance C' B') * cos y') with (Rsqr (distance C' A') + Rsqr (distance C' B') + - Rsqr (distance A' B')). rewrite (distance_sym C' B'); rewrite (distance_sym C' A'); rewrite H10; rewrite H2; rewrite H3; rewrite (distance_sym C B); rewrite (distance_sym C A); ring. rewrite H12; ring. rewrite H11; ring. apply Al_Kashi; auto. apply Al_Kashi; auto. discrR. apply dist_non_nulle; rewrite H10; auto with geo. apply distance_carre; auto. mesure A B A C. rewrite (Al_Kashi (A:=A') (B:=B') (C:=C') (a:=x0)); auto. rewrite (Al_Kashi (A:=A) (B:=B) (C:=C) (a:=x0)); auto. rewrite H2; rewrite H3; ring. rewrite H9; rewrite H4; auto. split; [ idtac | try assumption ]. apply dist_non_nulle; rewrite H2; auto with geo. apply dist_non_nulle; rewrite H3; auto with geo. Qed. Axiom angles_egaux_triangle : forall (A B C A' B' C' : PO) (x x' y y' : R), A <> B :>PO -> A <> C :>PO -> B <> C :>PO -> cons_AV (vec A B) (vec A C) = cons_AV (vec A' B') (vec A' C') :>AV -> image_angle x = cons_AV (vec B C) (vec B A) :>AV -> image_angle x' = cons_AV (vec B' C') (vec B' A') :>AV -> image_angle y = cons_AV (vec C A) (vec C B) :>AV -> image_angle y' = cons_AV (vec C' A') (vec C' B') :>AV -> cos x = cos x' -> cos y = cos y' -> cons_AV (vec B C) (vec B A) = cons_AV (vec B' C') (vec B' A') :>AV /\ cons_AV (vec C A) (vec C B) = cons_AV (vec C' A') (vec C' B') :>AV. Lemma cas_egalite_triangle : forall A B C A' B' C' : PO, A <> B :>PO -> A <> C :>PO -> B <> C :>PO -> distance A' B' = distance A B -> distance A' C' = distance A C -> cons_AV (vec A B) (vec A C) = cons_AV (vec A' B') (vec A' C') :>AV -> distance B' C' = distance B C /\ cons_AV (vec B C) (vec B A) = cons_AV (vec B' C') (vec B' A') :>AV /\ cons_AV (vec C A) (vec C B) = cons_AV (vec C' A') (vec C' B') :>AV. intros. cut (A' <> B' /\ A' <> C'); intros. elim H5; intros H6 H7; try clear H5; try exact H7. mesure A B A C. cut (distance B' C' = distance B C). intros H20. cut (B' <> C'). intros H21. mesure B C B A. mesure B' C' B' A'. mesure C A C B. mesure C' A' C' B'. rewrite H11; rewrite H10; rewrite H9; rewrite H8. elim triangles_isometriques with (A := A) (B := B) (C := C) (A' := A') (B' := B') (C' := C') (x := x0) (x' := x1) (y := x2) (y' := x3); [ intros; try exact H0 | auto | auto | auto | auto | auto | auto | auto | auto | auto | auto ]. split; [ try assumption | idtac ]. elim H13; intros H14 H15; try clear H13; try exact H15. apply angles_egaux_triangle with (9 := H14) (10 := H15); auto. apply dist_non_nulle; rewrite H20; auto with geo. cut (Rsqr (distance B' C') = Rsqr (distance B C)); intros. apply resolution; auto with geo real. rewrite (Al_Kashi (A:=A') (B:=B') (C:=C') (a:=x)); auto. rewrite (Al_Kashi (A:=A) (B:=B) (C:=C) (a:=x)); auto. rewrite H2; rewrite H3; ring. rewrite H5; rewrite H4; auto. split; [ idtac | try assumption ]. apply dist_non_nulle; rewrite H2; auto with geo. apply dist_non_nulle; rewrite H3; auto with geo. Qed. Lemma triangles_isometriques_indirects : forall (A B C A' B' C' : PO) (x x' y y' : R), A <> B :>PO -> A <> C :>PO -> B <> C :>PO -> distance A' B' = distance A B -> distance A' C' = distance A C -> cons_AV (vec A B) (vec A C) = cons_AV (vec A' C') (vec A' B') :>AV -> image_angle x = cons_AV (vec B C) (vec B A) :>AV -> image_angle x' = cons_AV (vec B' C') (vec B' A') :>AV -> image_angle y = cons_AV (vec C A) (vec C B) :>AV -> image_angle y' = cons_AV (vec C' A') (vec C' B') :>AV -> distance B' C' = distance B C /\ cos x = cos x' /\ cos y = cos y'. intros. mesure A B A C. cut (A' <> B' /\ A' <> C'); intros. elim H10; intros H22 H23; try clear H10. cut (distance B' C' = distance B C); intros. cut (B' <> C'). intros H21. cut (2 <> 0). intros H24. split; [ try assumption | idtac ]. split; [ try assumption | idtac ]. cut (Rsqr (distance C A) = Rsqr (distance B C) + Rsqr (distance B A) + - (2 * (distance B C * (distance B A * cos x)))); intros. cut (Rsqr (distance C' A') = Rsqr (distance B' C') + Rsqr (distance B' A') + - (2 * (distance B' C' * (distance B' A' * cos x')))); intros. cut (2 * (distance B C * distance B A) * cos x = 2 * (distance B' C' * distance B' A') * cos x'); intros. apply resolution2 with (x := 2 * (distance B C * distance B A)) (y := 2 * (distance B' C' * distance B' A')); auto with geo real. rewrite (distance_sym B' A'); rewrite H10; rewrite H2; rewrite (distance_sym B A); ring. replace (2 * (distance B' C' * distance B' A') * cos x') with (Rsqr (distance B' C') + Rsqr (distance B' A') + - Rsqr (distance C' A')). replace (2 * (distance B C * distance B A) * cos x) with (Rsqr (distance B C) + Rsqr (distance B A) + - Rsqr (distance C A)). rewrite (distance_sym B' A'); rewrite (distance_sym C' A'); rewrite H10; rewrite H2; rewrite H3; rewrite (distance_sym B A); rewrite (distance_sym C A); ring. rewrite H11; ring. rewrite H12; ring. apply Al_Kashi; auto. apply Al_Kashi; auto. cut (Rsqr (distance A B) = Rsqr (distance C A) + Rsqr (distance C B) + - (2 * (distance C A * (distance C B * cos y)))); intros. cut (Rsqr (distance A' B') = Rsqr (distance C' A') + Rsqr (distance C' B') + - (2 * (distance C' A' * (distance C' B' * cos y')))); intros. cut (2 * (distance C A * distance C B) * cos y = 2 * (distance C' A' * distance C' B') * cos y'); intros. apply resolution2 with (x := 2 * (distance C A * distance C B)) (y := 2 * (distance C' A' * distance C' B')); auto with geo real. rewrite (distance_sym C' A'); rewrite H3; rewrite (distance_sym C' B'); rewrite H10; rewrite (distance_sym C B); rewrite (distance_sym C A); ring. replace (2 * (distance C A * distance C B) * cos y) with (Rsqr (distance C A) + Rsqr (distance C B) + - Rsqr (distance A B)). replace (2 * (distance C' A' * distance C' B') * cos y') with (Rsqr (distance C' A') + Rsqr (distance C' B') + - Rsqr (distance A' B')). rewrite (distance_sym C' B'); rewrite (distance_sym C' A'); rewrite H10; rewrite H2; rewrite H3; rewrite (distance_sym C B); rewrite (distance_sym C A); ring. rewrite H12; ring. rewrite H11; ring. apply Al_Kashi; auto. apply Al_Kashi; auto. discrR. apply dist_non_nulle; rewrite H10; auto with geo. apply distance_carre. mesure A B A C. rewrite (Al_Kashi (A:=A) (B:=B) (C:=C) (a:=x1)); auto. rewrite (Al_Kashi (A:=A') (B:=B') (C:=C') (a:=- x1)); auto. rewrite H2; rewrite H3; rewrite cos_paire; ring. apply (mes_oppx (A:=A') (B:=C') (C:=A') (D:=B') (x:=x1)); auto. rewrite H10; rewrite H4; auto. split; [ idtac | try assumption ]. apply dist_non_nulle; rewrite H2; auto with geo. apply dist_non_nulle; rewrite H3; auto with geo. Qed. Axiom angles_egaux_triangle_indirect : forall (A B C A' B' C' : PO) (x x' y y' : R), A <> B :>PO -> A <> C :>PO -> B <> C :>PO -> cons_AV (vec A B) (vec A C) = cons_AV (vec A' C') (vec A' B') :>AV -> image_angle x = cons_AV (vec B C) (vec B A) :>AV -> image_angle x' = cons_AV (vec B' C') (vec B' A') :>AV -> image_angle y = cons_AV (vec C A) (vec C B) :>AV -> image_angle y' = cons_AV (vec C' A') (vec C' B') :>AV -> cos x = cos x' :>R -> cos y = cos y' :>R -> cons_AV (vec B C) (vec B A) = cons_AV (vec B' A') (vec B' C') :>AV /\ cons_AV (vec C A) (vec C B) = cons_AV (vec C' A') (vec C' B') :>AV. Lemma cas_egalite_triangle_indirect : forall A B C A' B' C' : PO, A <> B :>PO -> A <> C :>PO -> B <> C :>PO -> distance A' B' = distance A B :>R -> distance A' C' = distance A C :>R -> cons_AV (vec A B) (vec A C) = cons_AV (vec A' C') (vec A' B') :>AV -> distance B' C' = distance B C :>R /\ cons_AV (vec B C) (vec B A) = cons_AV (vec B' A') (vec B' C') :>AV /\ cons_AV (vec C A) (vec C B) = cons_AV (vec C' A') (vec C' B') :>AV. intros. cut (A' <> B' /\ A' <> C'); intros. elim H5; intros H6 H7; try clear H5; try exact H7. mesure A B A C. cut (distance B' C' = distance B C). intros H20. cut (B' <> C'). intros H21. mesure B C B A. mesure B' C' B' A'. mesure C A C B. mesure C' A' C' B'. rewrite H8; rewrite H10; rewrite H11. elim triangles_isometriques_indirects with (A := A) (B := B) (C := C) (A' := A') (B' := B') (C' := C') (x := x0) (x' := x1) (y := x2) (y' := x3); [ intros; try exact H0 | auto | auto | auto | auto | auto | auto | auto | auto | auto | auto ]. split; [ try assumption | idtac ]. elim H13; intros H14 H15; try clear H13; try exact H15. apply angles_egaux_triangle_indirect with (x := x0) (x' := x1) (y := x2) (y' := x3); auto. apply dist_non_nulle; rewrite H20; auto with geo. apply distance_carre. rewrite (Al_Kashi (A:=A) (B:=B) (C:=C) (a:=x)); auto. rewrite (Al_Kashi (A:=A') (B:=B') (C:=C') (a:=- x)); auto. rewrite H2; rewrite H3; rewrite cos_paire; ring. apply (mes_oppx (A:=A') (B:=C') (C:=A') (D:=B') (x:=x)); auto. rewrite H5; rewrite H4; auto. split; [ idtac | try assumption ]. apply dist_non_nulle; rewrite H2; auto with geo. apply dist_non_nulle; rewrite H3; auto with geo. Qed. HighSchoolGeometry/milieu.v0000644000076500007650000002247212073525612015706 0ustar coqcoq00000000000000(* This program is free software; you can redistribute it and/or *) (* modify it under the terms of the GNU Lesser General Public License *) (* as published by the Free Software Foundation; either version 2.1 *) (* of the License, or (at your option) any later version. *) (* *) (* This program is distributed in the hope that it will be useful, *) (* but WITHOUT ANY WARRANTY; without even the implied warranty of *) (* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *) (* GNU General Public License for more details. *) (* *) (* You should have received a copy of the GNU Lesser General Public *) (* License along with this program; if not, write to the Free *) (* Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA *) (* 02110-1301 USA *) Require Export barycentre. Set Implicit Arguments. Unset Strict Implicit. Definition milieu (A B : PO) := barycentre (cons 1 A) (cons 1 B). Hint Unfold milieu: geo. Lemma milieu_permute : forall A B I : PO, I = milieu A B :>PO -> I = milieu B A :>PO. unfold milieu in |- *; intros. rewrite permute_barycentre; auto. discrR. Qed. Lemma add_PP_milieu : forall A B : PO, add_PP (cons 1 A) (cons 1 B) = cons 2 (milieu A B) :>PP. unfold milieu in |- *; intros. repeat rewrite <- add_PP_barycentre; auto. discrR. Qed. Lemma milieu_trivial : forall A : PO, A = milieu A A :>PO. intros. apply conversion_PP with (a := 2) (b := 2); auto. rewrite <- add_PP_milieu; RingPP. discrR. Qed. Lemma prop_vecteur_milieu : forall B C A' O : PO, A' = milieu B C :>PO -> add_PP (vec O B) (vec O C) = mult_PP 2 (vec O A'). unfold milieu in |- *; intros. generalize (prop_vecteur_bary (a:=1) (b:=1) (A:=B) (B:=C) (G:=A') O); intros H5. rewrite <- (prop_vecteur_bary (a:=1) (b:=1) (A:=B) (B:=C) (G:=A') O); auto. Ringvec. discrR. Qed. Lemma alignes_milieu : forall A B I : PO, I = milieu A B :>PO -> alignes A B I. unfold milieu in |- *; intros. rewrite H. apply barycentre_alignes. discrR. Qed. Lemma add_PP_milieu_asso : forall A B C : PO, add_PP (cons 1 A) (cons 2 (milieu B C)) = add_PP (cons 2 (milieu A B)) (cons 1 C) :>PP. intros A B C; try assumption. repeat rewrite <- add_PP_milieu; try discrR; auto. RingPP. Qed. Lemma vecteur_milieu : forall A B M : PO, vec A M = mult_PP (/ 2) (vec A B) :>PP -> M = milieu A B :>PO. intros; unfold milieu in |- *. rewrite (colineaire_barycentre (k:=/ 2) (A:=A) (B:=B) (C:=M)); auto. cut (1 + - / 2 = / 2); intros; auto with real. rewrite H0. RReplace (/ 2) (/ 2 * 1). apply homogene_barycentre; auto with real. Qed. Lemma milieu_vecteur2 : forall A B M : PO, M = milieu A B :>PO -> vec A M = mult_PP (/ 2) (vec A B) :>PP. intros; unfold vec in |- *. cut (2 <> 0); intros; auto with real. apply mult_PP_regulier with 2; auto. replace (mult_PP 2 (add_PP (cons (-1) A) (cons 1 M))) with (add_PP (cons (-2) A) (cons 2 M)). rewrite H; rewrite <- add_PP_milieu. FieldPP 2. RingPP. Qed. Lemma milieu_vecteur : forall A B M : PO, M = milieu A B :>PO -> vec A M = vec M B. intros. rewrite H. apply mult_PP_regulier with 2; auto with real. VReplace (mult_PP 2 (vec A (milieu A B))) (add_PP (cons (-2) A) (cons 2 (milieu A B))). VReplace (mult_PP 2 (vec (milieu A B) B)) (mult_PP (-1) (add_PP (cons 2 (milieu A B)) (cons (-2) B))). rewrite <- add_PP_milieu; RingPP. Qed. Lemma milieu_vecteur_double : forall A B M : PO, M = milieu A B :>PO -> vec A B = mult_PP 2 (vec A M) :>PP. intros. VReplace (vec A B) (add_PP (vec A M) (vec M B)). rewrite <- (milieu_vecteur (A:=A) (B:=B) (M:=M)); auto. Ringvec. Qed. Lemma egalite_vecteur_milieu : forall A B M : PO, vec A M = vec M B -> M = milieu A B. unfold milieu in |- *; intros. apply def_vecteur_bary_rec; auto with real. rewrite <- H; Ringvec. Qed. Hint Resolve milieu_vecteur milieu_vecteur_double milieu_vecteur2 vecteur_milieu alignes_milieu milieu_trivial milieu_permute egalite_vecteur_milieu: geo. Lemma triangle_milieu_distinct : forall A B C : PO, ~ alignes B C A -> A <> milieu B C :>PO. intros. contrapose H. auto with geo. Qed. Lemma milieu_distinct : forall A B : PO, A <> B :>PO -> A <> milieu A B :>PO. intros A B H; try assumption. apply distinct_produit_vecteur with (B := B) (a := / 2); auto with real. rewrite <- (milieu_vecteur2 (A:=A) (B:=B) (M:=milieu A B)); auto. Qed. Lemma milieu_distinct2 : forall A B : PO, A <> B :>PO -> B <> milieu A B :>PO. intros A B H; try assumption. apply distinct_produit_vecteur with (B := A) (a := / 2); auto with real. cut (vec (milieu A B) B = mult_PP (/ 2) (vec A B)); intros. VReplace (vec B (milieu A B)) (mult_PP (-1) (vec (milieu A B) B)). rewrite H0. cut (2 <> 0); intros; auto with real. Fieldvec 2. rewrite <- (milieu_vecteur (A:=A) (B:=B) (M:=milieu A B)); auto. rewrite <- (milieu_vecteur2 (A:=A) (B:=B) (M:=milieu A B)); auto. Qed. Hint Resolve triangle_milieu_distinct milieu_distinct milieu_distinct2: geo. Lemma existence_milieu : forall A B : PO, ex (fun I : PO => I = milieu A B :>PO). intros. exists (milieu A B); auto. Qed. Comments "soit_milieu" "pose" "I" "milieu" "de" "AB" "et" "echoue" "si" "A=B" "et" "ajoute" "des" "hypotheses". Ltac soit_milieu A B I := elim (existence_milieu A B); intros I; intros; lapply (milieu_distinct (A:=A) (B:=B)); try assumption; match goal with | h:(I = milieu A B) |- _ => rewrite <- h; intros; lapply (milieu_distinct2 (A:=A) (B:=B)); try assumption; rewrite <- h; intros end. Lemma droite_milieu : forall A B C I J : PO, I = milieu A B -> J = milieu A C -> mult_PP 2 (vec I J) = vec B C. intros. rewrite H0; rewrite H. VReplace (mult_PP 2 (vec (milieu A B) (milieu A C))) (add_PP (mult_PP (-1) (cons 2 (milieu A B))) (cons 2 (milieu A C))). repeat rewrite <- add_PP_milieu. Ringvec. Qed. Lemma deux_milieux_distincts : forall A B C I J : PO, A <> C :>PO -> I = milieu A B :>PO -> J = milieu B C :>PO -> I <> J :>PO. intros. lapply (droite_milieu (A:=B) (B:=A) (C:=C) (I:=I) (J:=J)); auto with geo; intros. contrapose H. apply vecteur_nul_conf. rewrite <- H2; auto. rewrite <- H3; Ringvec. Qed. Lemma triangle_triangle_milieux : forall A B C A' B' C' : PO, triangle A B C -> A' = milieu B C :>PO -> B' = milieu A C :>PO -> C' = milieu A B :>PO -> triangle A' B' C'. intros. deroule_triangle A B C. red in |- *; intros; apply H3. assert (A' <> B'). apply (deux_milieux_distincts (A:=B) (B:=C) (C:=A)); auto with geo. halignes H7 ipattern:k. apply colineaire_alignes with k; auto. rewrite <- (droite_milieu (A:=B) (B:=A) (C:=C) (I:=C') (J:=A')); auto with geo. rewrite <- (droite_milieu (A:=C) (B:=A) (C:=B) (I:=B') (J:=A')); auto with geo. VReplace (vec C' A') (mult_PP (-1) (vec A' C')). rewrite H9; Ringvec. Qed. Lemma add_PP_milieu_permute : forall A B C : PO, add_PP (cons 1 A) (cons 2 (milieu B C)) = add_PP (cons 2 (milieu A C)) (cons 1 B) :>PP. intros A B C; try assumption. repeat rewrite <- add_PP_milieu; auto. Ringvec. Qed. Definition centre_gravite (A B C : PO) := barycentre (cons 1 A) (cons 2 (milieu B C)). Lemma centre_gravite_ordre_cycle : forall A B C : PO, centre_gravite A B C = centre_gravite B C A :>PO. unfold centre_gravite in |- *; intros. generalize (add_PP_milieu_permute A B C); intros. apply conversion_PP with (a := 3) (b := 3); auto with *. rewrite <- add_PP_barycentre; try discrR; auto with *. rewrite <- add_PP_barycentre; try discrR; auto with *. rewrite H. rewrite (milieu_permute (A:=A) (B:=C) (I:=milieu A C)); auto. Ringvec. Qed. Lemma centre_gravite_ordre_cycle2 : forall A B C : PO, centre_gravite A B C = centre_gravite C A B :>PO. unfold centre_gravite in |- *; intros. generalize (add_PP_milieu_asso A B C); intros. apply conversion_PP with (a := 3) (b := 3); auto with *. rewrite <- add_PP_barycentre; try discrR; auto with *. rewrite <- add_PP_barycentre; try discrR; auto with *. rewrite H. RingPP. Qed. Lemma centre_gravite_ordre_permute : forall A B C : PO, centre_gravite A B C = centre_gravite A C B :>PO. unfold centre_gravite in |- *; intros. rewrite (milieu_permute (A:=C) (B:=B) (I:=milieu C B)); auto. Qed. Hint Resolve centre_gravite_ordre_permute centre_gravite_ordre_cycle2 centre_gravite_ordre_cycle: geo. Lemma triangle_medianes_triangle : forall A B C I J : PO, triangle A B C -> I = milieu B C :>PO -> J = milieu A B :>PO -> ~ alignes A I J. intros. deroule_triangle A B C. red in |- *; intros; apply H2. cut (A <> J); intros. halignes H6 ipattern:k. cut (k <> 0); intros. apply colineaire_alignes with ((1 + - k) * / k). replace (vec A C) with (mult_PP 2 (vec J I)). replace (vec A B) with (mult_PP 2 (vec A J)). VReplace (vec J I) (add_PP (vec A I) (mult_PP (-1) (vec A J))). rewrite H8. Fieldvec k. rewrite (milieu_vecteur_double (A:=A) (B:=B) (M:=J)); auto with geo. rewrite (droite_milieu (A:=B) (B:=A) (C:=C) (I:=J) (J:=I)); auto with geo. apply distinct_col_nonzero with (2 := H8); auto. rewrite H1; apply milieu_distinct; auto. Qed. Lemma centre_gravite_mediane_vecteur : forall A B C I G : PO, I = milieu B C :>PO -> G = centre_gravite A B C :>PO -> vec A G = mult_PP (/ 3) (mult_PP 2 (vec A I)) :>PP. unfold centre_gravite in |- *; intros. rewrite <- H in H0. cut (3 <> 0); intros; auto with real. apply mult_PP_regulier with 3; auto. rewrite <- (prop_vecteur_bary (a:=1) (b:=2) (A:=A) (B:=I) (G:=G) A); auto. Fieldvec 3. Qed.HighSchoolGeometry/operations_complexes.v0000644000076500007650000005407512117747636020703 0ustar coqcoq00000000000000(* This program is free software; you can redistribute it and/or *) (* modify it under the terms of the GNU Lesser General Public License *) (* as published by the Free Software Foundation; either version 2.1 *) (* of the License, or (at your option) any later version. *) (* *) (* This program is distributed in the hope that it will be useful, *) (* but WITHOUT ANY WARRANTY; without even the implied warranty of *) (* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *) (* GNU General Public License for more details. *) (* *) (* You should have received a copy of the GNU Lesser General Public *) (* License along with this program; if not, write to the Free *) (* Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA *) (* 02110-1301 USA *) Require Export formes_complexes. Set Implicit Arguments. Unset Strict Implicit. Lemma Rinv_calcul : forall x y : R, x <> 0 :>R -> x * y = 1 :>R -> / x = y :>R. intros. apply Rmult_eq_reg_l with x; auto. rewrite H0; auto with real. Qed. Hint Resolve Rinv_calcul: real. Parameter Cplus : C -> C -> C. Axiom Cplus_def : forall (z1 z2 : C) (x1 y1 x2 y2 : R), z1 = cons_cart x1 y1 -> z2 = cons_cart x2 y2 -> Cplus z1 z2 = cons_cart (x1 + x2) (y1 + y2). Lemma Cplus_algebrique : forall x1 y1 x2 y2 : R, Cplus (cons_cart x1 y1) (cons_cart x2 y2) = cons_cart (x1 + x2) (y1 + y2). intros. rewrite (Cplus_def (z1:=cons_cart x1 y1) (z2:=cons_cart x2 y2) (x1:=x1) (y1:=y1) (x2:=x2) (y2:=y2)); auto. Qed. Hint Resolve Cplus_algebrique: geo. Lemma Cplus_commutative : forall z1 z2 : C, Cplus z1 z2 = Cplus z2 z1. intros. elim existence_parties_relles_imaginaires with (z := z1); intros x1 H; elim H; intros y1 H0; try clear H; try exact H0. elim existence_parties_relles_imaginaires with (z := z2); intros x2 H; elim H; intros y2 H1; try clear H; try exact H1. rewrite (Cplus_def (z1:=z1) (z2:=z2) (x1:=x1) (y1:=y1) (x2:=x2) (y2:=y2)); auto. rewrite (Cplus_def (z1:=z2) (z2:=z1) (x1:=x2) (y1:=y2) (x2:=x1) (y2:=y1)); auto. replace (x1 + x2) with (x2 + x1); [ idtac | ring ]. replace (y1 + y2) with (y2 + y1); [ auto | ring ]. Qed. Lemma Cplus_z_zeroC : forall z : C, Cplus z zeroC = z. intros. elim existence_parties_relles_imaginaires with (z := z); intros x1 H; elim H; intros y1 H0; try clear H; try exact H0. rewrite (Cplus_def (z1:=z) (z2:=zeroC) (x1:=x1) (y1:=y1) (x2:=0) (y2:=0)); auto. replace (x1 + 0) with x1; [ idtac | ring ]. replace (y1 + 0) with y1; [ auto | ring ]. Qed. Lemma Cplus_associative : forall z1 z2 z3 : C, Cplus z1 (Cplus z2 z3) = Cplus (Cplus z1 z2) z3. intros. elim existence_parties_relles_imaginaires with (z := z1); intros x1 H; elim H; intros y1 H0; try clear H; try exact H0. elim existence_parties_relles_imaginaires with (z := z2); intros x2 H; elim H; intros y2 H1; try clear H; try exact H1. elim existence_parties_relles_imaginaires with (z := z3); intros x3 H; elim H; intros y3 H2; try clear H; try exact H2. rewrite (Cplus_def (z1:=z1) (z2:=z2) (x1:=x1) (y1:=y1) (x2:=x2) (y2:=y2)); auto. rewrite (Cplus_def (z1:=cons_cart (x1 + x2) (y1 + y2)) (z2:=z3) (x1:= x1 + x2) (y1:=y1 + y2) (x2:=x3) (y2:=y3)); auto. rewrite (Cplus_def (z1:=z2) (z2:=z3) (x1:=x2) (y1:=y2) (x2:=x3) (y2:=y3)); auto. rewrite (Cplus_def (z1:=z1) (z2:=cons_cart (x2 + x3) (y2 + y3)) (x1:=x1) (y1:=y1) (x2:=x2 + x3) (y2:=y2 + y3)); auto. replace (x1 + (x2 + x3)) with (x1 + x2 + x3); [ idtac | ring ]. replace (y1 + (y2 + y3)) with (y1 + y2 + y3); [ auto | ring ]. Qed. Parameter Copp : C -> C. Definition Cminus x y := Cplus x (Copp y). Axiom Copp_def : forall (z : C) (x y : R), z = cons_cart x y -> Copp z = cons_cart (- x) (- y). Lemma Copp_algebrique : forall x y : R, Copp (cons_cart x y) = cons_cart (- x) (- y). intros. rewrite (Copp_def (z:=cons_cart x y) (x:=x) (y:=y)); auto. Qed. Lemma Cplus_z_oppz : forall z : C, Cplus z (Copp z) = zeroC. intros. elim existence_parties_relles_imaginaires with (z := z); intros x1 H; elim H; intros y1 H0; try clear H; try exact H0. unfold zeroC in |- *; rewrite H0; rewrite Copp_algebrique; rewrite Cplus_algebrique. replace (x1 + - x1) with 0; [ idtac | ring ]. replace (y1 + - y1) with 0; [ auto | ring ]. Qed. Hint Resolve Cplus_z_oppz Copp_algebrique Cplus_commutative Cplus_z_zeroC: geo. Parameter Cmult : C -> C -> C. Axiom Cmult_module : forall z z' : C, module (Cmult z z') = module z * module z'. Axiom Cmult_argument : forall z z' : C, z <> zeroC -> z' <> zeroC -> argument (Cmult z z') = plus (argument z) (argument z'). Lemma Cmult_zeroC_z : forall z : C, Cmult zeroC z = zeroC. intros. apply module_nul_zeroC. rewrite Cmult_module; rewrite module_zeroC; ring. Qed. Lemma Cmult_z_zeroC : forall z : C, Cmult z zeroC = zeroC. intros. apply module_nul_zeroC. rewrite Cmult_module; rewrite module_zeroC; ring. Qed. Lemma nonzero_produit : forall z z' : C, z <> zeroC -> z' <> zeroC -> Cmult z z' <> zeroC. intros. apply nonzero_module. rewrite Cmult_module. apply Rmult_integral_contrapositive. split; auto with geo. Qed. Hint Resolve Cmult_module Cmult_argument nonzero_produit Cmult_z_zeroC Cmult_zeroC_z: geo. Lemma Cmult_z_z' : forall (z z' : C) (r a r' a' : R), z <> zeroC -> z' <> zeroC -> z = cons_pol r a -> z' = cons_pol r' a' -> Cmult z z' = cons_pol (r * r') (a + a'). intros. apply forme_polaire_def; auto with geo. rewrite Cmult_module. rewrite (complexe_pol_module (z:=z) (r:=r) (a:=a)); auto with geo. rewrite (complexe_pol_module (z:=z') (r:=r') (a:=a')); auto with geo. rewrite Cmult_argument; auto with geo. rewrite (complexe_pol_argument (z:=z) (r:=r) (a:=a)); auto with geo. rewrite (complexe_pol_argument (z:=z') (r:=r') (a:=a')); auto with geo. Qed. Hint Resolve Cmult_z_z': geo. Lemma Cmult_commutative : forall z z' : C, Cmult z z' = Cmult z' z. intros. elim (classic (z = zeroC)); intros. rewrite H; rewrite Cmult_zeroC_z; rewrite Cmult_z_zeroC; auto. elim (classic (z' = zeroC)); intros. rewrite H0; rewrite Cmult_zeroC_z; rewrite Cmult_z_zeroC; auto. elim existence_forme_polaire with (z := z); [ intros r H1; elim H1; intros a H2; elim H2; intros H3 H4; try clear H2 H1 existence_forme_polaire; try exact H3 | auto with geo ]. elim existence_forme_polaire with (z := z'); [ intros r' H5; elim H5; intros a' H6; elim H6; intros H7 H8; try clear H6 H5 existence_forme_polaire; try exact H7 | auto with geo ]. rewrite (Cmult_z_z' (z:=z) (z':=z') (r:=r) (a:=a) (r':=r') (a':=a')); auto with geo. rewrite (Cmult_z_z' (z:=z') (z':=z) (r:=r') (a:=a') (r':=r) (a':=a)); auto with geo. replace (r * r') with (r' * r); [ idtac | ring ]. replace (a + a') with (a' + a); [ auto | ring ]. Qed. Lemma Cmult_associative : forall z1 z2 z3 : C, Cmult z1 (Cmult z2 z3) = Cmult (Cmult z1 z2) z3. intros. elim (classic (z1 = zeroC)); intros. rewrite H. repeat rewrite Cmult_zeroC_z; auto. elim (classic (z2 = zeroC)); intros. rewrite H0. repeat rewrite Cmult_zeroC_z; repeat rewrite Cmult_z_zeroC; repeat rewrite Cmult_zeroC_z; auto. elim (classic (z3 = zeroC)); intros. rewrite H1. repeat rewrite Cmult_z_zeroC; auto. apply egalite_forme_polaire. apply nonzero_produit; auto with geo. apply nonzero_produit; auto with geo. repeat rewrite Cmult_module; ring. repeat rewrite Cmult_argument; auto with geo. elim existence_argument with (z := z1); [ intros a H2; try clear existence_argument; try exact H2 | auto with geo ]. elim existence_argument with (z := z2); [ intros a0 H3; try clear existence_argument; try exact H3 | auto with geo ]. elim existence_argument with (z := z3); [ intros a1 H4; try clear existence_argument; try exact H4 | auto with geo ]. rewrite H2; rewrite H3; rewrite H4. repeat rewrite <- add_mes_compatible. replace (a + (a0 + a1)) with (a + a0 + a1); [ auto | ring ]. Qed. Lemma Cmult_z_oneC : forall z : C, Cmult z oneC = z. intros. elim (classic (z = zeroC)); intros. rewrite H. repeat rewrite Cmult_zeroC_z; auto with geo. apply egalite_forme_polaire; auto with geo. rewrite Cmult_module; rewrite module_oneC; ring. repeat rewrite Cmult_argument; auto with geo. rewrite argument_oneC; auto with geo. Qed. Definition Csqr (z : C) := Cmult z z. Hint Unfold Csqr: geo. Lemma i_carre : Csqr i = Rinj (-1). unfold Csqr in |- *. apply egalite_forme_polaire; auto with geo. rewrite Cmult_module; rewrite module_opp_un; rewrite module_i; ring. repeat rewrite Cmult_argument; auto with geo. rewrite argument_opp_un; rewrite argument_i. rewrite <- add_mes_compatible; auto. Qed. Theorem Cmult_algebrique : forall x1 y1 x2 y2 : R, Cmult (cons_cart x1 y1) (cons_cart x2 y2) = cons_cart (x1 * x2 + - (y1 * y2)) (y1 * x2 + x1 * y2). intros. elim (classic (cons_cart x1 y1 = zeroC)); intros. elim algebrique_zeroC with (a := x1) (b := y1); [ intros; try exact H1 | auto ]. rewrite H1; rewrite H0. replace (0 * x2 + - (0 * y2)) with 0; [ idtac | ring ]. replace (0 * x2 + 0 * y2) with 0; [ idtac | ring ]. repeat rewrite Cmult_zeroC_z; auto. elim (classic (cons_cart x2 y2 = zeroC)); intros. elim algebrique_zeroC with (a := x2) (b := y2); [ intros; try exact H1 | auto ]. rewrite H1; rewrite H2. replace (x1 * 0 + - (y1 * 0)) with 0; [ idtac | ring ]. replace (y1 * 0 + x1 * 0) with 0; [ idtac | ring ]. repeat rewrite Cmult_z_zeroC; auto. elim existence_forme_polaire with (z := cons_cart x1 y1); [ intros r1 H1; elim H1; intros a1 H2; elim H2; intros H3 H4; try clear H2 H1; try exact H4 | auto with geo ]. elim existence_forme_polaire with (z := cons_cart x2 y2); [ intros r2 H1; elim H1; intros a2 H2; elim H2; intros H5 H6; try clear H2 H1; try exact H6 | auto with geo ]. generalize (Cmult_module (cons_cart x1 y1) (cons_cart x2 y2)); intros. rewrite H5 in H1; rewrite H3 in H1. lapply (Cmult_argument (z:=cons_cart x1 y1) (z':=cons_cart x2 y2)); intros; auto with geo. rewrite H4 in H2; rewrite H6 in H2. cut (Cmult (cons_cart x1 y1) (cons_cart x2 y2) = cons_pol (r1 * r2) (a1 + a2)); intros. rewrite (polaire_calcul_algebrique (z:=Cmult (cons_cart x1 y1) (cons_cart x2 y2)) (r:=r1 * r2) (a:=a1 + a2)); auto with geo. elim passage_polaire_algebrique with (z := cons_cart x1 y1) (r := r1) (a := a1) (x := x1) (y := y1); [ intros; try exact H8 | auto with geo | auto with geo | auto with geo ]. rewrite H8; rewrite H9. elim passage_polaire_algebrique with (z := cons_cart x2 y2) (r := r2) (a := a2) (x := x2) (y := y2); [ intros | auto with geo | auto with geo | auto with geo ]. rewrite H10; rewrite H11. rewrite cos_som; rewrite sin_som. replace (r1 * r2 * (cos a1 * cos a2 + - (sin a1 * sin a2))) with (r1 * cos a1 * (r2 * cos a2) + - (r1 * sin a1 * (r2 * sin a2))); [ idtac | ring ]. replace (r1 * r2 * (sin a1 * cos a2 + sin a2 * cos a1)) with (r1 * sin a1 * (r2 * cos a2) + r1 * cos a1 * (r2 * sin a2)); [ auto | ring ]. apply forme_polaire_def; auto with geo. rewrite H2; auto. rewrite <- add_mes_compatible; auto. Qed. Hint Resolve Cmult_algebrique: geo. Theorem Cmult_distributive : forall z1 z2 z3 : C, Cmult z1 (Cplus z2 z3) = Cplus (Cmult z1 z2) (Cmult z1 z3). intros. elim existence_parties_relles_imaginaires with (z := z1); intros a1 H; elim H; intros b1 H0; try clear H; try exact H0. elim existence_parties_relles_imaginaires with (z := z2); intros a2 H; elim H; intros b2 H1; try clear H; try exact H1. elim existence_parties_relles_imaginaires with (z := z3); intros a3 H; elim H; intros b3 H2; try clear H; try exact H2. rewrite H2; rewrite H1; rewrite H0. repeat rewrite Cmult_algebrique; repeat rewrite Cplus_algebrique; repeat rewrite Cmult_algebrique. replace (a1 * (a2 + a3) + - (b1 * (b2 + b3))) with (a1 * a2 + - (b1 * b2) + (a1 * a3 + - (b1 * b3))); [ idtac | ring ]. replace (b1 * (a2 + a3) + a1 * (b2 + b3)) with (b1 * a2 + a1 * b2 + (b1 * a3 + a1 * b3)); [ auto | ring ]. Qed. Lemma Cplus_zeroC_z : forall z : C, Cplus zeroC z = z. intros. rewrite Cplus_commutative; auto with geo. Qed. Hint Resolve Cmult_z_oneC: geo. Lemma Cmult_oneC_z : forall z : C, Cmult oneC z = z. intros. rewrite Cmult_commutative; auto with geo. Qed. Lemma Cmult_distributive_r : forall z1 z2 z3 : C, Cmult (Cplus z1 z2) z3 = Cplus (Cmult z1 z3) (Cmult z2 z3). intros. rewrite Cmult_commutative; rewrite Cmult_distributive. rewrite Cmult_commutative; rewrite (Cmult_commutative z3 z2); auto with geo. Qed. Lemma CTheory : ring_theory zeroC oneC Cplus Cmult Cminus Copp (eq(A:=C)). split. exact Cplus_zeroC_z. exact Cplus_commutative. exact Cplus_associative. exact Cmult_oneC_z. exact Cmult_commutative. exact Cmult_associative. exact Cmult_distributive_r. reflexivity. exact Cplus_z_oppz. Defined. Add Ring Cring : CTheory. Lemma algebrique_operations : forall x y : R, cons_cart x y = Cplus (Rinj x) (Cmult i (Rinj y)). unfold i in |- *; unfold Rinj in |- *; intros. rewrite Cmult_algebrique; rewrite Cplus_algebrique. replace (x + (0 * y + - (1 * 0))) with x; [ idtac | ring ]. replace (0 + (1 * y + 0 * 0)) with y; [ auto | ring ]. Qed. Lemma existence_inverse : forall z : C, z <> zeroC -> exists z' : C, Cmult z z' = oneC. intros. elim existence_forme_polaire with (z := z); [ intros r H1; elim H1; intros a H2; elim H2; intros H3 H4; try clear H2 H1; try exact H3 | auto with geo ]. cut (r <> 0); intros. cut (/ r <> 0); intros; auto with real. cut (cons_pol (/ r) (- a) <> zeroC); intros. exists (cons_pol (/ r) (- a)). apply egalite_forme_polaire; auto with geo. rewrite Cmult_module; rewrite module_oneC; rewrite complexe_polaire_module; rewrite H3; field; trivial. rewrite Cmult_argument; auto with geo. rewrite complexe_polaire_argument; auto with geo. rewrite H4; rewrite argument_oneC. rewrite <- add_mes_compatible. replace (a + - a) with 0; [ auto | ring ]. auto with real geo. rewrite <- H3; auto with geo. Qed. Lemma unicite_inverse : forall z z1 z2 : C, z <> zeroC -> Cmult z z1 = oneC -> Cmult z z2 = oneC -> z1 = z2. intros. cut (module z * module z1 = 1); intros. cut (module z * module z2 = 1); intros. cut (module z <> 0); intros; auto with geo. cut (module z1 <> 0); intros. cut (module z2 <> 0); intros. cut (z1 <> zeroC); intros; auto with geo. cut (z2 <> zeroC); intros; auto with geo. apply egalite_forme_polaire; auto with geo. replace (module z1) with (/ module z); auto with real. auto with real. cut (plus (argument z) (argument z1) = image_angle 0); intros. cut (plus (argument z) (argument z2) = image_angle 0); intros. rewrite (opp_angle (a:=argument z) (b:=argument z1)); auto. rewrite (opp_angle (a:=argument z) (b:=argument z2)); auto. rewrite <- Cmult_argument; auto with geo. rewrite H1; rewrite <- argument_oneC; auto. rewrite <- Cmult_argument; auto with geo. rewrite H0; rewrite <- argument_oneC; auto. cut (module z * module z2 <> 0); intros. red in |- *; intros; apply H6. rewrite H7; ring. rewrite H3; discrR. cut (module z * module z1 <> 0); intros. red in |- *; intros; apply H5. rewrite H6; ring. rewrite H2; discrR. rewrite <- Cmult_module; rewrite H1; rewrite <- module_oneC; auto. rewrite <- Cmult_module; rewrite H0; rewrite <- module_oneC; auto. Qed. Parameter Cinv : C -> C. Axiom Cinv_def : forall z : C, z <> zeroC -> Cmult z (Cinv z) = oneC. Axiom Cinv_def2 : forall z z' : C, z <> zeroC -> Cmult z z' = oneC -> Cinv z = z'. Lemma Cinv_l : forall z : C, z <> zeroC -> Cmult (Cinv z) z = oneC. intros. rewrite <- (Cinv_def (z:=z)); auto. ring. Qed. Hint Resolve Cinv_def Cinv_def2 Cinv_l: geo. Lemma Cinv_module : forall z : C, z <> zeroC -> module (Cinv z) = / module z. intros. cut (module z * module (Cinv z) = 1); intros. cut (module z <> 0); intros; auto with geo. apply Rmult_eq_reg_l with (module z); auto. rewrite H0; auto with real. rewrite <- Cmult_module; rewrite Cinv_def; auto with geo. Qed. Hint Resolve Cinv_module: geo. Lemma inv_nonzero : forall z : C, z <> zeroC -> Cinv z <> zeroC. intros. apply nonzero_module. rewrite Cinv_module; auto with geo. cut (module z <> 0); intros; auto with geo. auto with real. Qed. Hint Resolve inv_nonzero: geo. Lemma Cinv_argument : forall z : C, z <> zeroC -> argument (Cinv z) = opp (argument z). intros. cut (Cinv z <> zeroC); intros; auto with geo. cut (plus (argument z) (argument (Cinv z)) = image_angle 0); intros. apply opp_angle; auto. rewrite <- argument_oneC. rewrite <- Cmult_argument; auto with geo. rewrite Cinv_def; auto with geo. Qed. Hint Resolve Cinv_argument: geo. Parameter Cdiv : C -> C -> C. Axiom Cdiv_def : forall z z' : C, z' <> zeroC -> Cdiv z z' = Cmult z (Cinv z'). Lemma Cdiv_module : forall z z' : C, z' <> zeroC -> module (Cdiv z z') = module z * / module z'. intros. rewrite Cdiv_def; auto with geo. rewrite Cmult_module; rewrite Cinv_module; auto. Qed. Hint Resolve Cdiv_module: geo. Lemma Cdiv_argument : forall z z' : C, z <> zeroC -> z' <> zeroC -> argument (Cdiv z z') = plus (argument z) (opp (argument z')). intros. rewrite Cdiv_def; auto with geo. rewrite Cmult_argument; auto with geo. rewrite Cinv_argument; auto with geo. Qed. Hint Resolve Cdiv_argument: geo. Lemma Cintegre : forall z z' : C, z <> zeroC -> Cmult z z' = zeroC -> z' = zeroC. intros. replace z' with (Cmult (Cmult (Cinv z) z) z') by (rewrite Cinv_l; trivial; ring). replace (Cmult (Cmult (Cinv z) z) z') with (Cmult (Cinv z) (Cmult z z')) by ring. rewrite H0; ring. Qed. Lemma module_un_nonzero : forall a : R, cons_pol 1 a <> zeroC. intros. apply polaire_non_nul; try discrR. Qed. Hint Resolve module_un_nonzero: geo. Lemma module_un_trivial : forall a : R, module (cons_pol 1 a) = 1. intros; auto with geo. Qed. Lemma argument_module_un : forall a : R, argument (cons_pol 1 a) = image_angle a. intros. rewrite (complexe_polaire_argument (r:=1) a); intros; auto with geo. discrR. Qed. Lemma polaire_produit : forall r a : R, r <> 0 -> cons_pol r a = Cmult (Rinj r) (cons_pol 1 a). intros. apply egalite_forme_polaire; auto with geo. rewrite Cmult_module; rewrite module_un_trivial; rewrite module_reel; ring_simplify. pattern r at 2 in |- *. rewrite <- (complexe_polaire_module r a); auto with geo. rewrite Cmult_argument; auto with geo. rewrite argument_module_un. rewrite argument_reel_pos; auto with geo. rewrite complexe_polaire_argument; auto with geo. rewrite plus_commutative; auto with geo. cut (r >= 0); intros. change (r > 0) in |- *. elim H0; intros; auto. absurd (r = 0); auto. rewrite <- (complexe_polaire_module r a); auto with geo. Qed. Lemma affixe_vec_AB : forall (a b : C) (A B : PO), a = affixe A -> b = affixe B -> Cplus b (Copp a) = affixe_vec (vec A B). intros. elim existence_parties_relles_imaginaires with (z := a); intros a1 H2; elim H2; intros a2 H3; try clear H2; try exact H3. elim existence_parties_relles_imaginaires with (z := b); intros b1 H4; elim H4; intros b2 H5; try clear H4; try exact H5. elim cartvec_AB with (a1 := a1) (a2 := a2) (b1 := b1) (b2 := b2) (O := O) (I := I) (J := J) (A := A) (B := B); [ intros H1 H2; try clear cartvec_AB; try exact H2 | eauto with geo | eauto with geo | eauto with geo | eauto with geo | eauto with geo ]. rewrite H5; rewrite H3; rewrite Copp_algebrique; rewrite Cplus_algebrique. rewrite (absvec_ordvec_affixe (a:=b1 + - a1) (b:=b2 + - a2) (A:=A) (B:=B)); auto. Qed. Lemma affixe_vec_AB_affixes : forall A B : PO, affixe_vec (vec A B) = Cplus (affixe B) (Copp (affixe A)). intros. elim existence_affixe_point with (M := A); intros a H; try exact H. elim existence_affixe_point with (M := B); intros b; intros. symmetry in |- *; rewrite <- H; rewrite <- H0. apply affixe_vec_AB; auto. Qed. Hint Resolve egalite_vecteur_distance: geo. Lemma module_difference : forall (a b : C) (A B : PO), a = affixe A -> b = affixe B -> module (Cplus b (Copp a)) = distance A B. intros. cut (Cplus b (Copp a) = affixe_vec (vec A B)); intros. elim existence_representant_vecteur with (A := O) (B := A) (C := B); intros D H2; intros; try exact H2. cut (Cplus b (Copp a) = affixe D); intros. rewrite (module_def (z:=Cplus b (Copp a)) (M:=D)); auto with geo. cut (Cplus b (Copp a) = affixe_vec (vec O D)); intros; auto with geo. rewrite H1; rewrite H2; auto. apply affixe_vec_AB; auto. Qed. Lemma argument_difference : forall (a b : C) (A B : PO), A <> B -> a = affixe A -> b = affixe B -> argument (Cplus b (Copp a)) = cons_AV (vec O I) (vec A B). intros. cut (Cplus b (Copp a) = affixe_vec (vec A B)); intros. elim existence_representant_vecteur with (A := O) (B := A) (C := B); intros D; intros. cut (Cplus b (Copp a) = affixe D); intros. rewrite (argument_def (M:=D) (z:=Cplus b (Copp a))); auto with geo. rewrite H3; auto. red in |- *; intros; apply H. apply vecteur_nul_conf. rewrite <- H3; rewrite <- H5; Ringvec. cut (Cplus b (Copp a) = affixe_vec (vec O D)); intros; auto with geo. rewrite H2; rewrite H3; auto with geo. apply affixe_vec_AB; auto. Qed. Hint Resolve module_difference argument_difference: geo. Lemma diff_nonzero : forall (a b : C) (A B : PO), a = affixe A -> b = affixe B -> A <> B :>PO -> Cplus b (Copp a) <> zeroC. intros. apply nonzero_module. rewrite (module_difference (a:=a) (b:=b) (A:=A) (B:=B)); auto with geo. Qed. Hint Resolve diff_nonzero: geo. Lemma module_quotient : forall (a b d e : C) (A B D E : PO), D <> E :>PO -> a = affixe A -> b = affixe B -> d = affixe D -> e = affixe E -> module (Cdiv (Cplus b (Copp a)) (Cplus e (Copp d))) = distance A B * / distance D E. intros. rewrite Cdiv_def. rewrite Cmult_module; rewrite Cinv_module; auto with geo. rewrite (module_difference (a:=a) (b:=b) (A:=A) (B:=B)); auto with geo. rewrite (module_difference (a:=d) (b:=e) (A:=D) (B:=E)); auto with geo. apply diff_nonzero with (3 := H); auto. apply diff_nonzero with (3 := H); auto. Qed. Hint Resolve module_quotient Chasles_diff: geo. Lemma argument_quotient : forall (a b d e : C) (A B D E : PO), A <> B :>PO -> D <> E :>PO -> a = affixe A -> b = affixe B -> d = affixe D -> e = affixe E -> argument (Cdiv (Cplus b (Copp a)) (Cplus e (Copp d))) = cons_AV (vec D E) (vec A B). intros. cut (Cplus b (Copp a) <> zeroC); intros. cut (Cplus e (Copp d) <> zeroC); intros. rewrite Cdiv_def; auto with geo. rewrite Cmult_argument; auto with geo. rewrite Cinv_argument; auto with geo. rewrite (argument_difference (a:=a) (b:=b) (A:=A) (B:=B)); auto with geo. rewrite (argument_difference (a:=d) (b:=e) (A:=D) (B:=E)); auto with geo. apply diff_nonzero with (3 := H0); auto. apply diff_nonzero with (3 := H); auto. Qed. HighSchoolGeometry/orthocentre.v0000644000076500007650000002453512117747636016773 0ustar coqcoq00000000000000(* This program is free software; you can redistribute it and/or *) (* modify it under the terms of the GNU Lesser General Public License *) (* as published by the Free Software Foundation; either version 2.1 *) (* of the License, or (at your option) any later version. *) (* *) (* This program is distributed in the hope that it will be useful, *) (* but WITHOUT ANY WARRANTY; without even the implied warranty of *) (* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *) (* GNU General Public License for more details. *) (* *) (* You should have received a copy of the GNU Lesser General Public *) (* License along with this program; if not, write to the Free *) (* Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA *) (* 02110-1301 USA *) Require Export projection_orthogonale. Require Export angles_droites. Set Implicit Arguments. Unset Strict Implicit. Lemma deux_hauteurs_trois : forall A B C H : PO, orthogonal (vec H A) (vec B C) -> orthogonal (vec H B) (vec A C) -> orthogonal (vec H C) (vec A B). intros. apply def_orthogonal2. replace (vec H C) with (add_PP (vec H A) (vec A C)) by Ringvec. lapply (def_orthogonal (A:=H) (B:=A) (C:=B) (D:=C)); auto; intros. lapply (def_orthogonal (A:=H) (B:=B) (C:=A) (D:=C)); auto; intros. Simplscal. replace (scalaire (vec H A) (vec A B)) with (scalaire (vec H A) (vec A C)). replace (scalaire (vec H A) (vec A C) + scalaire (vec A C) (vec A B)) with (scalaire (add_PP (vec H A) (vec A B)) (vec A C)). replace (add_PP (vec H A) (vec A B)) with (vec H B); auto. Ringvec. Simplscal. rewrite (scalaire_sym A B A C); auto. replace (vec A B) with (add_PP (vec A C) (vec C B)). Simplscal. replace (vec C B) with (mult_PP (-1) (vec B C)). Simplscal. rewrite H2; ring. Ringvec. Ringvec. Qed. Lemma triangle_rectangle_une_fois : forall A B C : PO, triangle A B C -> orthogonal (vec A B) (vec A C) -> ~ orthogonal (vec A B) (vec B C) /\ ~ orthogonal (vec A C) (vec C B). intros. cut (triangle A C B); intros; auto with geo. deroule_triangle A C B. split; [ try assumption | idtac ]. red in |- *; intros; apply H2. elim orthogonal_paralleles with (A := A) (B := B) (C := C) (E := B) (F := C); [ intros k H7; try exact H7 | auto with geo | auto with geo | auto with geo | auto with geo ]. apply colineaire_alignes with (- k + 1); auto. replace (vec A B) with (add_PP (mult_PP (-1) (vec B C)) (vec A C)); [ idtac | Ringvec ]. rewrite H7; Ringvec. deroule_triangle A B C. red in |- *; intros; apply H6. elim orthogonal_paralleles with (A := A) (B := C) (C := B) (E := C) (F := B); [ intros k H11; try exact H11 | auto with geo | auto with geo | auto with geo | auto with geo ]. apply colineaire_alignes with (- k + 1); auto. replace (vec A C) with (add_PP (mult_PP (-1) (vec C B)) (vec A B)); [ idtac | Ringvec ]. rewrite H11; Ringvec. Qed. Lemma triangle_distincts_pied_hauteur : forall A B C H : PO, triangle A B C -> H = projete_orthogonal A B C -> C <> H :>PO. intros. deroule_triangle A B C. elim (def_projete_orthogonal2 (A:=A) (B:=B) (C:=C) (H:=H)); auto; intros. red in |- *; intros; apply H2. rewrite H8; auto. Qed. Require Export Droite_espace. Lemma triangle_hauteurs_secantes : forall A B C H K : PO, triangle A B C -> H = projete_orthogonal A B C -> K = projete_orthogonal A C B -> concours (droite C H) (droite B K). intros. deroule_triangle A B C. elim (def_projete_orthogonal2 (A:=A) (B:=B) (C:=C) (H:=H)); auto; intros. elim (def_projete_orthogonal2 (A:=A) (B:=C) (C:=B) (H:=K)); auto; intros. cut (C <> H); intros. cut (B <> K); intros. elim (position_relative_droites_coplanaires (A:=C) (B:=H) (C:=B) (D:=K)); auto with geo; intros. absurd (paralleles (droite C H) (droite B K)); auto. apply angle_non_paralleles; auto. rewrite (angles_droites_orthogonales (A:=A) (B:=C) (C:=A) (D:=B) (E:=B) (F:=K) (G:=C) (I:=H)); auto with geo. apply (triangle_distincts_pied_hauteur (A:=A) (B:=C) (C:=B) (H:=K)); auto with geo. apply (triangle_distincts_pied_hauteur (A:=A) (B:=B) (C:=C) (H:=H)); auto with geo. Qed. Lemma aux : forall A B C H K : PO, triangle A B C -> H = projete_orthogonal A B C :>PO -> K = projete_orthogonal A C B :>PO -> ~ alignes C H B \/ ~ alignes C H K. intros. deroule_triangle A B C. elim (def_projete_orthogonal2 (A:=A) (B:=B) (C:=C) (H:=H)); auto; intros. elim (def_projete_orthogonal2 (A:=A) (B:=C) (C:=B) (H:=K)); auto; intros. cut (C <> H); intros. cut (B <> K); intros. elim (classic (orthogonal (vec B A) (vec B C))); intros. cut (H = B); intros. right; try assumption. rewrite H14. cut (~ orthogonal (vec A C) (vec B C)); intros. red in |- *; intros; apply H15. assert (alignes B K C); auto with geo. halignes H17 ipattern:k. apply ortho_sym. rewrite H18. Simplortho. elim triangle_rectangle_une_fois with (A := B) (B := A) (C := C); [ try clear triangle_rectangle_une_fois; intros | auto with geo | auto ]. red in |- *; intros; apply H16. auto with geo. apply unicite_projete_orthogonal with (2 := H7) (3 := H8); auto with geo. left. red in |- *; intros; apply H13. halignes H14 ipattern:k. apply ortho_sym. replace (vec B C) with (mult_PP (-1) (vec C B)); [ idtac | Ringvec ]. rewrite H15. replace (mult_PP (-1) (mult_PP k (vec C H))) with (mult_PP k (vec H C)); [ idtac | Ringvec ]. Simplortho. apply (triangle_distincts_pied_hauteur (A:=A) (B:=C) (C:=B) (H:=K)); auto with geo. apply (triangle_distincts_pied_hauteur (A:=A) (B:=B) (C:=C) (H:=H)); auto. Qed. Lemma existence_intersection_deux_hauteurs_triangle : forall A B C H K : PO, triangle A B C -> H = projete_orthogonal A B C :>PO -> K = projete_orthogonal A C B :>PO -> ex (fun I : PO => I = pt_intersection (droite C H) (droite B K) :>PO). intros. cut (~ alignes C H B \/ ~ alignes C H K); intros. apply existence_pt_intersection; auto. apply (triangle_distincts_pied_hauteur (A:=A) (B:=B) (C:=C) (H:=H)); auto. apply (triangle_distincts_pied_hauteur (A:=A) (B:=C) (C:=B) (H:=K)); auto with geo. apply triangle_hauteurs_secantes with (A := A); auto. apply aux with (A := A); auto. Qed. Parameter orthocentre : PO -> PO -> PO -> PO. Axiom orthocentre_def : forall A B C H : PO, orthogonal (vec H A) (vec B C) -> orthogonal (vec H B) (vec A C) -> orthogonal (vec H C) (vec A B) -> H = orthocentre A B C :>PO. Axiom orthocentre_def2 : forall A B C H : PO, H = orthocentre A B C :>PO -> (orthogonal (vec H A) (vec B C) /\ orthogonal (vec H B) (vec A C)) /\ orthogonal (vec H C) (vec A B). Lemma orthocentre_ordre : forall A B C H : PO, triangle A B C -> H = orthocentre A B C :>PO -> H = orthocentre C A B :>PO. intros. elim orthocentre_def2 with (A := A) (B := B) (C := C) (H := H); [ intros | auto ]. elim H2; intros H4 H5; try clear H2; try exact H5. apply orthocentre_def; auto with geo. Qed. Lemma orthocentre_permute : forall A B C H : PO, triangle A B C -> H = orthocentre A B C :>PO -> H = orthocentre B A C :>PO. intros. elim orthocentre_def2 with (A := A) (B := B) (C := C) (H := H); [ intros | auto ]. elim H2; intros H4 H5; try clear H2; try exact H5. apply orthocentre_def; auto with geo. Qed. Hint Immediate orthocentre_ordre orthocentre_permute: geo. Lemma orthocentre_triangle_rectangle : forall A B C : PO, triangle A B C -> orthogonal (vec A B) (vec B C) -> B = orthocentre A B C :>PO. intros. apply orthocentre_def; auto with geo. replace (vec B B) with zero; auto with geo. Ringvec. Qed. Lemma intersection_deux_hauteurs_orthocentre_triangle : forall A B C H K I : PO, triangle A B C -> H = projete_orthogonal A B C :>PO -> K = projete_orthogonal A C B :>PO -> I = pt_intersection (droite C H) (droite B K) :>PO -> I = orthocentre A B C :>PO. intros A B C H K I H0 H2 H3 H4. deroule_triangle A B C. elim (def_projete_orthogonal2 (A:=A) (B:=B) (C:=C) (H:=H)); auto; intros. elim (def_projete_orthogonal2 (A:=A) (B:=C) (C:=B) (H:=K)); auto; intros. cut (C <> H); intros. cut (B <> K); intros. cut (~ alignes C H B \/ ~ alignes C H K); intros. elim def_pt_intersection2 with (A := C) (B := H) (C := B) (D := K) (I := I); [ try clear def_pt_intersection2; intros | auto | auto | auto | auto ]. halignes H16 ipattern:k. halignes H15 ipattern:k0. cut (orthogonal (vec I B) (vec A C) /\ orthogonal (vec I C) (vec A B)); intros. elim H19; intros H20 H21; try clear H19; try exact H21. apply orthocentre_def; auto. apply deux_hauteurs_trois. auto with geo. auto with geo. split; [ idtac | try assumption ]. replace (vec I B) with (mult_PP (-1) (vec B I)). rewrite H17. replace (mult_PP (-1) (mult_PP k (vec B K))) with (mult_PP k (vec K B)). Simplortho. Ringvec. Ringvec. replace (vec I C) with (mult_PP (-1) (vec C I)). rewrite H18. replace (mult_PP (-1) (mult_PP k0 (vec C H))) with (mult_PP k0 (vec H C)). Simplortho. Ringvec. Ringvec. apply aux with (A := A); auto. apply (triangle_distincts_pied_hauteur (A:=A) (B:=C) (C:=B) (H:=K)); auto with geo. apply (triangle_distincts_pied_hauteur (A:=A) (B:=B) (C:=C) (H:=H)); auto. Qed. Lemma orthocentre_intersection_hauteurs : forall A B C H K I : PO, triangle A B C -> H = projete_orthogonal A B C :>PO -> K = projete_orthogonal A C B :>PO -> I = orthocentre A B C :>PO -> I = pt_intersection (droite C H) (droite B K) :>PO. intros. elim orthocentre_def2 with (A := A) (B := B) (C := C) (H := I); [ intros | auto ]. elim H4; intros H6 H7; try clear H4; try exact H7. cut (~ alignes C H B \/ ~ alignes C H K); intros. deroule_triangle A B C. elim (def_projete_orthogonal2 (A:=A) (B:=B) (C:=C) (H:=H)); auto; intros. elim (def_projete_orthogonal2 (A:=A) (B:=C) (C:=B) (H:=K)); auto; intros. cut (C <> H); intros. cut (B <> K); intros. apply def_pt_intersection; auto. elim orthogonal_colineaires with (A := A) (B := B) (C := H) (D := C) (E := C) (F := I); [ intros k H18; try exact H18 | auto with geo | auto with geo | auto with geo | auto with geo ]. apply colineaire_alignes with (- k); auto. rewrite H18; Ringvec. elim orthogonal_colineaires with (A := A) (B := C) (C := K) (D := B) (E := B) (F := I); [ intros k H18; try exact H18 | auto with geo | auto with geo | auto with geo | auto with geo ]. apply colineaire_alignes with (- k); auto. rewrite H18; Ringvec. apply (triangle_distincts_pied_hauteur (A:=A) (B:=C) (C:=B) (H:=K)); auto with geo. apply (triangle_distincts_pied_hauteur (A:=A) (B:=B) (C:=C) (H:=H)); auto. apply aux with (A := A); auto. Qed. HighSchoolGeometry/orthogonalite.v0000644000076500007650000002334012117747636017306 0ustar coqcoq00000000000000(* This program is free software; you can redistribute it and/or *) (* modify it under the terms of the GNU Lesser General Public License *) (* as published by the Free Software Foundation; either version 2.1 *) (* of the License, or (at your option) any later version. *) (* *) (* This program is distributed in the hope that it will be useful, *) (* but WITHOUT ANY WARRANTY; without even the implied warranty of *) (* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *) (* GNU General Public License for more details. *) (* *) (* You should have received a copy of the GNU Lesser General Public *) (* License along with this program; if not, write to the Free *) (* Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA *) (* 02110-1301 USA *) Require Export produit_scalaire. Set Implicit Arguments. Unset Strict Implicit. Parameter orthogonal : PP -> PP -> Prop. Axiom def_orthogonal : forall A B C D : PO, orthogonal (vec A B) (vec C D) -> scalaire (vec A B) (vec C D) = 0. Axiom def_orthogonal2 : forall A B C D : PO, scalaire (vec A B) (vec C D) = 0 -> orthogonal (vec A B) (vec C D). Lemma ortho_somme : forall A B C D E F : PO, orthogonal (vec A B) (vec E F) -> orthogonal (vec C D) (vec E F) -> orthogonal (add_PP (vec A B) (vec C D)) (vec E F). intros A B C D E F H H0; try assumption. elim existence_representant_som_vecteur with (A := A) (B := B) (C := C) (D := D); intros I H1; try clear existence_representant_som_vecteur; rewrite <- H1. apply def_orthogonal2. rewrite H1. Simplscal. rewrite (def_orthogonal (A:=A) (B:=B) (C:=E) (D:=F)); auto. rewrite (def_orthogonal (A:=C) (B:=D) (C:=E) (D:=F)); auto. ring. Qed. Lemma ortho_combinaison_lineaire : forall (a b : R) (A B C D E F : PO), orthogonal (vec A B) (vec E F) -> orthogonal (vec C D) (vec E F) -> orthogonal (add_PP (mult_PP a (vec A B)) (mult_PP b (vec C D))) (vec E F). intros a b A B C D E F H H0; try assumption. elim existence_representant_comb_lin_vecteur with (A := A) (B := B) (C := C) (D := D) (a := a) (b := b); intros E0 H1; try clear existence_representant_comb_lin_vecteur; rewrite <- H1. apply def_orthogonal2. rewrite H1. Simplscal. rewrite (def_orthogonal (A:=A) (B:=B) (C:=E) (D:=F)); auto. rewrite (def_orthogonal (A:=C) (B:=D) (C:=E) (D:=F)); auto. ring. Qed. Lemma ortho_mult : forall (a : R) (A B C D : PO), orthogonal (vec A B) (vec C D) -> orthogonal (mult_PP a (vec A B)) (vec C D). intros. replace (mult_PP a (vec A B)) with (add_PP (mult_PP a (vec A B)) (mult_PP 0 (vec A B))). apply ortho_combinaison_lineaire; auto. Ringvec. Qed. Lemma ortho_sym : forall A B C D : PO, orthogonal (vec A B) (vec C D) -> orthogonal (vec C D) (vec A B). intros A B C D H; try assumption. apply def_orthogonal2. rewrite scalaire_sym. rewrite (def_orthogonal (A:=A) (B:=B) (C:=C) (D:=D)); auto. Qed. Hint Immediate ortho_sym: geo. Lemma zero_ortho_tout : forall A B : PO, orthogonal (vec A B) zero. intros A B; try assumption. VReplace zero (vec A A). apply def_orthogonal2. VReplace (vec A A) (mult_PP 0 (vec A B)). Simplscal. Qed. Lemma zero_ortho_tout2 : forall A B : PO, orthogonal zero (vec A B). intros. VReplace zero (vec A A). apply def_orthogonal2. VReplace (vec A A) (mult_PP 0 (vec A B)). Simplscal. Qed. Hint Resolve ortho_sym ortho_mult zero_ortho_tout zero_ortho_tout2 def_orthogonal2 def_orthogonal: geo. Ltac Simplortho := (apply ortho_combinaison_lineaire; auto with geo) || (apply ortho_mult; auto with geo) || (apply ortho_somme; auto with geo); try Ringvec. Lemma opp_orthogonal : forall A B C D : PO, orthogonal (vec A B) (vec C D) -> orthogonal (vec B A) (vec C D). intros. replace (vec B A) with (mult_PP (-1) (vec A B)); [ Simplortho | Ringvec ]. Qed. Hint Immediate opp_orthogonal: geo. Lemma opp_orthogonal2 : forall A B C D : PO, orthogonal (vec A B) (vec C D) -> orthogonal (vec C D) (vec B A). auto with geo. Qed. Hint Immediate opp_orthogonal2: geo. Lemma opp_orthogonal3 : forall A B C D : PO, orthogonal (vec A B) (vec C D) -> orthogonal (vec A B) (vec D C). intros. apply ortho_sym. replace (vec D C) with (mult_PP (-1) (vec C D)); [ Simplortho | Ringvec ]. Qed. Hint Immediate opp_orthogonal3: geo. Lemma opp_orthogonal4 : forall A B C D : PO, orthogonal (vec A B) (vec C D) -> orthogonal (vec D C) (vec A B). auto with geo. Qed. Hint Immediate opp_orthogonal4: geo. Lemma opp_orthogonal5 : forall A B C D : PO, orthogonal (vec A B) (vec C D) -> orthogonal (vec B A) (vec D C). intros. apply opp_orthogonal. auto with geo. Qed. Hint Immediate opp_orthogonal5: geo. Lemma opp_orthogonal6 : forall A B C D : PO, orthogonal (vec A B) (vec C D) -> orthogonal (vec D C) (vec B A). auto with geo. Qed. Hint Immediate opp_orthogonal6: geo. Lemma orthogonal_milieu : forall A B C D I : PO, A <> B -> I = milieu A B -> orthogonal (vec I A) (vec C D) \/ orthogonal (vec I B) (vec C D) -> orthogonal (vec A B) (vec C D). intros. elim H1; intros. replace (vec A B) with (mult_PP (-2) (vec I A)). Simplortho. replace (vec A B) with (add_PP (vec A I) (vec I B)). rewrite <- (milieu_vecteur (A:=A) (B:=B) (M:=I)); auto. Ringvec. Ringvec. replace (vec A B) with (mult_PP 2 (vec I B)). Simplortho. replace (vec A B) with (add_PP (vec A I) (vec I B)). rewrite (milieu_vecteur (A:=A) (B:=B) (M:=I)); auto. Ringvec. Ringvec. Qed. Lemma orthogonal_segment_milieu : forall A B C D I : PO, A <> B -> I = milieu A B -> orthogonal (vec A B) (vec C D) -> orthogonal (vec I A) (vec C D) /\ orthogonal (vec I B) (vec C D). intros. cut (orthogonal (vec A I) (vec C D)); intros. split; [ try assumption | idtac ]. VReplace (vec I A) (mult_PP (-1) (vec A I)). Simplortho. rewrite <- (milieu_vecteur (A:=A) (B:=B) (M:=I)); auto. rewrite (milieu_vecteur2 (A:=A) (B:=B) (M:=I)); auto. Simplortho. Qed. Lemma non_orthogonal_def : forall A B C D : PO, scalaire (vec A B) (vec C D) <> 0 -> ~ orthogonal (vec A B) (vec C D). intros. contrapose H. apply def_orthogonal; auto. Qed. Lemma alignes_non_orthogonal : forall A B C : PO, A <> B :>PO -> A <> C :>PO -> alignes A B C -> ~ orthogonal (vec A B) (vec A C). intros. halignes H1 ipattern:x. cut (x <> 0); intros. 2: apply distinct_col_nonzero with (2 := H2); auto. apply non_orthogonal_def. rewrite H2. Simplscal. apply integre_not; auto with geo. Qed. Lemma orthogonal_non_alignes : forall A B C : PO, A <> B :>PO -> A <> C :>PO -> orthogonal (vec A B) (vec A C) -> ~ alignes A B C. intros. cut (~ ~ orthogonal (vec A B) (vec A C)); intros. contrapose H2. apply alignes_non_orthogonal; auto. tauto. Qed. Hint Resolve orthogonal_non_alignes alignes_non_orthogonal: geo. Lemma orthogonal_alignement : forall A B C D : PO, A <> B -> alignes A B C -> orthogonal (vec A B) (vec C D) -> orthogonal (vec C D) (vec C B). intros. halignes H0 ipattern:x. apply ortho_sym. replace (vec C B) with (add_PP (vec A B) (mult_PP (-1) (vec A C))). rewrite H2. replace (add_PP (vec A B) (mult_PP (-1) (mult_PP x (vec A B)))) with (mult_PP (1 + - x) (vec A B)). Simplortho. Ringvec. Ringvec. Qed. Lemma orthogonal_alignement2 : forall A B C D : PO, A <> B -> alignes A B C -> orthogonal (vec A B) (vec C D) -> orthogonal (vec C D) (vec C A). intros. halignes H0 ipattern:x. apply ortho_sym. replace (vec C A) with (mult_PP (-1) (vec A C)). rewrite H2. replace (mult_PP (-1) (mult_PP x (vec A B))) with (mult_PP (- x) (vec A B)). Simplortho. Ringvec. Ringvec. Qed. Lemma paralleles_orthogonal : forall A B C D E F : PO, A <> B -> C <> D -> paralleles (droite A B) (droite C D) -> orthogonal (vec A B) (vec E F) -> orthogonal (vec C D) (vec E F). intros. elim (paralleles_vecteur (A:=C) (B:=D) (C:=A) (D:=B)); auto with geo; intros. rewrite H3. Simplortho. Qed. Lemma alignes_unitaire : forall A B C : PO, alignes A B C -> scalaire (vec A B) (vec A B) = 1 -> vec A C = mult_PP (scalaire (vec A B) (vec A C)) (vec A B). intros. assert (A <> B); auto with geo. halignes H ipattern:x. pattern (vec A C) at 2 in |- *. rewrite H2. Simplscal. rewrite H0; rewrite H2. RingPP. Qed. Lemma scalaire_avec_projete : forall A B C H : PO, alignes A B H -> orthogonal (vec A B) (vec H C) -> scalaire (vec A B) (vec A C) = scalaire (vec A B) (vec A H). intros. discrimine A B. VReplace (vec B B) (mult_PP 0 (vec B C)). Simplscal. halignes H0 ipattern:k. replace (vec A C) with (add_PP (vec A H) (vec H C)). Simplscal. replace (scalaire (vec A B) (vec H C)) with 0. ring. symmetry in |- *. apply def_orthogonal; auto. Ringvec. Qed. Lemma scalaire_alignes : forall A B C D : PO, A <> B -> alignes A B C -> alignes A B D -> scalaire (vec A B) (vec A C) = scalaire (vec A B) (vec A D) -> C = D. intros A B C D H H0 H10 H1; try assumption. halignes H0 ipattern:k. halignes H10 ipattern:k'. rewrite H2 in H1. rewrite H3 in H1. repeat rewrite scalaire_mult_d in H1. elim (classic (k = k')); intros. rewrite H4 in H2. cut (vec A C = vec A D); intros. apply egalite_vecteur_point with A; auto. rewrite H2; rewrite H3; auto. absurd ((k + - k') * scalaire (vec A B) (vec A B) = 0); auto. apply integre_not; auto with geo. contrapose H4. RReplace k (k + - k' + k'). rewrite H5; ring. RReplace ((k + - k') * scalaire (vec A B) (vec A B)) (k * scalaire (vec A B) (vec A B) + - k' * scalaire (vec A B) (vec A B)). rewrite H1; ring. Qed. Lemma unicite_projete_orthogonal : forall A B C H H' : PO, A <> B -> alignes A B H -> orthogonal (vec A B) (vec H C) -> alignes A B H' -> orthogonal (vec A B) (vec H' C) -> H = H'. intros. apply scalaire_alignes with (2 := H1) (3 := H3); auto. rewrite <- (scalaire_avec_projete (A:=A) (B:=B) (C:=C) (H:=H)); auto. rewrite <- (scalaire_avec_projete (A:=A) (B:=B) (C:=C) (H:=H')); auto. Qed.HighSchoolGeometry/orthogonalite_espace.v0000644000076500007650000001536312117747636020634 0ustar coqcoq00000000000000(* This program is free software; you can redistribute it and/or *) (* modify it under the terms of the GNU Lesser General Public License *) (* as published by the Free Software Foundation; either version 2.1 *) (* of the License, or (at your option) any later version. *) (* *) (* This program is distributed in the hope that it will be useful, *) (* but WITHOUT ANY WARRANTY; without even the implied warranty of *) (* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *) (* GNU General Public License for more details. *) (* *) (* You should have received a copy of the GNU Lesser General Public *) (* License along with this program; if not, write to the Free *) (* Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA *) (* 02110-1301 USA *) Require Export orthogonalite. Require Export Plan_espace. Set Implicit Arguments. Unset Strict Implicit. Parameter orthogonales : DR -> DR -> Prop. Axiom def_orthogonales : forall A B C D : PO, A <> B -> C <> D -> orthogonal (vec A B) (vec C D) -> orthogonales (droite A B) (droite C D). Axiom def_orthogonales2 : forall A B C D : PO, A <> B -> C <> D -> orthogonales (droite A B) (droite C D) -> orthogonal (vec A B) (vec C D). Parameter perpendiculaires : DR -> DR -> Prop. Axiom def_perpendiculaires : forall A B C D : PO, A <> B -> C <> D -> coplanaires A B C D -> orthogonales (droite A B) (droite C D) -> perpendiculaires (droite A B) (droite C D). Axiom def_perpendiculaires2 : forall A B C D : PO, A <> B -> C <> D -> perpendiculaires (droite A B) (droite C D) -> coplanaires A B C D /\ orthogonales (droite A B) (droite C D). Hint Resolve ortho_somme ortho_combinaison_lineaire def_orthogonales2 def_orthogonales def_perpendiculaires: geo. Lemma perpendiculaires_orthogonales : forall A B C D : PO, A <> B -> C <> D -> perpendiculaires (droite A B) (droite C D) -> orthogonales (droite A B) (droite C D). intros. elim def_perpendiculaires2 with (A := A) (B := B) (C := C) (D := D); [ intros; try exact H3 | auto | auto | auto ]. Qed. Lemma orthogonales_2droites_secantes : forall A B C D E F G : PO, ~ alignes A B C -> D <> E -> F <> G -> coplanaires A B C F -> coplanaires A B C G -> orthogonales (droite A B) (droite D E) -> orthogonales (droite A C) (droite D E) -> orthogonales (droite F G) (droite D E). intros A B C D E F G H; try assumption. assert (A <> B); auto with geo. intros. apply def_orthogonales; auto. lapply (def_orthogonales2 (A:=A) (B:=B) (C:=D) (D:=E)); auto; intros. lapply (def_orthogonales2 (A:=A) (B:=C) (C:=D) (D:=E)); auto; intros. hcoplanaires H3 ipattern:k ipattern:k'. hcoplanaires H4 ipattern:k0 ipattern:k'0. replace (vec F G) with (add_PP (mult_PP (-1) (vec A F)) (vec A G)). rewrite H4. rewrite H3. replace (add_PP (mult_PP (-1) (add_PP (mult_PP k (vec A B)) (mult_PP k' (vec A C)))) (add_PP (mult_PP k0 (vec A B)) (mult_PP k'0 (vec A C)))) with (add_PP (mult_PP (-1 * k + k0) (vec A B)) (mult_PP (-1 * k' + k'0) (vec A C))). Simplortho. Ringvec. Ringvec. apply non_alignes_distincts with B; auto. Qed. Parameter orthogonaux : DR -> PL -> Prop. Axiom def_orthogonaux : forall A B C D E : PO, ~ alignes A B C -> D <> E -> orthogonales (droite A B) (droite D E) -> orthogonales (droite A C) (droite D E) -> orthogonaux (droite D E) (plan A B C). Axiom def_orthogonaux2 : forall A B C D E : PO, ~ alignes A B C -> D <> E -> orthogonaux (droite D E) (plan A B C) -> orthogonales (droite A B) (droite D E) /\ orthogonales (droite A C) (droite D E). Lemma vecteurs_orthogonaux : forall A B C D E : PO, ~ alignes A B C -> D <> E -> orthogonal (vec A B) (vec D E) -> orthogonal (vec A C) (vec D E) -> orthogonaux (droite D E) (plan A B C). intros. deroule_triangle A B C. apply def_orthogonaux; auto with geo. Qed. Lemma vecteurs_orthogonaux_rec : forall A B C D E : PO, ~ alignes A B C -> D <> E -> orthogonaux (droite D E) (plan A B C) -> orthogonal (vec A B) (vec D E) /\ orthogonal (vec A C) (vec D E). intros. deroule_triangle A B C. elim def_orthogonaux2 with (A := A) (B := B) (C := C) (D := D) (E := E); [ intros H5 H6; try clear def_orthogonaux2; try exact H6 | auto | auto | auto ]. intros. split; auto with geo. Qed. Lemma orthogonaux_orthogonales_toute_droite : forall A B C D E F G : PO, ~ alignes A B C -> D <> E -> F <> G -> coplanaires A B C F -> coplanaires A B C G -> orthogonaux (droite D E) (plan A B C) -> orthogonales (droite F G) (droite D E). intros. assert (A <> B); auto with geo. apply orthogonales_2droites_secantes with (1 := H); auto. elim def_orthogonaux2 with (A := A) (B := B) (C := C) (D := D) (E := E); [ try clear def_orthogonaux2; intros; auto | auto | auto | auto ]. elim def_orthogonaux2 with (A := A) (B := B) (C := C) (D := D) (E := E); [ try clear def_orthogonaux2; intros; auto | auto | auto | auto ]. Qed. Lemma orthogonales_toute_droite_orthogonaux : forall A B C D E : PO, ~ alignes A B C -> D <> E -> (forall F G : PO, F <> G -> coplanaires A B C F -> coplanaires A B C G -> orthogonales (droite F G) (droite D E)) -> orthogonaux (droite D E) (plan A B C). intros. assert (A <> B); auto with geo. apply def_orthogonaux; auto with geo. apply H1; auto with geo. apply non_alignes_distincts with B; auto with geo. Qed. Lemma orthogonaux_perce : forall A B C D E : PO, ~ alignes A B C -> D <> E -> orthogonaux (droite D E) (plan A B C) -> perce (droite D E) (plan A B C). intros. elim position_relative_droite_plan with (A := A) (B := B) (C := C) (D := D) (E := E); [ intros H3; try clear position_relative_droite_plan; intros | intros H3; try clear position_relative_droite_plan; try exact H3 | auto | auto ]. absurd (D = E); auto. elim para_plan_dr_vecteur with (A := A) (B := B) (C := C) (D := D) (E := E); [ intros k H4; elim H4; intros k' H5; try clear H4; try exact H5 | auto | auto | auto ]. elim vecteurs_orthogonaux_rec with (A := A) (B := B) (C := C) (D := D) (E := E); [ try clear vecteurs_orthogonaux_rec; intros | auto | auto | auto ]. apply vecteur_nul_conf. apply scalaire_non_degenere. pattern (vec D E) at 1 in |- *; rewrite H5. cut (orthogonal (add_PP (mult_PP k (vec A B)) (mult_PP k' (vec A C))) (vec D E)); intros. elim existence_representant_comb_lin_vecteur with (A := A) (B := B) (C := A) (D := C) (a := k) (b := k'); intros E0 H8; try clear existence_representant_comb_lin_vecteur; rewrite <- H8. rewrite <- H8 in H6. rewrite (def_orthogonal (A:=A) (B:=E0) (C:=D) (D:=E)); auto. apply ortho_combinaison_lineaire; auto. Qed.HighSchoolGeometry/parallelisme_concours.v0000644000076500007650000004267012117747636021024 0ustar coqcoq00000000000000(* This program is free software; you can redistribute it and/or *) (* modify it under the terms of the GNU Lesser General Public License *) (* as published by the Free Software Foundation; either version 2.1 *) (* of the License, or (at your option) any later version. *) (* *) (* This program is distributed in the hope that it will be useful, *) (* but WITHOUT ANY WARRANTY; without even the implied warranty of *) (* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *) (* GNU General Public License for more details. *) (* *) (* You should have received a copy of the GNU Lesser General Public *) (* License along with this program; if not, write to the Free *) (* Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA *) (* 02110-1301 USA *) Require Export milieu. Set Implicit Arguments. Unset Strict Implicit. Parameter DR : Type. Parameter droite : PO -> PO -> DR. Axiom droite_permute : forall A B : PO, A <> B :>PO -> droite A B = droite B A. Hint Resolve droite_permute: geo. Axiom alignes_droite : forall A B C : PO, A <> B :>PO -> A <> C :>PO -> alignes A B C -> droite A B = droite A C. Lemma alignes_droite2 : forall A B C : PO, A <> B :>PO -> B <> C :>PO -> alignes A B C -> droite A B = droite B C. intros. rewrite droite_permute; auto. apply alignes_droite; auto with geo. Qed. Hint Resolve alignes_droite alignes_droite2: geo. Parameter paralleles : DR -> DR -> Prop. Axiom def_paralleles : forall (A B C D : PO) (k : R), A <> B :>PO -> C <> D :>PO -> add_PP (cons 1 B) (cons (-1) A) = add_PP (cons k D) (cons (- k) C) -> paralleles (droite A B) (droite C D). Axiom def_paralleles2 : forall A B C D : PO, A <> B :>PO -> C <> D :>PO -> paralleles (droite A B) (droite C D) -> exists k : R, add_PP (cons 1 B) (cons (-1) A) = add_PP (cons k D) (cons (- k) C) :>PP. Lemma paralleles_refl : forall A B : PO, A <> B :>PO -> paralleles (droite A B) (droite A B). intros A B H; try assumption. apply def_paralleles with (k := 1); auto. Qed. Hint Resolve paralleles_refl: geo. Lemma paralleles_sym : forall A B C D : PO, A <> B -> C <> D -> paralleles (droite A B) (droite C D) -> paralleles (droite C D) (droite A B). intros A B C D H H1 H0; try assumption. elim def_paralleles2 with (3 := H0); intros; auto. elim (classic (x = 0)); intros. rewrite H3 in H2. absurd (A = B); auto. apply conversion_PP with (a := 1) (b := 1); auto. RingPP1 H2; RingPP; auto with *. auto with *. apply def_paralleles with (k := / x); auto. apply mult_PP_regulier with x; auto. VReplace (mult_PP x (add_PP (cons 1 D) (cons (-1) C))) (add_PP (cons x D) (cons (- x) C)). rewrite <- H2. FieldPP x. Qed. Lemma paralleles_trans : forall A B C D E F : PO, A <> B -> C <> D :>PO -> E <> F :>PO -> paralleles (droite A B) (droite C D) -> paralleles (droite C D) (droite E F) -> paralleles (droite A B) (droite E F). intros A B C D E F H H10 H11 H0 H1; try assumption. elim def_paralleles2 with (3 := H0); intros; auto. elim def_paralleles2 with (3 := H1); intros; auto. apply def_paralleles with (k := x * x0); auto. rewrite H2. elim (classic (x = 0)); intros. rewrite H4 in H2. absurd (A = B); auto. apply conversion_PP with (a := 1) (b := 1); auto. RingPP1 H2; RingPP; auto with *. auto with *. replace (add_PP (cons x D) (cons (- x) C)) with (mult_PP x (add_PP (cons 1 D) (cons (-1) C))). rewrite H3. RingPP. RingPP. Qed. Lemma paralleles_vecteur : forall A B C D : PO, A <> B :>PO -> C <> D :>PO -> paralleles (droite A B) (droite C D) -> exists k : R, vec A B = mult_PP k (vec C D) :>PP. unfold vec in |- *; intros. elim def_paralleles2 with (3 := H1); auto. intros k H2; try assumption. exists k. RingPP1 H2; RingPP. Qed. Lemma colineaires_paralleles : forall (k : R) (A B C D : PO), A <> B :>PO -> C <> D :>PO -> vec A B = mult_PP k (vec C D) -> paralleles (droite A B) (droite C D). unfold vec in |- *; intros. apply def_paralleles with k; auto. RingPP1 H1; RingPP. Qed. Lemma alignes_paralleles : forall A B C : PO, A <> B -> A <> C -> alignes A B C -> paralleles (droite A B) (droite A C). intros. apply paralleles_sym; auto. halignes H1 ipattern:x. apply colineaires_paralleles with x; intros; auto. Qed. Lemma paralleles_ABBA : forall A B : PO, A <> B -> paralleles (droite A B) (droite B A). intros. apply def_paralleles with (-1); auto. RingPP. Qed. Hint Immediate paralleles_ABBA paralleles_sym: geo. Lemma non_paralleles_trans : forall A B C D E F : PO, A <> B :>PO -> C <> D :>PO -> E <> F :>PO -> paralleles (droite A B) (droite C D) -> ~ paralleles (droite A B) (droite E F) -> ~ paralleles (droite C D) (droite E F). intros; red in |- *; intros. apply H3. apply paralleles_trans with (4 := H2); auto. Qed. Hint Resolve alignes_paralleles: geo. Lemma paralleles_alignes : forall A B C D : PO, A <> B :>PO -> C <> D :>PO -> paralleles (droite A B) (droite C D) -> alignes A B C -> alignes A B D. intros. elim (paralleles_vecteur (A:=C) (B:=D) (C:=A) (D:=B)); intros; auto with geo. halignes H2 ipattern:x0. apply colineaire_alignes with (x + x0). VReplace (vec A D) (add_PP (vec A C) (vec C D)). rewrite H3; rewrite H4; Ringvec. Qed. Lemma paralleles_alignes1 : forall A B C D E F : PO, A <> B :>PO -> C <> D :>PO -> vec E F = vec A B :>PP -> paralleles (droite A B) (droite C D) -> alignes C D E -> alignes C D F. intros A B C D E F H H0 H1 H2 H3; try assumption. elim (paralleles_vecteur (A:=A) (B:=B) (C:=C) (D:=D)); intros; auto. halignes H3 ipattern:x0. apply colineaire_alignes with (x0 + x). VReplace (vec C F) (add_PP (vec C E) (vec E F)). rewrite H5; rewrite H1; rewrite H4. Ringvec. Qed. Lemma paralleles_alignes2 : forall A B C D E F : PO, A <> B :>PO -> C <> D :>PO -> vec E F = vec A B :>PP -> paralleles (droite A B) (droite C D) -> alignes C D E -> alignes F C E. intros A B C D E F H H0 H1 H2 H3; try assumption. elim (paralleles_vecteur (A:=C) (B:=D) (C:=A) (D:=B)); intros; auto with geo. halignes H3 ipattern:x0. rewrite H4 in H5. discrimine F C. cut (1 + x0 * x <> 0); intros. apply colineaire_alignes with (/ (1 + x0 * x)). VReplace (vec F C) (add_PP (vec F E) (mult_PP (-1) (vec C E))). VReplace (vec F E) (mult_PP (-1) (vec E F)). rewrite H1; rewrite H5. Fieldvec (1 + x0 * x). red in |- *; intros; apply H6. apply vecteur_nul_conf. VReplace (vec F C) (add_PP (mult_PP (-1) (vec E F)) (mult_PP (-1) (vec C E))). rewrite H1; rewrite H5. VReplace (add_PP (mult_PP (-1) (vec A B)) (mult_PP (-1) (mult_PP x0 (mult_PP x (vec A B))))) (mult_PP (-1) (mult_PP (1 + x0 * x) (vec A B))). rewrite H7; Ringvec. Qed. Lemma paralleles_alignes3 : forall A B C D : PO, A <> B :>PO -> C <> D :>PO -> paralleles (droite A B) (droite C D) -> alignes C D A -> alignes A C B. intros A B C D H H0 H1 H2; try assumption. elim (paralleles_vecteur (A:=A) (B:=B) (C:=C) (D:=D)); intros; auto. discrimine C A. assert (alignes C A D); auto with geo. halignes H5 ipattern:x0. rewrite H6 in H3. apply colineaire_alignes with (- (x * x0)). rewrite H3; Ringvec. Qed. Lemma alignes_paralleles_confondus : forall A B C J : PO, triangle A B C -> alignes A C J -> paralleles (droite B C) (droite B J) -> J = C :>PO. intros. cut (triangle B C A); auto with geo; intros. deroule_triangle B C A. apply (concours_unique (A:=B) (B:=A) (A1:=C) (B1:=C) (I:=J) (J:=C)); auto with geo. cut (B <> J); intros. elim paralleles_vecteur with (A := B) (B := J) (C := B) (D := C); [ intros k0 H8 | auto | auto | auto with geo ]. apply colineaire_alignes with k0; auto. cut (triangle A C B); auto with geo; intros. deroule_triangle A C B. red in |- *; intros; apply H8. rewrite H12; auto. Qed. Parameter concours : DR -> DR -> Prop. Axiom def_concours : forall A B C D I : PO, A <> B -> C <> D -> alignes A B I -> alignes C D I -> concours (droite A B) (droite C D). Axiom def_concours2 : forall A B C D : PO, A <> B -> C <> D -> concours (droite A B) (droite C D) -> exists I : PO, alignes A B I /\ alignes C D I. Lemma paralleles_non_concours : forall A B C D : PO, A <> B :>PO -> C <> D :>PO -> ~ alignes A B D -> paralleles (droite C D) (droite A B) -> ~ concours (droite C D) (droite A B). intros A B C D H10 H11 H H0. elim def_paralleles2 with (3 := H0); intros; auto. unfold not in |- *; intros. elim def_concours2 with (3 := H2); intros; auto. elim H3; [ intros H4 H5; try clear H3; try exact H5 ]. elim H4; clear H4; (unfold alignes1 in |- *; intros); [ tauto | idtac ]. elim H3; [ intros k H4; try clear H3; try exact H4 ]. elim H5; clear H5; (unfold alignes1 in |- *; intros); [ tauto | idtac ]. elim H3; [ intros k0 H5; try clear H3; try exact H5 ]. apply H. cut (add_PP (cons k0 A) (cons (1 + - k0) B) = add_PP (cons k C) (cons (1 + - k) D)); intros. unfold alignes, alignes1 in |- *. right; try assumption. exists (k0 + - (x * k)). pattern 1 at 1 in |- *. replace 1 with (k + (1 + - k)); try ring. replace (cons (k + (1 + - k)) D) with (add_PP (cons k D) (cons (1 + - k) D)). replace (cons k D) with (mult_PP k (cons 1 D)). RingPP1 H1. replace (cons (k0 + - (x * k)) A) with (add_PP (cons k0 A) (cons (- (x * k)) A)). replace (1 + - (k0 + - (x * k))) with (1 + - k0 + x * k); try ring. RingPP1 H3. RingPP. RingPP. RingPP. RingPP. rewrite <- H4; auto. Qed. Lemma concours_non_paralleles : forall A B C D : PO, A <> B :>PO -> C <> D :>PO -> ~ alignes A B D -> concours (droite C D) (droite A B) -> ~ paralleles (droite C D) (droite A B). intros A B C D H10 H20 H H0; try assumption. cut (~ ~ concours (droite C D) (droite A B)); intros. unfold not in |- *; intros. apply H1. apply paralleles_non_concours; auto. intuition. Qed. Parameter pt_intersection : DR -> DR -> PO. Axiom def_pt_intersection : forall A B C D I : PO, A <> B -> C <> D -> ~ alignes A B C \/ ~ alignes A B D -> alignes A B I -> alignes C D I -> I = pt_intersection (droite A B) (droite C D). Axiom def_pt_intersection2 : forall A B C D I : PO, A <> B -> C <> D -> ~ alignes A B C \/ ~ alignes A B D -> I = pt_intersection (droite A B) (droite C D) -> alignes A B I /\ alignes C D I. Lemma existence_pt_intersection : forall A B C D : PO, A <> B -> C <> D -> ~ alignes A B C \/ ~ alignes A B D -> concours (droite A B) (droite C D) -> exists I : PO, I = pt_intersection (droite A B) (droite C D) :>PO. intros. elim def_concours2 with (A := A) (B := B) (C := C) (D := D); [ intros I H3; elim H3; intros H4 H5; try clear H3 def_concours2; try exact H5 | auto | auto | auto ]. exists I. apply def_pt_intersection; auto. Qed. Lemma ordre_alignement_4points : forall A B C D : PO, A <> B :>PO -> alignes A B C /\ alignes A B D -> alignes C D A /\ alignes C D B. intros. elim H0; intros H1 H2; try clear H0; try exact H2. split; [ try assumption | idtac ]. eauto with geo. eauto with geo. Qed. Lemma pt_intersection_commute : forall A B C D I : PO, A <> B :>PO -> C <> D :>PO -> ~ alignes A B C \/ ~ alignes A B D -> I = pt_intersection (droite A B) (droite C D) :>PO -> I = pt_intersection (droite C D) (droite A B) :>PO. intros. elim def_pt_intersection2 with (A := A) (B := B) (C := C) (D := D) (I := I); [ try clear def_pt_intersection2; intros | auto | auto | auto | auto ]. apply def_pt_intersection; auto. apply not_and_or; auto. cut (~ (alignes A B C /\ alignes A B D)); intros. red in |- *; intros; apply H5. apply ordre_alignement_4points; auto. apply or_not_and; auto. Qed. Lemma concours_barycentre : forall A B C D : PO, A <> B -> C <> D -> concours (droite A B) (droite C D) -> exists I : PO, ex (fun a : R => ex (fun b : R => I = barycentre (cons (1 + - a) A) (cons a B) :>PO /\ I = barycentre (cons (1 + - b) C) (cons b D) :>PO)). intros A B C D H10 H11 H; try assumption. elim def_concours2 with (3 := H); auto. intros I H0; elim H0; intros H1 H2; clear H0 H; try exact H2. elim alignes_barycentre with (A := A) (B := B) (C := I); [ intros a H; try clear alignes_barycentre; try exact H | auto | auto ]. elim alignes_barycentre with (A := C) (B := D) (C := I); [ intros b H'; try clear alignes_barycentre | auto | auto ]. exists I; exists (1 + - a); exists (1 + - b). replace (1 + - (1 + - a)) with a; try ring. replace (1 + - (1 + - b)) with b; try ring. split; [ try assumption | try assumption ]. Qed. Lemma barycentre_concours : forall (a b c d : R) (A B C D I : PO), A <> B -> C <> D :>PO -> a + b <> 0 :>R -> barycentre (cons a A) (cons b B) = I :>PO -> c + d <> 0 :>R -> barycentre (cons c C) (cons d D) = I :>PO -> concours (droite A B) (droite C D). intros a b c d A B C D I H H0 H1 H2 H3 H4; try assumption. apply def_concours with I; auto. rewrite <- H2. apply barycentre_alignes; auto. rewrite <- H4. apply barycentre_alignes; auto. Qed. Lemma add_PP_concours : forall (a b c d : R) (A B C D I : PO), A <> B :>PO -> C <> D :>PO -> a + b <> 0 :>R -> add_PP (cons a A) (cons b B) = cons (a + b) I :>PP -> c + d <> 0 :>R -> add_PP (cons c C) (cons d D) = cons (c + d) I :>PP -> concours (droite A B) (droite C D). intros a b c d A B C D I H H0 H1 H2 H3 H4; try assumption. apply def_concours with I; auto. apply add_PP_alignes with (a := a) (b := b); auto. apply add_PP_alignes with (a := c) (b := d); auto. Qed. Lemma concours_mediane : forall A B C : PO, A <> milieu B C :>PO -> milieu A B <> C :>PO -> concours (droite A (milieu B C)) (droite (milieu A B) C). intros A B C H H0; try assumption. generalize (add_PP_milieu_asso A B C); intros. generalize (add_PP_concours (a:=1) (b:=2) (c:=2) (d:=1) (A:=A) (B:= milieu B C) (C:=milieu A B) (D:=C) (I:=barycentre (cons 1 A) (cons 2 (milieu B C)))); intros H8; apply H8; auto. try discrR; auto with *. rewrite add_PP_barycentre; try discrR; auto with *. try discrR; auto with *. rewrite <- H1; auto. rewrite add_PP_barycentre; try discrR; auto with *. apply cons_comp; try ring; auto. Qed. Definition concours_3 (A B C D E F : PO) := exists I : PO, alignes A B I /\ alignes C D I /\ alignes E F I. Lemma concours_3_mediane : forall A B C : PO, concours_3 A (milieu B C) (milieu A B) C (milieu A C) B. intros A B C; try assumption. generalize (add_PP_milieu_asso A B C); intros. generalize (add_PP_milieu_permute A B C); intros. unfold concours_3 in |- *. exists (barycentre (cons 1 A) (cons 2 (milieu B C))). split; [ try assumption | idtac ]. apply barycentre_alignes; try discrR; auto with *. split; [ try assumption | idtac ]. apply add_PP_alignes with (a := 2) (b := 1); try discrR; auto with *. rewrite <- H; auto. rewrite add_PP_barycentre; try discrR; auto with *. apply cons_comp; (try ring; auto). apply add_PP_alignes with (a := 2) (b := 1); try discrR; auto with *. rewrite <- H0; auto. rewrite add_PP_barycentre; try discrR; auto with *. apply cons_comp; try ring; auto. Qed. Lemma concours_3_barycentre : forall (a b c : R) (A B C : PO), a + (b + c) <> 0 :>R -> a + b <> 0 :>R -> b + c <> 0 :>R -> a + c <> 0 :>R -> concours_3 A (barycentre (cons b B) (cons c C)) (barycentre (cons a A) (cons b B)) C (barycentre (cons a A) (cons c C)) B. unfold concours_3 in |- *. intros a b c A B C H H0 H1 H2; try assumption. exists (barycentre (cons a A) (cons (b + c) (barycentre (cons b B) (cons c C)))). generalize (add_PP_assoc (cons a A) (cons b B) (cons c C)); intros. generalize (add_PP_assoc_permute (cons a A) (cons b B) (cons c C)); intros. split; [ try assumption | idtac ]. apply add_PP_alignes with (a := a) (b := b + c); auto with geo. split; [ try assumption | idtac ]. apply add_PP_alignes with (a := a + b) (b := c); auto with geo. unfold not in |- *; intros; apply H. rewrite <- H5; ring. rewrite <- add_PP_barycentre; auto with geo. rewrite <- H3; auto. repeat rewrite add_PP_barycentre; auto with geo. apply cons_comp; auto. ring. apply add_PP_alignes with (a := a + c) (b := b); auto with geo. unfold not in |- *; intros; apply H. rewrite <- H5; ring. rewrite <- add_PP_barycentre; auto. rewrite <- H4; auto. repeat rewrite add_PP_barycentre; auto. apply cons_comp; auto. ring. Qed. Lemma centre_gravite_intersection_medianes : forall A B C I J G : PO, triangle A B C -> I = milieu B C :>PO -> J = milieu A B :>PO -> G = centre_gravite A B C :>PO -> G = pt_intersection (droite A I) (droite C J) :>PO. intros. deroule_triangle A B C. cut (triangle B C A); auto with geo; unfold triangle in |- *; intros. cut (C <> J); intros. cut (A <> I); intros. cut (3 <> 0); intros; auto with real. replace (droite C J) with (droite J C); auto with geo. apply def_pt_intersection; auto. left. apply triangle_medianes_triangle with (1 := H); auto. apply colineaire_alignes with (/ 3 * 2); auto. rewrite (centre_gravite_mediane_vecteur (A:=A) (B:=B) (C:=C) (I:=I) (G:=G)); auto. Fieldvec 3. apply permute_alignes; auto. apply colineaire_alignes with (/ 3 * 2); auto. rewrite (centre_gravite_mediane_vecteur (A:=C) (B:=A) (C:=B) (I:=J) (G:=G)); auto. Fieldvec 3. rewrite H2; auto with geo. rewrite H0. apply triangle_milieu_distinct; auto. rewrite H1. apply triangle_milieu_distinct; auto. Qed. Lemma centre_gravite_intersection_trois_medianes : forall A B C I J K G : PO, triangle A B C -> I = milieu B C :>PO -> J = milieu A B :>PO -> K = milieu A C :>PO -> G = centre_gravite A B C :>PO -> G = pt_intersection (droite A I) (droite B K) :>PO /\ G = pt_intersection (droite A I) (droite C J) :>PO. intros. split; [ idtac | try assumption ]. apply centre_gravite_intersection_medianes with (B := C); auto with geo. rewrite H3; auto with geo. apply centre_gravite_intersection_medianes with (B := B); auto. Qed.HighSchoolGeometry/produit_scalaire.v0000644000076500007650000001471612117747636017770 0ustar coqcoq00000000000000(* This program is free software; you can redistribute it and/or *) (* modify it under the terms of the GNU Lesser General Public License *) (* as published by the Free Software Foundation; either version 2.1 *) (* of the License, or (at your option) any later version. *) (* *) (* This program is distributed in the hope that it will be useful, *) (* but WITHOUT ANY WARRANTY; without even the implied warranty of *) (* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *) (* GNU General Public License for more details. *) (* *) (* You should have received a copy of the GNU Lesser General Public *) (* License along with this program; if not, write to the Free *) (* Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA *) (* 02110-1301 USA *) Require Export parallelisme_concours. Set Implicit Arguments. Unset Strict Implicit. Parameter scalaire : PP -> PP -> R. Axiom scalaire_positif : forall A B : PO, scalaire (vec A B) (vec A B) >= 0. Axiom scalaire_non_degenere : forall A B : PO, scalaire (vec A B) (vec A B) = 0 -> vec A B = zero. Axiom scalaire_sym : forall A B C D : PO, scalaire (vec A B) (vec C D) = scalaire (vec C D) (vec A B). Axiom scalaire_somme_g : forall A B C D E F : PO, scalaire (add_PP (vec A B) (vec C D)) (vec E F) = scalaire (vec A B) (vec E F) + scalaire (vec C D) (vec E F). Axiom scalaire_mult_g : forall (k : R) (A B C D : PO), scalaire (mult_PP k (vec A B)) (vec C D) = k * scalaire (vec A B) (vec C D). Lemma scalaire_lineaire_g : forall (a b : R) (A B C D E F : PO), scalaire (add_PP (mult_PP a (vec A B)) (mult_PP b (vec C D))) (vec E F) = a * scalaire (vec A B) (vec E F) + b * scalaire (vec C D) (vec E F). intros. elim existence_representant_mult_vecteur with (A := A) (B := A) (C := B) (k := a); intros B' H; try clear existence_representant_mult_vecteur; rewrite <- H. elim existence_representant_mult_vecteur with (A := A) (B := C) (C := D) (k := b); intros C' H0; try clear existence_representant_mult_vecteur; rewrite <- H0. rewrite scalaire_somme_g. rewrite H; rewrite H0. repeat rewrite scalaire_mult_g; auto. Qed. Lemma scalaire_lineaire_d : forall (a b : R) (A B C D E F : PO), scalaire (vec E F) (add_PP (mult_PP a (vec A B)) (mult_PP b (vec C D))) = a * scalaire (vec E F) (vec A B) + b * scalaire (vec E F) (vec C D). intros. rewrite scalaire_sym. rewrite (scalaire_sym E F C D). rewrite <- scalaire_lineaire_g. elim existence_representant_comb_lin_vecteur with (A := A) (B := B) (C := C) (D := D) (a := a) (b := b); intros E0 H; try clear existence_representant_comb_lin_vecteur; rewrite <- H. rewrite scalaire_sym; auto. Qed. Lemma scalaire_bilineaire : forall (a b c d : R) (A B C D E F G H : PO), scalaire (add_PP (mult_PP a (vec A B)) (mult_PP b (vec C D))) (add_PP (mult_PP c (vec E F)) (mult_PP d (vec G H))) = a * c * scalaire (vec A B) (vec E F) + a * d * scalaire (vec A B) (vec G H) + (b * c * scalaire (vec C D) (vec E F) + b * d * scalaire (vec C D) (vec G H)). intros a b c d A B C D E F G I; try assumption. elim existence_representant_comb_lin_vecteur with (A := E) (B := F) (C := G) (D := I) (a := c) (b := d); intros E0 H; try clear existence_representant_comb_lin_vecteur; rewrite <- H. rewrite scalaire_lineaire_g. rewrite H. repeat rewrite scalaire_lineaire_d. ring. Qed. Lemma scalaire_mult_mult : forall (A B C D : PO) (x y : R), scalaire (mult_PP x (vec A B)) (mult_PP y (vec C D)) = x * y * scalaire (vec A B) (vec C D) :>R. intros A B C D x y; try assumption. replace (mult_PP x (vec A B)) with (add_PP (mult_PP x (vec A B)) (mult_PP 0 (vec C D))). replace (mult_PP y (vec C D)) with (add_PP (mult_PP 0 (vec A B)) (mult_PP y (vec C D))). rewrite scalaire_bilineaire; ring. unfold vec in |- *; RingPP. unfold vec in |- *; RingPP. Qed. Lemma scalaire_mult_d : forall (k : R) (A B C D : PO), scalaire (vec A B) (mult_PP k (vec C D)) = k * scalaire (vec A B) (vec C D) :>R. intros. replace (mult_PP k (vec C D)) with (add_PP (mult_PP k (vec C D)) (mult_PP 0 (vec C D))). rewrite scalaire_lineaire_d. ring. unfold vec in |- *; RingPP. Qed. Lemma scalaire_somme_d : forall A B C D E F : PO, scalaire (vec A B) (add_PP (vec C D) (vec E F)) = scalaire (vec A B) (vec C D) + scalaire (vec A B) (vec E F) :>R. intros. replace (add_PP (vec C D) (vec E F)) with (add_PP (mult_PP 1 (vec C D)) (mult_PP 1 (vec E F))). rewrite scalaire_lineaire_d. ring. unfold vec in |- *; RingPP. Qed. Ltac Simplscal := repeat rewrite scalaire_lineaire_d; repeat rewrite scalaire_lineaire_g; repeat rewrite scalaire_somme_g; repeat rewrite scalaire_somme_d; repeat rewrite scalaire_mult_g; repeat rewrite scalaire_mult_d; repeat rewrite scalaire_mult_mult; repeat rewrite scalaire_bilineaire; try (ring || ring_simplify). Lemma unitaire_distincts : forall A B : PO, scalaire (vec A B) (vec A B) = 1 -> A <> B :>PO. intros; unfold not in |- *; intros. absurd (scalaire (vec A B) (vec A B) = 1); auto. rewrite H0. pattern (vec B B) at 1 in |- *. replace (vec B B) with (mult_PP 0 (vec A B)). rewrite scalaire_mult_g. replace (0 * scalaire (vec A B) (vec B B)) with 0. auto with *. ring. unfold vec in |- *; RingPP. Qed. Lemma distance_non_nulle : forall A B : PO, scalaire (vec A B) (vec A B) <> 0 -> A <> B :>PO. intros; unfold not in |- *; intros. apply H. rewrite H0. replace (vec B B) with (mult_PP 0 (vec A B)). Simplscal. unfold vec in |- *; RingPP. Qed. Lemma distance_nulle : forall A B : PO, scalaire (vec A B) (vec A B) = 0 :>R -> A = B. intros. cut (vec A B = zero); intros. unfold vec in H0. apply conversion_PP with (a := 1) (b := 1); auto with *. RingPP2 H0; RingPP. apply scalaire_non_degenere; auto. Qed. Hint Resolve distance_nulle unitaire_distincts distance_non_nulle: geo. Lemma egalite_scalaire_alignes : forall A B C D : PO, A <> B -> alignes A B C -> alignes A B D -> scalaire (vec A B) (vec A C) = scalaire (vec A B) (vec A D) -> C = D. intros. halignes H0 ipattern:x. halignes H1 ipattern:x0. assert (x = x0). apply Rmult_eq_reg_l with (scalaire (vec A B) (vec A B)); auto with geo real. replace (scalaire (vec A B) (vec A B) * x) with (scalaire (vec A B) (vec A C)). rewrite H2; rewrite H4; Simplscal. rewrite H3; Simplscal. apply egalite_vecteur_point with A. rewrite H3; rewrite H5; rewrite H4; auto. Qed. HighSchoolGeometry/projection_orthogonale.v0000644000076500007650000000761212117747636021211 0ustar coqcoq00000000000000(* This program is free software; you can redistribute it and/or *) (* modify it under the terms of the GNU Lesser General Public License *) (* as published by the Free Software Foundation; either version 2.1 *) (* of the License, or (at your option) any later version. *) (* *) (* This program is distributed in the hope that it will be useful, *) (* but WITHOUT ANY WARRANTY; without even the implied warranty of *) (* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *) (* GNU General Public License for more details. *) (* *) (* You should have received a copy of the GNU Lesser General Public *) (* License along with this program; if not, write to the Free *) (* Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA *) (* 02110-1301 USA *) Require Export orthogonalite. Set Implicit Arguments. Unset Strict Implicit. Parameter projete_orthogonal : PO -> PO -> PO -> PO. Axiom def_projete_orthogonal : forall A B C H : PO, A <> B -> alignes A B H -> orthogonal (vec A B) (vec H C) -> H = projete_orthogonal A B C. Axiom def_projete_orthogonal2 : forall A B C H : PO, A <> B -> H = projete_orthogonal A B C -> alignes A B H /\ orthogonal (vec A B) (vec H C). Lemma existence_projete_orthogonal : forall A B C : PO, A <> B -> exists H : PO, H = projete_orthogonal A B C. intros A B C H0; try assumption. elim existence_representant_mult_vecteur with (A := A) (B := A) (C := B) (k := / scalaire (vec A B) (vec A B) * scalaire (vec A B) (vec A C)); intros H H1; try clear existence_representant_mult_vecteur. exists H. apply def_projete_orthogonal; auto. apply (colineaire_alignes H1). apply def_orthogonal2. cut (scalaire (vec A B) (vec A B) <> 0); intros; auto with geo. VReplace (vec H C) (add_PP (mult_PP 1 (vec A C)) (mult_PP (-1) (vec A H))). rewrite H1. FVReplace (mult_PP (-1) (mult_PP (/ scalaire (vec A B) (vec A B) * scalaire (vec A B) (vec A C)) (vec A B))) (mult_PP (- (/ scalaire (vec A B) (vec A B) * scalaire (vec A B) (vec A C))) (vec A B)) (scalaire (vec A B) (vec A B)). Simplscal. field; auto. Qed. Theorem scalaire_deux_projetes : forall A B C H K : PO, A <> B -> A <> C -> H = projete_orthogonal A B C -> K = projete_orthogonal A C B -> scalaire (vec A B) (vec A C) = scalaire (vec A B) (vec A H) /\ scalaire (vec A B) (vec A C) = scalaire (vec A K) (vec A C). intros. elim (def_projete_orthogonal2 (A:=A) (B:=B) (C:=C) (H:=H)); auto; intros. elim (def_projete_orthogonal2 (A:=A) (B:=C) (C:=B) (H:=K)); auto; intros. split; [ try assumption | idtac ]. apply scalaire_avec_projete; auto. rewrite scalaire_sym. rewrite (scalaire_sym A K A C). apply scalaire_avec_projete; auto. Qed. Ltac soit_projete A B C H := elim (existence_projete_orthogonal (A:=A) (B:=B) C); [ intros H; intros | auto ]; elim (def_projete_orthogonal2 (A:=A) (B:=B) (C:=C) (H:=H)); auto; intros. Lemma existence_perpendiculaire : forall A B C : PO, A <> B -> exists D : PO, orthogonal (vec A B) (vec C D). intros A B C H0; try assumption. soit_projete A B C ipattern:H. exists H. auto with geo. Qed. Lemma projete_axe : forall A B M H : PO, A <> B :>PO -> H = projete_orthogonal A B M :>PO -> alignes A B M -> H = M :>PO. intros. elim (def_projete_orthogonal2 (A:=A) (B:=B) (C:=M) (H:=H)); auto; intros. apply (unicite_projete_orthogonal (A:=A) (B:=B) (C:=M) (H:=H) (H':=M)); auto. VReplace (vec M M) zero. auto with geo. Qed. Lemma projete_non_axe : forall A B M H : PO, A <> B :>PO -> H = projete_orthogonal A B M :>PO -> ~ alignes A B M -> M <> H :>PO. intros. elim (def_projete_orthogonal2 (A:=A) (B:=B) (C:=M) (H:=H)); auto; intros. red in |- *; intros; apply H2. rewrite H5; auto. Qed.HighSchoolGeometry/puissance_cercle.v0000755000076500007650000001773312073525613017741 0ustar coqcoq00000000000000(* This program is free software; you can redistribute it and/or *) (* modify it under the terms of the GNU Lesser General Public License *) (* as published by the Free Software Foundation; either version 2.1 *) (* of the License, or (at your option) any later version. *) (* *) (* This program is distributed in the hope that it will be useful, *) (* but WITHOUT ANY WARRANTY; without even the implied warranty of *) (* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *) (* GNU General Public License for more details. *) (* *) (* You should have received a copy of the GNU Lesser General Public *) (* License along with this program; if not, write to the Free *) (* Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA *) (* 02110-1301 USA *) Require Export contact. Set Implicit Arguments. Unset Strict Implicit. Lemma scalaire_diametre : forall A A' B O M : PO, A <> B -> O = milieu A A' -> cercle_diametre A A' B -> alignes A B M -> scalaire (vec M A) (vec M B) = Rsqr (distance M O) + - Rsqr (distance O A). intros A A' B O M H0 H1 H2 H3; try assumption. generalize H2; unfold cercle_diametre in |- *; intros. elim H4; [ intros O' H5; elim H5; [ intros H6 H7; try clear H5 H4; try exact H7 ] ]. assert (O' = O). rewrite H1; auto. rewrite H in H6; clear H O' H7. discrimine A A'. assert (A = B). apply cercle_diametre_degenere with A'; auto. rewrite <- H4. rewrite (scalaire_difference_carre (A:=A') (B:=A) (I:=O) M); auto with geo. elim (classic (alignes A A' B)); intros. assert (B = A'). elim alignes_diametre with (A := A) (B := B) (A' := A'); [ intros H12; try clear alignes_diametre | intros H12; try clear alignes_diametre; try exact H12 | auto | auto ]. absurd (A = B); auto. rewrite H5. rewrite (scalaire_difference_carre (A:=A) (B:=A') (I:=O) M); auto. assert (triangle A A' B); auto with geo. discrimine M A. unfold Rsqr in |- *; repeat rewrite <- carre_scalaire_distance. VReplace (vec A O) (mult_PP (-1) (vec O A)). VReplace (vec A A) (mult_PP 0 (vec O A)). Simplscal. rewrite <- (scalaire_avec_projete (A:=M) (B:=A) (C:=A') (H:=B)); auto. apply scalaire_difference_carre; auto. apply alignes_ordre_cycle2; auto. assert (orthogonal (vec B A) (vec B A')). apply triangle_diametre with O; auto with geo. apply circonscrit_permute; auto. halignes H3 ipattern:k. replace (vec M A) with (mult_PP k (vec B A)). Simplortho. VReplace (vec M A) (mult_PP (-1) (vec A M)). rewrite H9; Ringvec. Qed. Theorem puissance_cercle : forall A B C D M : PO, triangle A B C -> C <> D -> sont_cocycliques A B C D -> alignes A B M -> alignes C D M -> scalaire (vec M A) (vec M B) = scalaire (vec M C) (vec M D). intros A B C D M H H20 H0 H2 H3; try assumption. elim cocycliques_existence_diametre with (A := A) (B := B) (C := C) (D := D); [ intros A' H1; try clear cocycliques_existence_diametre; try exact H1 | auto ]. generalize H0; generalize H1; unfold sont_cocycliques, diametre_circonscrit in |- *; intros. elim H4; [ intros O1 H6; elim H6; [ intros H7 H8; try clear H6 H4; try exact H8 ] ]. elim H5; [ intros O H4; elim H4; [ intros H6 H9; try clear H4 H5; try exact H9 ] ]. assert (O1 = O). apply (unicite_circonscrit_triangle H H8 H6); auto. rewrite H4 in H7; clear H8 H4. deroule_triangle A B C. deroule_circonscrit A B C O. rewrite (scalaire_diametre (A:=A) (A':=A') (B:=B) (O:=O) (M:=M)); auto. hcercle H9; hcercle H6. replace (Rsqr (distance O A)) with (Rsqr (distance O C)). symetrique O C ipattern:C'. rewrite (scalaire_diametre (A:=C) (A':=C') (B:=D) (O:=O) (M:=M)); auto. apply changement_diametre with (2 := H6); auto. rewrite <- H18; auto. apply circonscrit_diametre with (1 := H6); auto. Qed. Theorem puissance_cercle_tangente : forall A B C O M : PO, triangle A B C -> circonscrit O A B C -> alignes A B M -> tangente_cercle O A C M -> Rsqr (distance M C) = scalaire (vec M A) (vec M B). unfold tangente_cercle in |- *; intros; applatit_and. symetrique O A ipattern:A'. deroule_triangle A B C. deroule_circonscrit A B C O. hcercle H0. clear H3. rewrite (scalaire_diametre (A:=A) (A':=A') (B:=B) (O:=O) (M:=M)); auto. elim (Pythagore C O M); intros. replace (Rsqr (distance O A)) with (Rsqr (distance O C)). rewrite (distance_sym M O). rewrite H3; auto with geo. rewrite (distance_sym M C); rewrite (distance_sym O C); ring. rewrite <- H15; auto. apply circonscrit_diametre with (1 := H0); auto. Qed. Theorem egalite_puissance_cocycliques : forall A B C D M : PO, triangle A B C -> M <> C -> alignes A B M -> alignes C D M -> scalaire (vec M A) (vec M B) = scalaire (vec M C) (vec M D) -> sont_cocycliques A B C D. unfold sont_cocycliques in |- *; intros A B C D M H10 H0 H1 H2 H3. elim existence_cercle_circonscrit with (A := A) (B := B) (C := C); [ intros O H4; try clear existence_cercle_circonscrit; try exact H4 | auto ]. exists O; split; auto. elim existence_projete_orthogonal with (A := M) (B := C) (C := O); [ intros H H6; try clear existence_projete_orthogonal; try exact H6 | auto ]. elim def_projete_orthogonal2 with (A := M) (B := C) (C := O) (H := H); [ intros; auto | auto | auto ]. assert (alignes M C D); auto with geo. halignes H8 ipattern:k'. halignes H5 ipattern:k. discrimine H C. assert (Rsqr (distance M C) = scalaire (vec M A) (vec M B)). apply puissance_cercle_tangente with O; auto. hcercle H4. rewrite <- H12. replace (vec H M) with (mult_PP (- k) (vec M C)). auto with geo. VReplace (vec H M) (mult_PP (-1) (vec M H)). rewrite H11; Ringvec. assert (k' = 1). apply Rmult_eq_reg_l with (scalaire (vec M C) (vec M C)); auto with geo. replace (scalaire (vec M C) (vec M C) * k') with (scalaire (vec M C) (vec M D)). rewrite carre_scalaire_distance. unfold Rsqr in H13. rewrite H13; rewrite H3; ring. rewrite H9; Simplscal. assert (D = C). apply egalite_vecteur_point with M. rewrite H9; rewrite H14; Ringvec. rewrite H15; auto. elim intersection2_cercle_droite with (A := C) (B := M) (O := O) (H := H); [ intros E H13; elim H13; [ intros H14 H15; elim H15; [ unfold cercle_rayon, isocele in |- *; intros H16 H17; try clear H15 H13; try exact H17 ] ] | auto | auto | auto | auto ]. assert (sont_cocycliques A B C E). exists O; split; auto. generalize H4; unfold circonscrit, isocele in |- *; intros; applatit_and. split; [ try assumption | idtac ]. rewrite <- H17; auto. assert (scalaire (vec M C) (vec M D) = scalaire (vec M C) (vec M E)). rewrite <- H3. apply puissance_cercle; auto. auto with geo. assert (alignes M C E); auto with geo. halignes H18 ipattern:k1. assert (k' = k1). apply Rmult_eq_reg_l with (scalaire (vec M C) (vec M C)); auto with geo. replace (scalaire (vec M C) (vec M C) * k') with (scalaire (vec M C) (vec M D)). rewrite H15; rewrite H19; Simplscal. rewrite H9; Simplscal. assert (D = E). apply egalite_vecteur_point with M. rewrite H9; rewrite H20; rewrite H19; auto. rewrite H21. generalize H13; unfold sont_cocycliques in |- *; intros. elim H22; [ intros O1 H23; elim H23; [ intros H24 H25; try clear H23 H22; try exact H25 ] ]. assert (O1 = O). apply (unicite_circonscrit_triangle H10 H24 H4); auto. rewrite H22 in H25; auto. deroule_circonscrit A B C O. try exact H15. apply def_projete_orthogonal; auto with geo. apply projete_distance_Rlt with M; auto. Qed. Lemma puissance_cercle_tangente_rec : forall A B C O M : PO, triangle A B C -> circonscrit O A B C -> alignes A B M -> Rsqr (distance M C) = scalaire (vec M A) (vec M B) -> tangente_cercle O A C M. intros. deroule_circonscrit A B C O. deroule_triangle A B C. hcercle H0. symetrique O A ipattern:A'. rewrite (scalaire_diametre (A:=A) (A':=A') (B:=B) (O:=O) (M:=M)) in H2; auto. elim (Pythagore C M O); intros. apply H15. rewrite (distance_sym C M). rewrite H2; rewrite H12. rewrite (distance_sym O C); ring. apply circonscrit_diametre with (1 := H0); auto. Qed. Definition puissance_point_cercle (M O A : PO) := Rsqr (distance O M) + - Rsqr (distance O A).HighSchoolGeometry/reflexion_plane.v0000644000076500007650000006404112073525611017571 0ustar coqcoq00000000000000(* This program is free software; you can redistribute it and/or *) (* modify it under the terms of the GNU Lesser General Public License *) (* as published by the Free Software Foundation; either version 2.1 *) (* of the License, or (at your option) any later version. *) (* *) (* This program is distributed in the hope that it will be useful, *) (* but WITHOUT ANY WARRANTY; without even the implied warranty of *) (* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *) (* GNU General Public License for more details. *) (* *) (* You should have received a copy of the GNU Lesser General Public *) (* License along with this program; if not, write to the Free *) (* Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA *) (* 02110-1301 USA *) Require Export isocele. Set Implicit Arguments. Unset Strict Implicit. Parameter reflexion : PO -> PO -> PO -> PO. Axiom reflexion_def : forall A B M M' H : PO, A <> B -> H = projete_orthogonal A B M -> M' = reflexion A B M -> vec M M' = mult_PP 2 (vec M H). Axiom reflexion_def2 : forall A B M M' H : PO, A <> B -> H = projete_orthogonal A B M -> vec M M' = mult_PP 2 (vec M H) -> M' = reflexion A B M. Lemma reflexion_axe : forall A B M : PO, A <> B -> alignes A B M -> M = reflexion A B M. intros A B M H2 H0; try assumption. elim existence_projete_orthogonal with (A := A) (B := B) (C := M); [ intros H H3; try clear existence_projete_orthogonal; try exact H3 | auto ]. apply reflexion_def2 with H; auto. cut (M = H); intros. rewrite <- H1; Ringvec. rewrite H3. apply def_projete_orthogonal; auto. replace (vec M M) with zero; auto with geo. Ringvec. Qed. Hint Resolve reflexion_axe: geo. Lemma reflexion_projete_orthogonal_milieu : forall A B M M' H : PO, A <> B -> H = projete_orthogonal A B M -> M' = reflexion A B M -> H = milieu M M'. intros. generalize (reflexion_def (A:=A) (B:=B) (M:=M) (M':=M') (H:=H)); intros H5. cut (2 <> 0); intros. apply vecteur_milieu. rewrite H5; auto. replace (mult_PP (/ 2) (mult_PP 2 (vec M H))) with (mult_PP (/ 2 * 2) (vec M H)). replace (/ 2 * 2) with 1. Ringvec. auto with real. Ringvec. discrR. Qed. Lemma reflexion_image_distinct : forall A B M M' : PO, ~ alignes A B M -> M' = reflexion A B M -> M <> M'. intros A B M M' H0 H1; try assumption. cut (A <> B); intros H2; [ idtac | auto with geo ]. elim existence_projete_orthogonal with (A := A) (B := B) (C := M); [ intros H H3; try clear existence_projete_orthogonal; try exact H3 | auto ]. generalize (reflexion_def (A:=A) (B:=B) (M:=M) (M':=M') (H:=H)); intros H5. generalize (reflexion_projete_orthogonal_milieu (A:=A) (B:=B) (M:=M) (M':=M') (H:=H)); intros. cut (M <> H); intros. apply dist_non_nulle. unfold not in |- *; intros; apply H6. apply distance_nulle. rewrite (milieu_vecteur2 (A:=M) (B:=M') (M:=H)); auto. Simplscal. rewrite carre_scalaire_distance; rewrite H7; ring. unfold not in |- *; intros; apply H0. rewrite H6. elim def_projete_orthogonal2 with (A := A) (B := B) (C := M) (H := H); [ intros; try exact H7 | auto | auto ]. Qed. Lemma reflexion_mediatrice : forall A B M M' : PO, ~ alignes A B M -> M' = reflexion A B M -> mediatrice M M' A /\ mediatrice M M' B. intros A B M M' H1 H3; try assumption. cut (A <> B); intros H0; [ idtac | auto with geo ]. elim existence_projete_orthogonal with (A := A) (B := B) (C := M); [ intros H H2; try clear existence_projete_orthogonal | auto ]. generalize (reflexion_image_distinct (A:=A) (B:=B) (M:=M) (M':=M')); intros H5. generalize (reflexion_projete_orthogonal_milieu (A:=A) (B:=B) (M:=M) (M':=M') (H:=H)); intros. generalize (reflexion_def (A:=A) (B:=B) (M:=M) (M':=M') (H:=H)); intros. elim def_projete_orthogonal2 with (A := A) (B := B) (C := M) (H := H); [ intros | auto | auto ]. halignes H7 ipattern:k. split; [ try assumption | idtac ]. elim (classic (H = A)); intros. rewrite <- H10. apply milieu_mediatrice; auto. apply orthogonale_segment_milieu_mediatrice with H; auto. apply ortho_sym. cut (orthogonal (vec A B) (vec M M')); intros. replace (vec H A) with (mult_PP (- k) (vec A B)). Simplortho. replace (vec H A) with (mult_PP (-1) (vec A H)). rewrite H9. Ringvec. Ringvec. apply ortho_sym. rewrite H6; auto. Simplortho. elim (classic (H = B)); intros. rewrite <- H10. apply milieu_mediatrice; auto. apply orthogonale_segment_milieu_mediatrice with H; auto. apply ortho_sym. cut (orthogonal (vec A B) (vec M M')); intros. replace (vec H B) with (add_PP (mult_PP (- k) (vec A B)) (mult_PP 1 (vec A B))). Simplortho. replace (mult_PP (- k) (vec A B)) with (mult_PP (-1) (mult_PP k (vec A B))). rewrite <- H9. Ringvec. Ringvec. apply ortho_sym. rewrite H6; auto. Simplortho. Qed. Lemma reflexion_axe_orthogonal_segment : forall A B M M' : PO, ~ alignes A B M -> M' = reflexion A B M -> orthogonal (vec M M') (vec A B). intros. assert (A <> B); auto with geo. apply ortho_sym; auto. elim (reflexion_mediatrice (A:=A) (B:=B) (M:=M) (M':=M')); auto; intros. apply mediatrice_orthogonale_segment; auto. apply reflexion_image_distinct with (2 := H0); auto. Qed. Lemma projete_orthogonal_image : forall A B M M' H : PO, A <> B -> H = projete_orthogonal A B M -> M' = reflexion A B M -> H = projete_orthogonal A B M'. intros. generalize (reflexion_def (A:=A) (B:=B) (M:=M) (M':=M') (H:=H)); intros H5. generalize (reflexion_projete_orthogonal_milieu (A:=A) (B:=B) (M:=M) (M':=M') (H:=H)); intros. elim def_projete_orthogonal2 with (A := A) (B := B) (C := M) (H := H); [ intros | auto | auto ]. apply def_projete_orthogonal; auto. apply ortho_sym. replace (vec H M') with (vec M H); auto with geo. Qed. Lemma non_axe_image_non_axe : forall A B M M' : PO, ~ alignes A B M -> M' = reflexion A B M -> ~ alignes A B M'. intros A B M M' H0 H2; try assumption. cut (A <> B); intros H1; [ idtac | auto with geo ]. elim existence_projete_orthogonal with (A := A) (B := B) (C := M); [ intros H H3; try clear existence_projete_orthogonal; try exact H3 | auto ]. generalize (reflexion_def (A:=A) (B:=B) (M:=M) (M':=M') (H:=H)); intros H5. generalize (reflexion_projete_orthogonal_milieu (A:=A) (B:=B) (M:=M) (M':=M') (H:=H)); intros. elim reflexion_mediatrice with (A := A) (B := B) (M := M) (M' := M'); [ intros H6 H7; try clear reflexion_mediatrice; try exact H7 | auto | auto ]. generalize (mediatrice_orthogonale_segment (A:=M) (B:=M') (M:=A) (N:=B)); intros. generalize (reflexion_image_distinct (A:=A) (B:=B) (M:=M) (M':=M')); intros. elim def_projete_orthogonal2 with (A := A) (B := B) (C := M) (H := H); [ intros | auto | auto ]. cut (H = projete_orthogonal A B M'); intros. cut (M' <> H); intros. unfold not in |- *; intros; apply H13. rewrite H12. apply def_projete_orthogonal; auto. replace (vec M' M') with zero. apply zero_ortho_tout. Ringvec. rewrite H4; auto. apply milieu_distinct2; auto. apply projete_orthogonal_image with M; auto. Qed. Lemma reflexion_symetrie : forall A B M M' : PO, A <> B -> M' = reflexion A B M -> M = reflexion A B M'. intros A B M M' H1 H0; try assumption. elim (classic (alignes A B M)); intros H20. rewrite H0. rewrite <- reflexion_axe. rewrite <- reflexion_axe; auto. auto. rewrite <- reflexion_axe; auto. elim existence_projete_orthogonal with (A := A) (B := B) (C := M); [ intros H H3; try clear existence_projete_orthogonal; try exact H3 | auto ]. generalize (reflexion_def (A:=A) (B:=B) (M:=M) (M':=M') (H:=H)); intros H5. generalize (reflexion_projete_orthogonal_milieu (A:=A) (B:=B) (M:=M) (M':=M') (H:=H)); intros. generalize (projete_orthogonal_image (A:=A) (B:=B) (M:=M) (M':=M') (H:=H)); intros. generalize (non_axe_image_non_axe (A:=A) (B:=B) (M:=M) (M':=M')); intros. apply reflexion_def2 with H; auto with geo. Qed. Lemma reflexion_isocele : forall A B M M' : PO, A <> B -> M' = reflexion A B M -> isocele A M M'. intros. elim (classic (alignes A B M)); intros. replace M' with M; auto. unfold isocele in |- *; auto. rewrite H0; rewrite <- reflexion_axe; auto. apply mediatrice_isocele. elim (reflexion_mediatrice (A:=A) (B:=B) (M:=M) (M':=M')); auto. Qed. Lemma axe_reflexion_droite : forall A B C M M' : PO, A <> B -> A <> C -> alignes A B C -> M' = reflexion A B M -> M' = reflexion C A M. intros A B C M M' H10 H0 H1 H2; try assumption. elim existence_projete_orthogonal with (A := A) (B := B) (C := M); [ intros H H4; try clear existence_projete_orthogonal; try exact H3 | auto ]. halignes H1 ipattern:k. elim def_projete_orthogonal2 with (A := A) (B := B) (C := M) (H := H); [ intros | auto | auto ]. apply reflexion_def2 with H; auto. apply def_projete_orthogonal. auto. halignes H5 ipattern:k0. elim (classic (k = 0)); intros. absurd (A = C); auto. rewrite H8 in H3. apply conversion_PP with (a := 1) (b := 1); auto with real. RingPP2 H3. Ringvec. apply colineaire_alignes with (/ k * (k + - k0)). replace (vec C H) with (add_PP (vec A H) (mult_PP (-1) (vec A C))). replace (vec C A) with (mult_PP (-1) (vec A C)). rewrite H7; rewrite H3. replace (mult_PP (/ k * (k + - k0)) (mult_PP (-1) (mult_PP k (vec A B)))) with (mult_PP (/ k * (k + - k0) * (-1 * k)) (vec A B)). replace (/ k * (k + - k0) * (-1 * k)) with (/ k * k * (-1 * (k + - k0))). replace (/ k * k) with 1. Ringvec. auto with real. ring. Ringvec. Ringvec. Ringvec. replace (vec C A) with (add_PP (mult_PP 0 (vec A B)) (mult_PP (- k) (vec A B))). apply ortho_combinaison_lineaire; auto. replace (vec C A) with (mult_PP (-1) (vec A C)). rewrite H3. Ringvec. Ringvec. rewrite (reflexion_def (A:=A) (B:=B) (M:=M) (M':=M') (H:=H)); auto. Qed. Theorem axe_reflexion_bissectrice : forall A B M M' : PO, ~ alignes A B M -> M' = reflexion A B M -> cons_AV (vec A M) (vec A B) = cons_AV (vec A B) (vec A M'). intros A B M M' H1 H2; try assumption. cut (A <> B); intros H0; [ idtac | auto with geo ]. elim existence_projete_orthogonal with (A := A) (B := B) (C := M); [ intros H H4; try clear existence_projete_orthogonal; try exact H3 | auto ]. generalize (non_axe_image_non_axe (A:=A) (B:=B) (M:=M) (M':=M')); intros. generalize (non_alignes_distincts (A:=A) (B:=B) (C:=M')); intros. generalize (non_alignes_distincts (A:=A) (B:=B) (C:=M)); intros. elim def_projete_orthogonal2 with (A := A) (B := B) (C := M) (H := H); [ intros; try exact H13 | auto | auto ]. elim (classic (A = H)); intros. generalize (reflexion_projete_orthogonal_milieu (A:=A) (B:=B) (M:=M) (M':=M') (H:=H)); intros. apply milieu_angles_orthogonaux; auto. apply reflexion_image_distinct with (2 := H2); auto. rewrite H9; auto. generalize (reflexion_def (A:=A) (B:=B) (M:=M) (M':=M') (H:=H)); intros. replace (vec M M') with (add_PP (mult_PP (-1) (vec H M)) (mult_PP (-1) (vec H M))). apply ortho_combinaison_lineaire; apply ortho_sym; auto. rewrite H11; auto. Ringvec. cut (cons_AV (vec A M) (vec A H) = cons_AV (vec A H) (vec A M')); intros; auto. rewrite angles_representants_unitaires; auto. rewrite angles_representants_unitaires; auto. elim existence_representant_unitaire with (A := A) (B := H); [ intros; try clear existence_representant_unitaire | auto ]. elim existence_representant_unitaire with (A := A) (B := M'); [ intros; try clear existence_representant_unitaire | auto ]. elim existence_representant_unitaire with (A := A) (B := M); [ intros; try clear existence_representant_unitaire | auto ]. elim alignes_representant_unitaire with (A := A) (B := B) (C := H); [ intros; try clear alignes_representant_unitaire; auto | intros; auto | auto | auto | auto ]. rewrite H14. rewrite <- angles_representants_unitaires; auto. rewrite <- angles_representants_unitaires; auto. replace (representant_unitaire (vec A B)) with (mult_PP (-1) (representant_unitaire (vec A H))). cut (A <> x); intros. replace (mult_PP (-1) (representant_unitaire (vec A H))) with (vec x A). replace (cons_AV (representant_unitaire (vec A M)) (vec x A)) with (plus (cons_AV (representant_unitaire (vec A M)) (vec A x)) (cons_AV (vec A x) (vec x A))). replace (cons_AV (vec x A) (representant_unitaire (vec A M'))) with (plus (cons_AV (vec x A) (vec A x)) (cons_AV (vec A x) (representant_unitaire (vec A M')))). rewrite <- angle_plat; auto. rewrite <- angle_plat; auto. rewrite H11. rewrite <- angles_representants_unitaires; auto. rewrite <- angles_representants_unitaires; auto. rewrite <- H10; auto. mesure A M A H. replace (x2 + pi) with (pi + x2); (try ring; auto). rewrite <- H12. cut (A <> x0); intros. rewrite Chasles; auto. apply distance_non_nulle. elim def_representant_unitaire2 with (A := A) (B := M') (C := x0); [ intros; elim H17; intros H22 H23; try clear H17 def_representant_unitaire2; rewrite H22; try discrR | auto | auto ]. rewrite <- H13. cut (A <> x1); intros. rewrite Chasles; auto. apply distance_non_nulle. elim def_representant_unitaire2 with (A := A) (B := M) (C := x1); [ intros; elim H17; intros H22 H23; try clear H18 def_representant_unitaire2; rewrite H22; try discrR | auto | auto ]. rewrite <- H11; Ringvec. apply distance_non_nulle. elim def_representant_unitaire2 with (A := A) (B := H) (C := x); [ intros; elim H16; intros H22 H23; try clear H18 def_representant_unitaire2; rewrite H22; try discrR | auto | auto ]. rewrite H14. elim existence_representant_unitaire with (A := A) (B := B); [ intros; try clear existence_representant_unitaire | auto ]. rewrite <- H15; Ringvec. generalize (reflexion_image_distinct (A:=A) (B:=B) (M:=M) (M':=M')); intros. generalize (reflexion_mediatrice (A:=A) (B:=B) (M:=M) (M':=M')); intros. elim H11; auto; intros. generalize (reflexion_projete_orthogonal_milieu (A:=A) (B:=B) (M:=M) (M':=M') (H:=H)); intros. apply mediatrice_milieu_angles; auto. Qed. Lemma reflexion_isocele2 : forall A B M M' : PO, A <> B -> M' = reflexion A B M -> isocele B M M'. intros. apply reflexion_isocele with A; auto. apply axe_reflexion_droite with B; auto with geo. Qed. Lemma reflexion_inverse_angle : forall A B M M' : PO, A <> B -> M <> A -> M <> B -> M' = reflexion A B M -> cons_AV (vec M' A) (vec M' B) = opp (cons_AV (vec M A) (vec M B)). intros. elim (classic (alignes A B M)); intros. replace M' with M; auto. cut (double_AV (cons_AV (vec M A) (vec M B)) = image_angle 0); intros. replace (opp (cons_AV (vec M A) (vec M B))) with (plus (image_angle 0) (opp (cons_AV (vec M A) (vec M B)))); auto. rewrite <- H4; unfold double_AV in |- *. mesure M A M B. replace (x + x + - x) with x; auto. ring. mesure M A M B. replace (0 + - x) with (- x); auto. ring. apply angle_alignes; auto with geo. rewrite H2; rewrite <- reflexion_axe; auto. cut (M <> M'); intros. cut (~ alignes A B M'); intros. cut (A <> M'); intros. cut (B <> M'); intros. replace (cons_AV (vec M A) (vec M B)) with (plus (cons_AV (vec M A) (vec M M')) (cons_AV (vec M M') (vec M B))). rewrite opp_plus_plus_opp; auto. rewrite def_opp; auto. lapply (reflexion_isocele (A:=A) (B:=B) (M:=M) (M':=M')); auto; intros. lapply (reflexion_isocele2 (A:=A) (B:=B) (M:=M) (M':=M')); auto; intros. lapply (isocele_angles_base (A:=A) (B:=M) (C:=M')); auto; intros. lapply (isocele_angles_base (A:=B) (B:=M) (C:=M')); auto; intros. rewrite H11; auto. rewrite H10; auto. rewrite def_opp; auto. rewrite Chasles; auto. rewrite Chasles; auto. lapply (non_alignes_distincts2 (A:=A) (B:=B) (C:=M')); auto; intros. lapply (non_alignes_distincts (A:=A) (B:=B) (C:=M')); auto; intros. apply non_axe_image_non_axe with M; auto. apply reflexion_image_distinct with (2 := H2); auto. Qed. Lemma reflexion_isometrie : forall A B M M' N N' : PO, A <> B -> M' = reflexion A B M -> N' = reflexion A B N -> distance M N = distance M' N'. intros. discrimine M N. rewrite H2 in H0. rewrite H0; rewrite <- H1. rewrite distance_refl2; auto. rewrite distance_refl2; auto. elim (classic (alignes A B M)); intros. replace M' with M; auto. elim (classic (alignes A B N)); intros. replace N' with N; auto. rewrite H1; rewrite <- reflexion_axe; auto. cut (A <> N); intros. cut (A <> N'); intros. discrimine M A. elim (reflexion_mediatrice (A:=A) (B:=B) (M:=N) (M':=N')); auto; unfold mediatrice in |- *; intros. lapply (axe_reflexion_droite (A:=A) (B:=B) (C:=M) (M:=N) (M':=N')); auto; intros. elim (reflexion_mediatrice (A:=M) (B:=A) (M:=N) (M':=N')); auto with geo; unfold mediatrice in |- *; intros. lapply (alignes_non_alignes_trans (A:=A) (B:=B) (C:=N) (D:=M)); auto with geo; intros. lapply (non_alignes_distincts (A:=A) (B:=B) (C:=N')); auto with geo; intros. apply non_axe_image_non_axe with N; auto with geo. apply non_alignes_distincts with B; auto with geo. rewrite H0; rewrite <- reflexion_axe; auto. cut (A <> M); intros. cut (A <> M'); intros. elim (classic (alignes A B N)); intros. replace N' with N; auto. discrimine N A. rewrite distance_sym; rewrite (distance_sym M' A). elim (reflexion_mediatrice (A:=A) (B:=B) (M:=M) (M':=M')); auto with geo; unfold mediatrice in |- *; intros. lapply (axe_reflexion_droite (A:=A) (B:=B) (C:=N) (M:=M) (M':=M')); auto with geo; intros. rewrite distance_sym; rewrite (distance_sym M' N). elim (reflexion_mediatrice (A:=N) (B:=A) (M:=M) (M':=M')); auto with geo; unfold mediatrice in |- *; intros. lapply (alignes_non_alignes_trans (A:=A) (B:=B) (C:=M) (D:=N)); auto with geo; intros. rewrite H1; rewrite <- reflexion_axe; auto. cut (A <> N); intros. cut (A <> N'); intros. elim cas_egalite_triangle_indirect with (A := A) (B := M) (C := N) (A' := A) (B' := M') (C' := N'); (auto; intros). elim (reflexion_mediatrice (A:=A) (B:=B) (M:=M) (M':=M')); auto with geo; unfold mediatrice in |- *; intros. elim (reflexion_mediatrice (A:=A) (B:=B) (M:=N) (M':=N')); auto with geo; unfold mediatrice in |- *; intros. replace (cons_AV (vec A M) (vec A N)) with (plus (cons_AV (vec A M) (vec A B)) (cons_AV (vec A B) (vec A N))). rewrite (axe_reflexion_bissectrice (A:=A) (B:=B) (M:=M) (M':=M')); auto. replace (cons_AV (vec A B) (vec A N)) with (cons_AV (vec A N') (vec A B)). replace (plus (cons_AV (vec A B) (vec A M')) (cons_AV (vec A N') (vec A B))) with (plus (cons_AV (vec A N') (vec A B)) (cons_AV (vec A B) (vec A M'))). rewrite Chasles; auto. mesure A B A M'. mesure A N' A B. replace (x0 + x) with (x + x0); auto. ring. apply permute_angles; auto. rewrite (axe_reflexion_bissectrice (A:=A) (B:=B) (M:=N) (M':=N')); auto. rewrite Chasles; auto. lapply (non_alignes_distincts (A:=A) (B:=B) (C:=N')); auto; intros. apply non_axe_image_non_axe with N; auto. apply non_alignes_distincts with B; auto. lapply (non_alignes_distincts (A:=A) (B:=B) (C:=M')); auto; intros. apply non_axe_image_non_axe with M; auto. apply non_alignes_distincts with B; auto. Qed. Lemma reflexion_inverse_AMN : forall A B M M' N N' : PO, A <> B -> A <> M -> A <> N -> M' = reflexion A B M -> N' = reflexion A B N -> cons_AV (vec A M') (vec A N') = opp (cons_AV (vec A M) (vec A N)). intros. elim (classic (alignes A B M)); intros. replace M' with M; auto. elim (classic (alignes A B N)); intros. replace N' with N; auto. lapply (alignes_trans (A:=A) (B:=B) (C:=M) (D:=N)); auto; intros. cut (double_AV (cons_AV (vec A M) (vec A N)) = image_angle 0); intros. replace (opp (cons_AV (vec A M) (vec A N))) with (plus (image_angle 0) (opp (cons_AV (vec A M) (vec A N)))); auto. rewrite <- H7; unfold double_AV in |- *. mesure A M A N. replace (x + x + - x) with x; auto. ring. rewrite plus_commutative; auto with geo. apply angle_alignes; auto. rewrite H3; rewrite <- reflexion_axe; auto. cut (A <> N'); intros. lapply (axe_reflexion_droite (A:=A) (B:=B) (C:=M) (M:=N) (M':=N')); auto; intros. rewrite <- (axe_reflexion_bissectrice (A:=A) (B:=M) (M:=N) (M':=N')); auto. rewrite def_opp; auto. lapply (alignes_non_alignes_trans (A:=A) (B:=B) (C:=N) (D:=M)); auto; intros. lapply (axe_reflexion_droite (A:=M) (B:=A) (C:=A) (M:=N) (M':=N')); auto with geo; intros. lapply (non_alignes_distincts (A:=A) (B:=B) (C:=N')); auto; intros. apply non_axe_image_non_axe with N; auto. rewrite H2; rewrite <- reflexion_axe; auto. cut (A <> M'); intros. elim (classic (alignes A B N)); intros. replace N' with N; auto. lapply (axe_reflexion_droite (A:=A) (B:=B) (C:=N) (M:=M) (M':=M')); auto; intros. rewrite (axe_reflexion_bissectrice (A:=A) (B:=N) (M:=M) (M':=M')); auto. rewrite def_opp; auto. lapply (alignes_non_alignes_trans (A:=A) (B:=B) (C:=M) (D:=N)); auto; intros. lapply (axe_reflexion_droite (A:=N) (B:=A) (C:=A) (M:=M) (M':=M')); auto with geo; intros. rewrite H3; rewrite <- reflexion_axe; auto. cut (A <> N'); intros. replace (cons_AV (vec A M) (vec A N)) with (plus (cons_AV (vec A M) (vec A B)) (cons_AV (vec A B) (vec A N))). rewrite (axe_reflexion_bissectrice (A:=A) (B:=B) (M:=M) (M':=M')); auto. replace (cons_AV (vec A B) (vec A N)) with (cons_AV (vec A N') (vec A B)). replace (plus (cons_AV (vec A B) (vec A M')) (cons_AV (vec A N') (vec A B))) with (plus (cons_AV (vec A N') (vec A B)) (cons_AV (vec A B) (vec A M'))). rewrite Chasles; auto. rewrite def_opp; auto. mesure A B A M'. mesure A N' A B. replace (x0 + x) with (x + x0); auto. ring. apply permute_angles; auto. rewrite (axe_reflexion_bissectrice (A:=A) (B:=B) (M:=N) (M':=N')); auto. rewrite Chasles; auto. lapply (non_alignes_distincts (A:=A) (B:=B) (C:=N')); auto; intros. apply non_axe_image_non_axe with N; auto. apply non_alignes_distincts with B; auto. apply non_axe_image_non_axe with M; auto. Qed. Theorem reflexion_anti_deplacement : forall A B M M' N N' P P' : PO, A <> B -> M <> N -> M <> P -> N <> P -> M' = reflexion A B M -> N' = reflexion A B N -> P' = reflexion A B P -> cons_AV (vec M' N') (vec M' P') = opp (cons_AV (vec M N) (vec M P)). intros. cut (M' <> N'); intros. cut (M' <> P'); intros. discrimine M A. cut (M' = A); intros. rewrite H9. cut (A <> N); intros. cut (A <> P); intros. apply reflexion_inverse_AMN with B; auto. red in |- *; intros; apply H1. rewrite H8; auto. red in |- *; intros; apply H0. rewrite H8; auto. rewrite H3; rewrite H8; rewrite <- reflexion_axe; auto with geo. discrimine N A. cut (N' = A); intros. rewrite H10. cut (A <> P); intros. elim cas_egalite_triangle_indirect with (A := A) (B := M) (C := P) (A' := A) (B' := M') (C' := P'); (auto; intros). elim H13; intros. rewrite <- H14; rewrite def_opp; auto. rewrite (reflexion_isometrie (A:=A) (B:=B) (M:=A) (M':=A) (N:=M) (N':=M')); auto with geo. rewrite (reflexion_isometrie (A:=A) (B:=B) (M:=A) (M':=A) (N:=P) (N':=P')); auto with geo. rewrite (reflexion_inverse_AMN (A:=A) (B:=B) (M:=P) (M':=P') (N:=M) (N':=M')); auto. rewrite def_opp; auto. red in |- *; intros; apply H2. rewrite H9; auto. rewrite H4; rewrite H9; rewrite <- reflexion_axe; auto with geo. discrimine P A. cut (P' = A); intros. rewrite H11. elim cas_egalite_triangle_indirect with (A := A) (B := M) (C := N) (A' := A) (B' := M') (C' := N'); (auto; intros). elim H13; intros. rewrite H14; rewrite def_opp; auto. red in |- *; intros; apply H7. rewrite H16; auto. rewrite (reflexion_isometrie (A:=A) (B:=B) (M:=A) (M':=A) (N:=M) (N':=M')); auto with geo. rewrite (reflexion_isometrie (A:=A) (B:=B) (M:=A) (M':=A) (N:=N) (N':=N')); auto with geo. rewrite (reflexion_inverse_AMN (A:=A) (B:=B) (M:=N) (M':=N') (N:=M) (N':=M')); auto. rewrite def_opp; auto. rewrite H5; rewrite H10; rewrite <- reflexion_axe; auto with geo. cut (A <> M'); intros. elim cas_egalite_triangle_indirect with (A := A) (B := M) (C := N) (A' := A) (B' := M') (C' := N'); (auto; intros). elim H13; intros. elim cas_egalite_triangle_indirect with (A := A) (B := M) (C := P) (A' := A) (B' := M') (C' := P'); (auto; intros). elim H17; intros. replace (cons_AV (vec M N) (vec M P)) with (plus (cons_AV (vec M N) (vec M A)) (cons_AV (vec M A) (vec M P))). replace (cons_AV (vec M A) (vec M P)) with (cons_AV (vec M' P') (vec M' A)). rewrite H14. replace (plus (cons_AV (vec M' A) (vec M' N')) (cons_AV (vec M' P') (vec M' A))) with (plus (cons_AV (vec M' P') (vec M' A)) (cons_AV (vec M' A) (vec M' N'))). rewrite Chasles; auto. rewrite def_opp; auto. mesure M' P' M' A. mesure M' A M' N'. replace (x + x0) with (x0 + x); auto. ring. apply permute_angles; auto. rewrite Chasles; auto. rewrite (reflexion_isometrie (A:=A) (B:=B) (M:=A) (M':=A) (N:=M) (N':=M')); auto with geo. rewrite (reflexion_isometrie (A:=A) (B:=B) (M:=A) (M':=A) (N:=P) (N':=P')); auto with geo. rewrite (reflexion_inverse_AMN (A:=A) (B:=B) (M:=P) (M':=P') (N:=M) (N':=M')); auto. rewrite def_opp; auto. rewrite (reflexion_isometrie (A:=A) (B:=B) (M:=A) (M':=A) (N:=M) (N':=M')); auto with geo. rewrite (reflexion_isometrie (A:=A) (B:=B) (M:=A) (M':=A) (N:=N) (N':=N')); auto with geo. rewrite (reflexion_inverse_AMN (A:=A) (B:=B) (M:=N) (M':=N') (N:=M) (N':=M')); auto. rewrite def_opp; auto. apply (isometrie_distinct (A:=A) (B:=M) (A':=A) (B':=M')); auto with geo. rewrite (reflexion_isometrie (A:=A) (B:=B) (M:=A) (M':=A) (N:=M) (N':=M')); auto with geo. apply (isometrie_distinct (A:=M) (B:=P) (A':=M') (B':=P')); auto. rewrite (reflexion_isometrie (A:=A) (B:=B) (M:=M) (M':=M') (N:=P) (N':=P')); auto. apply (isometrie_distinct (A:=M) (B:=N) (A':=M') (B':=N')); auto. rewrite (reflexion_isometrie (A:=A) (B:=B) (M:=M) (M':=M') (N:=N) (N':=N')); auto. Qed. Lemma mediatrices_reflexion : forall A B M M' : PO, M <> M' -> ~ alignes A B M -> mediatrice M M' A -> mediatrice M M' B -> M' = reflexion A B M. intros A B M M' H0 H1 H2 H3; try assumption. cut (A <> B); intros H; [ idtac | auto with geo ]. soit_milieu M M' ipattern:K. apply reflexion_def2 with K; auto with geo. apply def_projete_orthogonal; auto. discrimine K A. apply alignes_ordre_cycle; auto. apply mediatrice_droite with (2 := H4); auto. cut (orthogonal (vec M M') (vec A B)); intros. apply ortho_sym. replace (vec K M) with (mult_PP (-1) (vec M K)). rewrite (milieu_vecteur2 (A:=M) (B:=M') (M:=K)); auto. replace (mult_PP (-1) (mult_PP (/ 2) (vec M M'))) with (mult_PP (- / 2) (vec M M')). Simplortho. cut (2 <> 0); intros; auto with real. Fieldvec 2. Ringvec. apply ortho_sym. apply mediatrice_orthogonale_segment; auto. Qed. Lemma existence_reflexion_AB : forall A B M : PO, A <> B -> exists M' : PO, M' = reflexion A B M. intros A B M H1; try assumption. elim existence_projete_orthogonal with (A := A) (B := B) (C := M); [ intros H H4; try clear existence_projete_orthogonal; try exact H3 | auto ]. elim existence_representant_vecteur with (A := H) (B := M) (C := H); intros M' H3; try clear existence_representant_vecteur; try exact H3. exists M'. apply reflexion_def2 with H; auto. replace (vec M M') with (add_PP (vec M H) (vec H M')). rewrite H3; Ringvec. Ringvec. Qed.HighSchoolGeometry/repere_ortho_plan.v0000644000076500007650000001536612073525611020134 0ustar coqcoq00000000000000(* This program is free software; you can redistribute it and/or *) (* modify it under the terms of the GNU Lesser General Public License *) (* as published by the Free Software Foundation; either version 2.1 *) (* of the License, or (at your option) any later version. *) (* *) (* This program is distributed in the hope that it will be useful, *) (* but WITHOUT ANY WARRANTY; without even the implied warranty of *) (* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *) (* GNU General Public License for more details. *) (* *) (* You should have received a copy of the GNU Lesser General Public *) (* License along with this program; if not, write to the Free *) (* Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA *) (* 02110-1301 USA *) Require Export repere_plan. Require Export distance_euclidienne. Set Implicit Arguments. Unset Strict Implicit. Definition repere_orthogonal (O I J : PO) := repere O I J /\ scalaire (vec O I) (vec O J) = 0. Lemma triangle_rectangle_repere : forall O I J : PO, O <> I -> O <> J -> orthogonal (vec O I) (vec O J) -> repere_orthogonal O I J. intros; red in |- *. cut (scalaire (vec O I) (vec O J) = 0); intros. split; [ idtac | try assumption ]. red in |- *; red in |- *; red in |- *; intros. halignes H3 ipattern:k. rewrite H4 in H2. rewrite scalaire_mult_d in H2. elim (classic (k = 0)); intros. rewrite H5 in H4. absurd (O = J); auto. apply vecteur_nul_conf. rewrite H4; Ringvec. absurd (O = I); auto. apply distance_nulle. elim Rmult_integral with (r1 := k) (r2 := scalaire (vec O I) (vec O I)); [ intros H6; try clear without_div_Od | intros H6; try clear without_div_Od; try exact H6 | auto ]. absurd (k = 0); auto. apply def_orthogonal; auto. Qed. Definition repere_orthonormal (O I J : PO) := scalaire (vec O I) (vec O J) = 0 /\ scalaire (vec O I) (vec O I) = 1 /\ scalaire (vec O J) (vec O J) = 1. Lemma orthonormal_orthogonal : forall O I J : PO, repere_orthonormal O I J -> repere_orthogonal O I J. unfold repere_orthonormal in |- *; intros. elim H; intros H0 H1; elim H1; intros H2 H3; try clear H1 H; try exact H3. apply triangle_rectangle_repere; auto with geo. Qed. Hint Resolve orthonormal_orthogonal: geo. Lemma orthonormal_repere : forall O I J : PO, repere_orthonormal O I J -> repere O I J. intros. cut (repere_orthogonal O I J); intros; auto with geo. elim H0; auto. Qed. Hint Resolve orthonormal_repere: geo. Lemma orthonormal_non_alignes : forall O I J : PO, repere_orthonormal O I J -> ~ alignes O I J. intros. cut (repere O I J); intros; auto with geo. Qed. Hint Resolve orthonormal_non_alignes: geo. Lemma orthogonal_paralleles : forall A B C E F : PO, A <> B -> A <> C -> orthogonal (vec A B) (vec A C) -> orthogonal (vec E F) (vec A B) -> exists k : R, vec E F = mult_PP k (vec A C). intros. cut (repere_orthogonal A B C); intros. elim H3; intros. generalize (composantes_vecteur (O:=A) (I:=B) (J:=C) E F); intros. elim H6; [ intros x H7; elim H7; [ intros y H8; try clear H7 H6; try exact H8 ] | auto ]. cut (scalaire (vec E F) (vec A B) = 0); auto with geo; intros. cut (x = 0); intros. rewrite H8; rewrite H7. exists y. Ringvec. cut (x * scalaire (vec A B) (vec A B) = 0); intros. elim Rmult_integral with (r1 := scalaire (vec A B) (vec A B)) (r2 := x); [ intros H12; try clear without_div_Od; try trivial | intros H12; try trivial | try trivial ]. absurd (scalaire (vec A B) (vec A B) = 0); auto with geo. rewrite <- H7; ring. rewrite <- H6; auto with geo. rewrite H8. Simplscal. rewrite (scalaire_sym A C A B). rewrite H5; ring. apply triangle_rectangle_repere; auto with geo. Qed. Lemma orthogonal_colineaires : forall A B C D E F : PO, A <> B :>PO -> C <> D :>PO -> orthogonal (vec A B) (vec C D) -> orthogonal (vec A B) (vec E F) -> ex (fun k : R => vec E F = mult_PP k (vec C D) :>PP). intros. elim existence_representant_vecteur with (A := A) (B := C) (C := D); intros C1 H5; try clear existence_representant_vecteur; try exact H5. rewrite <- H5. elim orthogonal_paralleles with (A := A) (B := B) (C := C1) (E := E) (F := F); [ intros k H3; try clear orthogonal_paralleles; try exact H3 | auto | auto | auto | auto with geo ]. exists k; auto. apply distinct_egalite_vecteur with (2 := H5); auto. rewrite H5; auto with geo. Qed. Lemma scalaire_coordonnees : forall (O I J M N : PO) (x y x' y' : R), repere_orthonormal O I J -> vec O M = add_PP (mult_PP x (vec O I)) (mult_PP y (vec O J)) -> vec O N = add_PP (mult_PP x' (vec O I)) (mult_PP y' (vec O J)) -> scalaire (vec O M) (vec O N) = x * x' + y * y'. unfold repere_orthonormal in |- *; intros. rewrite H0; rewrite H1. Simplscal. elim H; intros H4 H5; elim H5; intros H6 H7; try clear H5 H; try exact H7. rewrite H7; rewrite H6; rewrite H4; rewrite scalaire_sym; rewrite H4; ring. Qed. Lemma scalaire_composantes_ABCD : forall (O I J A B C D : PO) (x y x' y' : R), repere_orthonormal O I J -> vec A B = add_PP (mult_PP x (vec O I)) (mult_PP y (vec O J)) -> vec C D = add_PP (mult_PP x' (vec O I)) (mult_PP y' (vec O J)) -> scalaire (vec A B) (vec C D) = x * x' + y * y'. intros. elim existence_representant_vecteur with (A := O) (B := A) (C := B); [ intros M H20 ]. elim existence_representant_vecteur with (A := O) (B := C) (C := D); [ intros N H21 ]. rewrite <- H20; rewrite <- H21. rewrite (scalaire_coordonnees (O:=O) (I:=I) (J:=J) (M:=M) (N:=N) (x:=x) (y:=y) (x':=x') (y':=y')); auto with geo. rewrite H20; auto. rewrite H21; auto. Qed. Lemma coordonnees_scalaire_base : forall O I J M : PO, repere_orthonormal O I J -> vec O M = add_PP (mult_PP (scalaire (vec O M) (vec O I)) (vec O I)) (mult_PP (scalaire (vec O M) (vec O J)) (vec O J)). intros. elim existence_coordonnees with (O := O) (I := I) (J := J) (M := M); [ intros x H1; elim H1; intros y H2; try clear H1; try exact H2 | auto with geo ]. elim H; intros H1 H11; elim H11; intros H3 H4; try clear H11; try exact H4. cut (x = scalaire (vec O M) (vec O I) /\ y = scalaire (vec O M) (vec O J)); intros. elim H0; intros H6 H7; try clear H5; try exact H7. rewrite <- H7; rewrite <- H6; auto. rewrite H2. split; [ try assumption | idtac ]. Simplscal. rewrite H3; rewrite scalaire_sym; rewrite H1; ring. Simplscal. rewrite H4; rewrite H1; ring. Qed. Lemma distance_coordonnees : forall (O I J M : PO) (x y : R), repere_orthonormal O I J -> vec O M = add_PP (mult_PP x (vec O I)) (mult_PP y (vec O J)) :>PP -> distance O M = sqrt (Rsqr x + Rsqr y) :>R. unfold distance in |- *; intros. rewrite (scalaire_coordonnees (O:=O) (I:=I) (J:=J) (M:=M) (N:=M) (x:=x) (y:=y) (x':=x) (y':=y)); eauto. Qed. Hint Resolve distance_coordonnees: geo.HighSchoolGeometry/repere_plan.v0000644000076500007650000001410012117747636016716 0ustar coqcoq00000000000000(* This program is free software; you can redistribute it and/or *) (* modify it under the terms of the GNU Lesser General Public License *) (* as published by the Free Software Foundation; either version 2.1 *) (* of the License, or (at your option) any later version. *) (* *) (* This program is distributed in the hope that it will be useful, *) (* but WITHOUT ANY WARRANTY; without even the implied warranty of *) (* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *) (* GNU General Public License for more details. *) (* *) (* You should have received a copy of the GNU Lesser General Public *) (* License along with this program; if not, write to the Free *) (* Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA *) (* 02110-1301 USA *) Require Export coplanarite. Require Export barycentre. Set Implicit Arguments. Unset Strict Implicit. Axiom geometrie_plane : forall A B C D : PO, coplanaires A B C D. Hint Resolve geometrie_plane: geo. Definition repere (O I J : PO) := triangle O I J. Lemma existence_coordonnees : forall O I J M : PO, repere O I J -> exists x : R, (exists y : R, vec O M = add_PP (mult_PP x (vec O I)) (mult_PP y (vec O J))). unfold repere, triangle in |- *; intros. assert (coplanaires O I J M); auto with geo. hcoplanaires H0 ipattern:k ipattern:k'. exists k; exists k'; auto. Qed. Lemma unicite_coordonnees : forall (O I J M : PO) (x y x' y' : R), repere O I J -> vec O M = add_PP (mult_PP x (vec O I)) (mult_PP y (vec O J)) -> vec O M = add_PP (mult_PP x' (vec O I)) (mult_PP y' (vec O J)) -> x = x' /\ y = y'. unfold vec, repere in |- *; intros. deroule_triangle O I J. cut (cons 1 M = add_PP (add_PP (cons x I) (cons y J)) (cons (1 + - (x + y)) O)); intros. apply unicite_coor_bar2 with (2 := H6); auto. auto with geo. RingPP2 H1. RingPP. RingPP2 H0. RingPP. Qed. Lemma composantes_vecteur : forall O I J M N : PO, repere O I J -> exists x : R, (exists y : R, vec M N = add_PP (mult_PP x (vec O I)) (mult_PP y (vec O J))). unfold repere, triangle in |- *; intros. assert (coplanaires O I J M); auto with geo. hcoplanaires H0 ipattern:k ipattern:k'. assert (coplanaires O I J N); auto with geo. hcoplanaires H1 ipattern:k0 ipattern:k'0. replace (vec M N) with (add_PP (vec O N) (mult_PP (-1) (vec O M))). rewrite H1; rewrite H0. exists (k0 + -1 * k); exists (k'0 + -1 * k'). Ringvec. Ringvec. Qed. Parameter abscisse : PO -> R. Parameter ordonnee : PO -> R. Axiom abscisse_def : forall (O I J M : PO) (x y : R), repere O I J -> vec O M = add_PP (mult_PP x (vec O I)) (mult_PP y (vec O J)) :>PP -> x = abscisse M. Axiom ordonnee_def : forall (O I J M : PO) (x y : R), repere O I J -> vec O M = add_PP (mult_PP x (vec O I)) (mult_PP y (vec O J)) :>PP -> y = ordonnee M. Axiom cart_def : forall (O I J M : PO) (x y : R), repere O I J -> x = abscisse M -> y = ordonnee M -> vec O M = add_PP (mult_PP x (vec O I)) (mult_PP y (vec O J)) :>PP. Lemma composantes_vecAB : forall (a1 a2 b1 b2 : R) (O I J A B : PO), repere O I J -> a1 = abscisse A -> a2 = ordonnee A -> b1 = abscisse B -> b2 = ordonnee B -> vec A B = add_PP (mult_PP (b1 + - a1) (vec O I)) (mult_PP (b2 + - a2) (vec O J)) :>PP. intros. generalize (cart_def (O:=O) (I:=I) (J:=J) (M:=A) (x:=a1) (y:=a2)); intros. generalize (cart_def (O:=O) (I:=I) (J:=J) (M:=B) (x:=b1) (y:=b2)); intros. replace (vec A B) with (add_PP (vec O B) (mult_PP (-1) (vec O A))); [ idtac | Ringvec ]. rewrite H4; auto. rewrite H5; auto. Ringvec. Qed. Parameter absvec : PP -> R. Parameter ordvec : PP -> R. Axiom absvec_def : forall (a b : R) (O I J M N : PO), repere O I J -> vec M N = add_PP (mult_PP a (vec O I)) (mult_PP b (vec O J)) :>PP -> a = absvec (vec M N). Axiom ordvec_def : forall (a b : R) (O I J M N : PO), repere O I J -> vec M N = add_PP (mult_PP a (vec O I)) (mult_PP b (vec O J)) :>PP -> b = ordvec (vec M N). Axiom cartvec_def : forall (a b : R) (O I J M N : PO), repere O I J -> a = absvec (vec M N) -> b = ordvec (vec M N) -> vec M N = add_PP (mult_PP a (vec O I)) (mult_PP b (vec O J)) :>PP. Lemma unicite_composantes_vecteur : forall (a1 a2 b1 b2 : R) (O I J A B : PO), repere O I J -> vec A B = add_PP (mult_PP a1 (vec O I)) (mult_PP a2 (vec O J)) :>PP -> vec A B = add_PP (mult_PP b1 (vec O I)) (mult_PP b2 (vec O J)) :>PP -> a1 = b1 :>R /\ a2 = b2 :>R. intros. elim existence_representant_vecteur with (A := O) (B := A) (C := B); [ intros D H2; try clear existence_representant_vecteur; try exact H2 ]. rewrite <- H2 in H0. rewrite <- H2 in H1. apply (unicite_coordonnees (O:=O) (I:=I) (J:=J) (M:=D) (x:=a1) (y:=a2) (x':=b1) (y':=b2)); auto. Qed. Lemma cartvec_AB : forall (a1 a2 b1 b2 : R) (O I J A B : PO), repere O I J -> a1 = abscisse A :>R -> a2 = ordonnee A :>R -> b1 = abscisse B :>R -> b2 = ordonnee B :>R -> b1 + - a1 = absvec (vec A B) :>R /\ b2 + - a2 = ordvec (vec A B) :>R. intros. apply (unicite_composantes_vecteur (a1:=b1 + - a1) (a2:= b2 + - a2) (b1:=absvec (vec A B)) (b2:=ordvec (vec A B)) (O:=O) (I:=I) (J:=J) (A:=A) (B:=B)); auto. apply composantes_vecAB; auto. apply cartvec_def; auto. Qed. Hint Resolve abscisse_def ordonnee_def cartvec_AB unicite_composantes_vecteur absvec_def ordvec_def: geo. Lemma absvec_abscisse : forall O I J M : PO, repere O I J -> absvec (vec O M) = abscisse M. intros. elim existence_coordonnees with (O := O) (I := I) (J := J) (M := M); [ intros x H0; elim H0; [ intros y H1; try clear H0; try exact H1 ] | auto ]. rewrite <- (absvec_def H H1); eauto with geo. Qed. Lemma ordvec_ordonnee : forall O I J M : PO, repere O I J -> ordvec (vec O M) = ordonnee M. intros. elim existence_coordonnees with (O := O) (I := I) (J := J) (M := M); [ intros x H0; elim H0; [ intros y H1; try clear H0; try exact H1 ] | auto ]. rewrite <- (ordvec_def H H1); eauto with geo. Qed.HighSchoolGeometry/representant_unitaire.v0000644000076500007650000003406312117747636021046 0ustar coqcoq00000000000000(* This program is free software; you can redistribute it and/or *) (* modify it under the terms of the GNU Lesser General Public License *) (* as published by the Free Software Foundation; either version 2.1 *) (* of the License, or (at your option) any later version. *) (* *) (* This program is distributed in the hope that it will be useful, *) (* but WITHOUT ANY WARRANTY; without even the implied warranty of *) (* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *) (* GNU General Public License for more details. *) (* *) (* You should have received a copy of the GNU Lesser General Public *) (* License along with this program; if not, write to the Free *) (* Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA *) (* 02110-1301 USA *) Require Export orthogonalite. Set Implicit Arguments. Unset Strict Implicit. Hint Resolve distance_non_nulle scalaire_positif: geo. Lemma existence_unitaire : forall A B : PO, A <> B -> exists C : PO, alignes A B C /\ scalaire (vec A C) (vec A C) = 1 /\ scalaire (vec A B) (vec A C) >= 0. intros. cut (ex (fun C : PO => vec A C = mult_PP (/ sqrt (scalaire (vec A B) (vec A B))) (vec A B))); intros. elim H0; intros C H1; try clear H0; try exact H1. cut (/ sqrt (scalaire (vec A B) (vec A B)) * / sqrt (scalaire (vec A B) (vec A B)) * scalaire (vec A B) (vec A B) = 1); intros. exists C. split; [ try assumption | idtac ]. apply colineaire_alignes with (/ sqrt (scalaire (vec A B) (vec A B))); auto. rewrite H1. split; [ try assumption | idtac ]. Simplscal. rewrite <- H0; ring. Simplscal. apply Rmult_pos; auto with *. replace (/ sqrt (scalaire (vec A B) (vec A B)) * / sqrt (scalaire (vec A B) (vec A B))) with (/ (sqrt (scalaire (vec A B) (vec A B)) * sqrt (scalaire (vec A B) (vec A B)))); auto with real. rewrite def_sqrt; auto. auto with *. auto with *. apply Rinv_mult_distr; auto with *. apply existence_representant_mult_vecteur; auto. Qed. Lemma scalaire_non_nul : forall A B C : PO, A <> B -> alignes A B C -> scalaire (vec A C) (vec A C) = 1 -> scalaire (vec A B) (vec A C) >= 0 -> scalaire (vec A B) (vec A C) <> 0. intros. halignes H0 ipattern:k. rewrite H3. replace (scalaire (vec A B) (mult_PP k (vec A B))) with (k * scalaire (vec A B) (vec A B)). cut (scalaire (vec A B) (vec A B) <> 0 /\ k <> 0); intros. cut (~ (k = 0 \/ scalaire (vec A B) (vec A B) = 0)); intros. unfold not in |- *; intros; apply H5. apply Rmult_integral; auto with *. tauto. split; [ try assumption | idtac ]. auto with geo. elim (classic (k = 0)); auto; intros. rewrite H4 in H3. rewrite H3 in H1. absurd (0 = 1); auto with *. rewrite <- H1. Simplscal. Simplscal. Qed. Hint Resolve scalaire_non_nul: geo. Lemma unicite_representant_unitaire : forall A B C D : PO, A <> B -> alignes A B C -> scalaire (vec A C) (vec A C) = 1 -> scalaire (vec A B) (vec A C) >= 0 -> alignes A B D -> scalaire (vec A D) (vec A D) = 1 -> scalaire (vec A B) (vec A D) >= 0 -> C = D. intros. halignes H0 ipattern:k. halignes H3 ipattern:k0. cut (k = k0); intros. apply conversion_PP with (a := 1) (b := 1); auto with *. RingPP2 H6. RingPP2 H7. rewrite H8; RingPP. apply resolution; auto. replace k with (k * scalaire (vec A B) (vec A C) * / scalaire (vec A B) (vec A C)). replace (k * scalaire (vec A B) (vec A C)) with (scalaire (mult_PP k (vec A B)) (vec A C)). rewrite <- H6; rewrite H1. replace (1 * / scalaire (vec A B) (vec A C)) with (/ scalaire (vec A B) (vec A C)); try ring. apply Rinv_le_pos; auto with geo real. Simplscal. field. auto with geo. replace k0 with (k0 * scalaire (vec A B) (vec A D) * / scalaire (vec A B) (vec A D)). replace (k0 * scalaire (vec A B) (vec A D)) with (scalaire (mult_PP k0 (vec A B)) (vec A D)). rewrite <- H7; rewrite H4. replace (1 * / scalaire (vec A B) (vec A D)) with (/ scalaire (vec A B) (vec A D)); try ring. apply Rinv_le_pos; auto with geo real. Simplscal. field. auto with geo. cut (scalaire (vec A C) (vec A C) = scalaire (vec A D) (vec A D)); intros. rewrite H7 in H8; rewrite H6 in H8. replace (k * k) with (scalaire (mult_PP k (vec A B)) (mult_PP k (vec A B)) * / scalaire (vec A B) (vec A B)). replace (k0 * k0) with (scalaire (mult_PP k0 (vec A B)) (mult_PP k0 (vec A B)) * / scalaire (vec A B) (vec A B)). rewrite H8; auto. field_simplify_eq. Simplscal. auto with geo. field_simplify_eq. Simplscal. auto with geo. rewrite H4; auto. Qed. Parameter representant_unitaire : PP -> PP. Axiom def_representant_unitaire : forall A B C : PO, A <> B -> alignes A B C -> scalaire (vec A C) (vec A C) = 1 -> scalaire (vec A B) (vec A C) >= 0 -> vec A C = representant_unitaire (vec A B). Axiom def_representant_unitaire2 : forall A B C : PO, A <> B -> vec A C = representant_unitaire (vec A B) -> alignes A B C /\ scalaire (vec A C) (vec A C) = 1 /\ scalaire (vec A B) (vec A C) >= 0. Lemma existence_representant_unitaire : forall A B : PO, A <> B -> exists C : PO, vec A C = representant_unitaire (vec A B). intros A B H; try assumption. elim existence_unitaire with (A := A) (B := B); [ intros C H0; try clear existence_unitaire; try exact H0 | auto ]. exists C. elim H0; intros H1 H2; elim H2; intros H3 H4; try clear H2 H0; try exact H4. apply def_representant_unitaire; auto. Qed. Ltac applatit_and := match goal with | h:(_ /\ _) |- _ => elim h; intros; clear h end. Ltac deroule_representant_unitaire A B C := elim (existence_representant_unitaire (A:=A) (B:=B)); auto; intros C; intros; elim (def_representant_unitaire2 (A:=A) (B:=B) (C:=C)); auto; intros; applatit_and; cut (A <> C); intros; [ idtac | auto with geo ]. Lemma produit_positif_representant_unitaire : forall (k : R) (A B C : PO), A <> B :>PO -> k > 0 -> vec A C = mult_PP k (vec A B) :>PP -> representant_unitaire (vec A B) = representant_unitaire (vec A C). intros. cut (A <> C); intros. 2: apply distinct_produit_vecteur with (3 := H1); auto with real. deroule_representant_unitaire A B ipattern:B'. rewrite <- H3. cut (scalaire (vec A C) (vec A B') >= 0); intros. apply def_representant_unitaire; auto. apply alignes_trans with B; auto. apply colineaire_alignes with k; auto. rewrite H1. replace (scalaire (mult_PP k (vec A B)) (vec A B')) with (k * scalaire (vec A B) (vec A B')); [ idtac | Simplscal ]. apply Rmult_pos; auto with geo. apply Rgt_ge; auto. Qed. Lemma egalite_representant_unitaire : forall A B C : PO, A <> B :>PO -> A <> C :>PO -> representant_unitaire (vec A B) = representant_unitaire (vec A C) :>PP -> exists k : R, k > 0 /\ vec A C = mult_PP k (vec A B) :>PP. intros A B C H H0; try assumption. elim existence_representant_unitaire with (A := A) (B := B); [ intros B' H3; try clear existence_representant_unitaire; rewrite <- H3 | auto ]. elim existence_representant_unitaire with (A := A) (B := C); [ intros C' H4; rewrite <- H4; intros | auto ]. elim def_representant_unitaire2 with (A := A) (B := B) (C := B'); [ intros | auto | auto ]. elim H5; intros H6 H7; try clear H5; try exact H7. elim def_representant_unitaire2 with (A := A) (B := C) (C := C'); [ intros | auto | auto ]. elim H8; intros H9 H10; try clear H8; try exact H10. cut (alignes A C' C); intros; auto with geo. assert (A <> C'); auto with geo. halignes H8 ipattern:k. halignes H2 ipattern:k0. exists (k * k0). split; [ idtac | try assumption ]. apply Rmult_gt_0_compat. elim Rtotal_order with (r1 := k) (r2 := 0); [ intros H14 | intros H14; elim H14; [ intros H15; try clear H14; try exact H15 | intros H15; try exact H15 ] ]. absurd (scalaire (vec A C) (vec A C') >= 0); auto. rewrite H12. replace (scalaire (mult_PP k (vec A C')) (vec A C')) with (k * scalaire (vec A C') (vec A C')); [ idtac | Simplscal ]. rewrite H9. replace (k * 1) with k; [ auto with real | ring ]. absurd (A = C); auto. apply vecteur_nul_conf. rewrite H12; rewrite H15; Ringvec. elim Rtotal_order with (r1 := k0) (r2 := 0); [ intros H16; try clear total_order | intros H16; elim H16; [ intros H17; try clear H16; try exact H17 | intros H17; try exact H17 ] ]. absurd (scalaire (vec A B) (vec A B') >= 0); auto. replace (vec A B) with (mult_PP (/ k0) (vec A B')); [ Simplscal | idtac ]. rewrite H6. replace (/ k0 * 1) with (/ k0); [ idtac | ring ]. cut (/ k0 < 0); intros; auto with real. rewrite H13. cut (k0 <> 0); intros; auto with real. Fieldvec k0. absurd (scalaire (vec A B') (vec A B') = 1); auto. rewrite H13; rewrite H17; Simplscal. replace (0 * 0 * scalaire (vec A B) (vec A B)) with 0; [ auto with real | ring ]. rewrite H12; rewrite <- H1; rewrite H13; Ringvec. Qed. Lemma representant_unitaire_bis : forall A B : PO, A <> B :>PO -> representant_unitaire (representant_unitaire (vec A B)) = representant_unitaire (vec A B) :>PP. intros A B H; try assumption. elim existence_representant_unitaire with (A := A) (B := B); [ intros B' H3; try clear existence_representant_unitaire; rewrite <- H3 | auto ]. elim def_representant_unitaire2 with (A := A) (B := B) (C := B'); [ intros | auto | auto ]. elim H1; intros H2 H4; try clear H1; try exact H4. cut (A <> B'); intros; auto with geo. elim existence_representant_unitaire with (A := A) (B := B'); [ intros C' H5; rewrite <- H5; intros | auto ]. elim def_representant_unitaire2 with (A := A) (B := B') (C := C'); [ intros | auto | auto ]. elim H7; intros H8 H9; try clear H7; try exact H9. cut (A <> C'); intros; auto with geo. halignes H6 ipattern:k. elim Rtotal_order with (r1 := k) (r2 := 0); [ intros H13 | intros H13; (elim H13; [ intros H14; try clear H13 | intros H14; try clear H13; try exact H14 ]) ]. absurd (scalaire (vec A B') (vec A C') >= 0); auto. rewrite H10. replace (scalaire (vec A B') (mult_PP k (vec A B'))) with (k * scalaire (vec A B') (vec A B')); [ idtac | Simplscal ]. rewrite H2. replace (k * 1) with k; [ auto with real | ring ]. absurd (A = C'); auto with geo. apply vecteur_nul_conf. rewrite H10; rewrite H14; Ringvec. elim (classic (k = 1)); intros. rewrite H10; rewrite H11; Ringvec. absurd (scalaire (vec A C') (vec A C') = 1); auto. rewrite H10; Simplscal; rewrite H2. replace (k * k * 1) with (Rsqr k) by (unfold Rsqr; ring). red in |- *; intros; apply H11. apply Rsqr_inj; auto with real. rewrite H12; unfold Rsqr in |- *; ring. Qed. Hint Resolve representant_unitaire_bis: geo. Lemma oppose_representant_unitaire : forall A B C : PO, A <> B :>PO -> A <> C :>PO -> representant_unitaire (vec A C) = mult_PP (-1) (representant_unitaire (vec A B)) :>PP -> exists k : R, k < 0 /\ vec A C = mult_PP k (vec A B) :>PP. intros A B C H H0; try assumption. elim existence_representant_unitaire with (A := A) (B := B); [ intros B' H3; try clear existence_representant_unitaire; rewrite <- H3 | auto ]. elim existence_representant_unitaire with (A := A) (B := C); [ intros C' H4; rewrite <- H4; intros | auto ]. elim def_representant_unitaire2 with (A := A) (B := B) (C := B'); [ intros | auto | auto ]. elim H5; intros H6 H7; try clear H5; try exact H7. elim def_representant_unitaire2 with (A := A) (B := C) (C := C'); [ intros | auto | auto ]. elim H8; intros H9 H10; try clear H8; try exact H10. cut (representant_unitaire (vec A C) = representant_unitaire (vec A C')); intros. elim egalite_representant_unitaire with (A := A) (B := C) (C := C'); [ intros k H12; try clear egalite_representant_unitaire; try exact H12 | auto with geo | auto with geo | auto with geo ]. elim H12; intros H13 H14; try clear H12; try exact H14. cut (representant_unitaire (vec A B) = representant_unitaire (vec A B')); intros. elim egalite_representant_unitaire with (A := A) (B := B) (C := B'); [ intros k0 H12; try clear egalite_representant_unitaire; try exact H12 | auto with geo | auto with geo | auto with geo ]. elim H12; intros H15 H16; try clear H12; try exact H16. cut (k <> 0); auto with real; intros. replace (vec A C) with (mult_PP (/ k) (vec A C')); idtac. rewrite H1; rewrite H16. exists (- (/ k * k0)). split; [ idtac | Ringvec ]. cut (/ k * k0 > 0); intros; auto with real. apply Rmult_gt_0_compat; auto with *. rewrite H14. Fieldvec k. rewrite H3; (symmetry in |- *; auto with geo). rewrite H4; (symmetry in |- *; auto with geo). Qed. Lemma produit_negatif_representant_unitaire : forall (k : R) (A B C : PO), A <> B -> k < 0 -> vec A C = mult_PP k (vec A B) -> representant_unitaire (vec A C) = mult_PP (-1) (representant_unitaire (vec A B)). intros. cut (A <> C); intros. 2: apply distinct_produit_vecteur with (3 := H1); auto. elim existence_representant_unitaire with (A := A) (B := B); [ intros B' H3; try clear existence_representant_unitaire; try exact H3 | auto ]. rewrite <- H3. elim def_representant_unitaire2 with (A := A) (B := B) (C := B'); [ intros; elim H5; intros H6 H7; try clear H5; try exact H6 | auto | auto ]. cut (- scalaire (vec A C) (vec A B') >= 0); intros. symmetry in |- *. elim existence_representant_mult_vecteur with (A := A) (B := A) (C := B') (k := -1); intros D H9; try clear existence_representant_mult_vecteur; rewrite <- H9. apply def_representant_unitaire; auto. apply alignes_trans with B; auto. apply colineaire_alignes with k; auto. halignes H4 ipattern:k0. apply colineaire_alignes with (- k0); auto. rewrite H9; rewrite H8; Ringvec. rewrite H9; Simplscal; auto. rewrite H9; Simplscal; auto. rewrite H1; Simplscal. apply Rmult_pos; auto. apply Rgt_ge; auto with real. auto with real. Qed. Lemma alignes_representant_unitaire : forall A B C : PO, A <> B :>PO -> A <> C :>PO -> alignes A B C -> representant_unitaire (vec A B) = representant_unitaire (vec A C) \/ representant_unitaire (vec A C) = mult_PP (-1) (representant_unitaire (vec A B)). intros. halignes H1 ipattern:k. elim Rtotal_order with (r1 := k) (r2 := 0); [ intros H3; try clear total_order | intros H3; elim H3; [ intros H4; try clear H3 total_order | intros H4; try clear H3 total_order; try exact H4 ] ]. right; try assumption. apply produit_negatif_representant_unitaire with k; auto. absurd (k = 0); auto. contrapose H0. apply (produit_zero_conf H2); auto. left; try assumption. apply produit_positif_representant_unitaire with k; auto. Qed. HighSchoolGeometry/rotation_plane.v0000644000076500007650000003665112117747636017457 0ustar coqcoq00000000000000(* This program is free software; you can redistribute it and/or *) (* modify it under the terms of the GNU Lesser General Public License *) (* as published by the Free Software Foundation; either version 2.1 *) (* of the License, or (at your option) any later version. *) (* *) (* This program is distributed in the hope that it will be useful, *) (* but WITHOUT ANY WARRANTY; without even the implied warranty of *) (* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *) (* GNU General Public License for more details. *) (* *) (* You should have received a copy of the GNU Lesser General Public *) (* License along with this program; if not, write to the Free *) (* Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA *) (* 02110-1301 USA *) Require Export metrique_triangle. Set Implicit Arguments. Unset Strict Implicit. Parameter rotation : PO -> R -> PO -> PO. Axiom rotation_def : forall (I A B : PO) (a : R), I <> A -> B = rotation I a A -> distance I A = distance I B /\ image_angle a = cons_AV (vec I A) (vec I B). Axiom rotation_def_centre : forall (I : PO) (a : R), I = rotation I a I. Axiom rotation_def2 : forall (I A B : PO) (a : R), I <> A -> distance I A = distance I B -> image_angle a = cons_AV (vec I A) (vec I B) -> B = rotation I a A. Lemma rotation_angle_nul : forall I A : PO, A = rotation I 0 A. intros. elim (classic (I = A)); intros. rewrite <- H. apply rotation_def_centre. apply rotation_def2; auto. apply angle_nul; auto. Qed. Lemma image_distinct_centre : forall (I A B : PO) (a : R), I <> A :>PO -> B = rotation I a A :>PO -> I <> B :>PO. intros; red in |- *; intros. apply H. elim rotation_def with (I := I) (A := A) (B := B) (a := a); [ unfold distance in |- *; intros | auto | auto ]. rewrite <- H1 in H2. apply distance_nulle. rewrite <- (def_sqrt (scalaire (vec I A) (vec I A))); auto with geo. rewrite H2. replace (scalaire (vec I I) (vec I I)) with 0. rewrite sqrt_0; ring. replace (vec I I) with (mult_PP 0 (vec I B)). Simplscal. Ringvec. Qed. Lemma rotation_inverse : forall (I A B : PO) (a : R), B = rotation I a A :>PO -> A = rotation I (- a) B :>PO. intros. elim (classic (I = A)); intros. rewrite <- H0. rewrite <- H0 in H. rewrite H; rewrite <- rotation_def_centre; auto. apply rotation_def_centre. elim rotation_def with (I := I) (A := A) (B := B) (a := a); [ try clear rotation_def; intros | auto | auto ]. apply rotation_def2; auto. apply image_distinct_centre with (2 := H); auto. rewrite <- (mes_oppx (A:=I) (B:=A) (C:=I) (D:=B) (x:=a)); auto. apply image_distinct_centre with (2 := H); auto. Qed. Lemma composee_rotations_meme_centre : forall (I A B C : PO) (a b : R), B = rotation I a A -> C = rotation I b B -> C = rotation I (a + b) A. intros. elim (classic (I = A)); intros. rewrite H0. rewrite H. rewrite <- H1. repeat rewrite <- rotation_def_centre; auto. generalize (image_distinct_centre (I:=I) (A:=A) (B:=B) (a:=a)); intros H5. generalize (image_distinct_centre (I:=I) (A:=B) (B:=C) (a:=b)); intros. elim rotation_def with (I := I) (A := A) (B := B) (a := a); [ try clear rotation_def; intros | auto | auto ]. elim rotation_def with (I := I) (A := B) (B := C) (a := b); [ try clear rotation_def; intros | auto | auto ]. apply rotation_def2; auto. rewrite H3; auto. rewrite add_mes_compatible. rewrite H7; rewrite H4; rewrite Chasles; auto. Qed. Theorem rotation_isometrie : forall (I A B A' B' : PO) (a : R), A' = rotation I a A -> B' = rotation I a B -> distance A' B' = distance A B. intros I A B A' B' a H H0; try assumption. apply distance_carre; auto. elim (classic (I = A)); intros. rewrite <- H1 in H. rewrite <- H1; rewrite H; repeat rewrite <- rotation_def_centre; auto. elim (classic (I = B)); intros. rewrite <- H2 in H0. rewrite H0; rewrite <- H2; repeat rewrite <- rotation_def_centre; auto. elim rotation_def with (I := I) (A := B) (B := B') (a := a); [ try clear rotation_def; intros | auto | auto ]. rewrite H3; auto. elim (classic (I = B)); intros. rewrite <- H2 in H0. rewrite H0; rewrite <- H2; repeat rewrite <- rotation_def_centre; auto. elim rotation_def with (I := I) (A := A) (B := A') (a := a); [ try clear rotation_def; intros | auto | auto ]. rewrite (distance_sym A I); auto. rewrite H3; rewrite distance_sym; auto. generalize (image_distinct_centre (I:=I) (A:=A) (B:=A') (a:=a)); intros H11. generalize (image_distinct_centre (I:=I) (A:=B) (B:=B') (a:=a)); intros H12. elim rotation_def with (I := I) (A := B) (B := B') (a := a); [ try clear rotation_def; intros | auto | auto ]. elim rotation_def with (I := I) (A := A) (B := A') (a := a); [ try clear rotation_def; intros | auto | auto ]. mesure I A I B. rewrite (Al_Kashi (A:=I) (B:=A) (C:=B) (a:=x)); auto. rewrite (Al_Kashi (A:=I) (B:=A') (C:=B') (a:=x)); auto. rewrite H5; rewrite H3; auto. rewrite H7. replace (cons_AV (vec I A') (vec I B')) with (plus (cons_AV (vec I A') (vec I A)) (plus (cons_AV (vec I A) (vec I B)) (cons_AV (vec I B) (vec I B')))). rewrite <- (mes_oppx (A:=I) (B:=A) (C:=I) (D:=A') (x:=a)); auto. rewrite <- H7; rewrite <- H4. rewrite <- add_mes_compatible; rewrite <- add_mes_compatible. replace (- a + (x + a)) with x; try ring; auto. rewrite Chasles; auto. rewrite Chasles; auto. Qed. Lemma rotation_IAB : forall (I A B A' B' : PO) (a : R), I <> A -> I <> B -> A' = rotation I a A -> B' = rotation I a B -> cons_AV (vec I A) (vec I B) = cons_AV (vec I A') (vec I B') :>AV. intros. generalize (isometrie_distinct (A:=I) (B:=B) (A':=I) (B':=B')); intros. generalize (isometrie_distinct (A:=I) (B:=A) (A':=I) (B':=A')); intros. elim rotation_def with (I := I) (A := B) (B := B') (a := a); [ try clear rotation_def; intros | auto | auto ]. elim rotation_def with (I := I) (A := A) (B := A') (a := a); [ try clear rotation_def; intros | auto | auto ]. replace (cons_AV (vec I A') (vec I B')) with (plus (cons_AV (vec I A') (vec I A)) (plus (cons_AV (vec I A) (vec I B)) (cons_AV (vec I B) (vec I B')))). rewrite <- H6. rewrite <- (mes_oppx (A:=I) (B:=A) (C:=I) (D:=A') (x:=a)); auto. mesure I A I B. replace (- a + (x + a)) with x; try ring; auto. rewrite Chasles; auto. rewrite Chasles; auto. Qed. Lemma image_bipoint_distinct : forall (I A B A' B' : PO) (a : R), A <> B :>PO -> A' = rotation I a A -> B' = rotation I a B -> A' <> B' :>PO. intros. generalize (rotation_isometrie (I:=I) (A:=A) (B:=B) (A':=A') (B':=B') (a:=a)); intros H7. apply (isometrie_distinct (A:=A) (B:=B)); auto. symmetry in |- *; auto. Qed. Theorem rotation_conserve_angle : forall (I A B C A' B' C' : PO) (a : R), A <> B :>PO -> A <> C :>PO -> A' = rotation I a A -> B' = rotation I a B -> C' = rotation I a C -> cons_AV (vec A B) (vec A C) = cons_AV (vec A' B') (vec A' C') :>AV. intros. generalize (image_bipoint_distinct (I:=I) (A:=A) (B:=C) (A':=A') (B':=C') (a:=a)); intros. generalize (image_bipoint_distinct (I:=I) (A:=A) (B:=B) (A':=A') (B':=B') (a:=a)); intros H11. elim (classic (I = A)); intros. rewrite <- H5 in H1; rewrite <- H5 in H; rewrite <- H5 in H0. rewrite H1; repeat rewrite <- rotation_def_centre; rewrite <- H5; auto. elim rotation_def with (I := I) (A := B) (B := B') (a := a); [ try clear rotation_def; intros | auto | auto ]. elim rotation_def with (I := I) (A := C) (B := C') (a := a); [ try clear rotation_def; intros | auto | auto ]. generalize (isometrie_distinct (A:=I) (B:=B) (A':=I) (B':=B')); intros H30. generalize (isometrie_distinct (A:=I) (B:=C) (A':=I) (B':=C')); intros H31. apply rotation_IAB with a; auto. elim (classic (I = B)); intros. rewrite <- H6 in H2; rewrite <- H6 in H. rewrite H2; repeat rewrite <- rotation_def_centre; rewrite <- H6; auto. elim rotation_def with (I := I) (A := A) (B := A') (a := a); [ try clear rotation_def; intros | auto | auto ]. elim (classic (I = C)); intros. rewrite <- H9 in H3; rewrite <- H9 in H0. rewrite H3; repeat rewrite <- rotation_def_centre; rewrite <- H9; auto. rewrite <- angle_nul; auto. rewrite <- angle_nul; auto. apply dist_non_nulle; rewrite distance_sym; rewrite <- H7; auto with geo. elim rotation_def with (I := I) (A := C) (B := C') (a := a); [ try clear rotation_def; intros | auto | auto ]. generalize (isometrie_distinct (A:=I) (B:=C) (A':=I) (B':=C')); intros H31. elim cas_egalite_triangle with (A := I) (B := A) (C := C) (A' := I) (B' := A') (C' := C'); (auto with geo; intros). elim H14; intros H15 H16; try clear H14; try exact H16. mesure A C A I. rewrite <- (mes_oppx (A:=A) (B:=C) (C:=A) (D:=I) (x:=x)); auto. rewrite <- (mes_oppx (A:=A') (B:=C') (C:=A') (D:=I) (x:=x)); auto. apply dist_non_nulle; rewrite distance_sym; rewrite <- H7; auto with geo. rewrite H14; rewrite H15; auto. generalize (isometrie_distinct (A:=I) (B:=A) (A':=I) (B':=A')); intros H30. apply rotation_IAB with a; auto. generalize (isometrie_distinct (A:=I) (B:=A) (A':=I) (B':=A')); intros H30. generalize (isometrie_distinct (A:=I) (B:=B) (A':=I) (B':=B')); intros H31. elim (classic (I = C)); intros. rewrite <- H7 in H3. rewrite H3; repeat rewrite <- rotation_def_centre; rewrite <- H7; auto. elim rotation_def with (I := I) (A := A) (B := A') (a := a); [ try clear rotation_def; intros | auto | auto ]. elim rotation_def with (I := I) (A := B) (B := B') (a := a); [ try clear rotation_def; intros | auto | auto ]. elim cas_egalite_triangle with (A := I) (B := A) (C := B) (A' := I) (B' := A') (C' := B'); (auto; intros). elim H14; intros H15 H16; try clear H14; try exact H15. apply rotation_IAB with a; auto. generalize (isometrie_distinct (A:=I) (B:=C) (A':=I) (B':=C')); intros H32. elim rotation_def with (I := I) (A := A) (B := A') (a := a); [ try clear rotation_def; intros | auto | auto ]. elim rotation_def with (I := I) (A := B) (B := B') (a := a); [ try clear rotation_def; intros | auto | auto ]. elim rotation_def with (I := I) (A := C) (B := C') (a := a); [ try clear rotation_def; intros | auto | auto ]. elim cas_egalite_triangle with (A := I) (B := A) (C := B) (A' := I) (B' := A') (C' := B'); (auto; intros). elim cas_egalite_triangle with (A := I) (B := A) (C := C) (A' := I) (B' := A') (C' := C'); (auto; intros). elim H18; intros H19 H20; try clear H18; try exact H20. elim H16; intros H18 H21; try clear H16; try exact H21. replace (cons_AV (vec A B) (vec A C)) with (plus (cons_AV (vec A B) (vec A I)) (cons_AV (vec A I) (vec A C))). mesure A C A I. rewrite <- (mes_oppx (A:=A) (B:=C) (C:=A) (D:=I) (x:=x)); auto with geo. rewrite (mes_oppx (A:=A') (B:=C') (C:=A') (D:=I) (x:=x)); auto with geo. rewrite H18; rewrite Chasles; auto with geo. apply dist_non_nulle; rewrite distance_sym; rewrite <- H8; auto with geo. apply dist_non_nulle; rewrite distance_sym; rewrite <- H8; auto with geo. rewrite H16; rewrite H19; auto. rewrite Chasles; auto. apply rotation_IAB with a; auto. apply rotation_IAB with a; auto. Qed. Theorem rotation_image_bipoint : forall (I A B C A' B' C' : PO) (a : R), A <> B :>PO -> A' = rotation I a A -> B' = rotation I a B -> distance A' B' = distance A B /\ image_angle a = cons_AV (vec A B) (vec A' B') :>AV. intros. generalize (image_bipoint_distinct (I:=I) (A:=A) (B:=B) (A':=A') (B':=B') (a:=a)); intros H11. split; [ try assumption | idtac ]. apply rotation_isometrie with (1 := H0); auto. elim (classic (I = A)); intros. rewrite <- H2; rewrite <- H2 in H0; rewrite <- H2 in H. elim rotation_def with (I := I) (A := B) (B := B') (a := a); [ try clear rotation_def; intros | auto | auto ]. rewrite H0; repeat rewrite <- rotation_def_centre; auto. elim (classic (I = B)); intros. rewrite <- H3; rewrite <- H3 in H1; rewrite <- H3 in H. generalize (isometrie_distinct (A:=I) (B:=A) (A':=I) (B':=A')); intros H30. elim rotation_def with (I := I) (A := A) (B := A') (a := a); [ try clear rotation_def; intros | auto | auto ]. rewrite H1; repeat rewrite <- rotation_def_centre; auto. rewrite angle_oppu_oppv; auto. elim rotation_def with (I := I) (A := B) (B := B') (a := a); [ try clear rotation_def; intros | auto | auto ]. elim rotation_def with (I := I) (A := A) (B := A') (a := a); [ try clear rotation_def; intros | auto | auto ]. generalize (isometrie_distinct (A:=I) (B:=A) (A':=I) (B':=A')); intros H30. generalize (isometrie_distinct (A:=I) (B:=B) (A':=I) (B':=B')); intros. elim cas_egalite_triangle with (A := I) (B := A) (C := B) (A' := I) (B' := A') (C' := B'); (auto; intros). elim H10; intros H12 H13; try clear H10; try exact H13. replace (cons_AV (vec A B) (vec A' B')) with (plus (cons_AV (vec A B) (vec A I)) (plus (cons_AV (vec A I) (vec A' I)) (cons_AV (vec A' I) (vec A' B')))). mesure A B A I. rewrite <- (mes_oppx (A:=A') (B:=B') (C:=A') (D:=I) (x:=x)). rewrite angle_oppu_oppv; auto. rewrite <- H7. rewrite <- add_mes_compatible; rewrite <- add_mes_compatible. replace (x + (a + - x)) with a; try ring; auto. apply H11; auto. apply dist_non_nulle; rewrite distance_sym; rewrite <- H6; auto with geo. rewrite H10; rewrite H12; auto. rewrite Chasles; auto. rewrite Chasles; auto. apply dist_non_nulle; rewrite distance_sym; rewrite <- H6; auto with geo. apply rotation_IAB with a; auto. Qed. Lemma existence_rotation_Ia : forall (I M : PO) (a : R), exists M' : PO, M' = rotation I a M. intros. elim (classic (M = I)); intros. exists I. rewrite H; rewrite <- rotation_def_centre; auto. elim existence_representant_unitaire with (A := I) (B := M); [ intros; try clear existence_representant_unitaire | auto ]. cut (I <> x); intros. generalize (existence_representant_angle (A:=I) (B:=x) I a); intros. elim H2; [ intros C H3; elim H3; intros H4 H5; try clear H3 H2; try exact H5 | idtac ]. cut (I <> C); intros. generalize (distance_vecteur (A:=I) (B:=M)); intros. elim existence_representant_mult_vecteur with (A := I) (B := I) (C := C) (k := distance I M); intros D H6; try clear existence_representant_mult_vecteur; try exact H6. cut (I <> D); intros. exists D. apply rotation_def2; auto. apply resolution; auto with geo. repeat rewrite <- carre_scalaire_distance. rewrite H6; rewrite H3; auto. rewrite <- H0. Simplscal. elim def_representant_unitaire2 with (A := I) (B := M) (C := x); [ intros; elim H9; intros H22 H23; rewrite H22; try discrR | auto | auto ]. rewrite carre_scalaire_distance. rewrite H4. ring. rewrite angles_representants_unitaires; auto. replace (representant_unitaire (vec I D)) with (vec I C). rewrite <- H0; auto. apply def_representant_unitaire; auto with geo. cut (distance I M <> 0); intros; auto with geo. apply colineaire_alignes with (/ distance I M); auto. rewrite H6. Fieldvec (distance I M). rewrite H6. replace (scalaire (mult_PP (distance I M) (vec I C)) (vec I C)) with (distance I M * scalaire (vec I C) (vec I C)). apply Rmult_pos; auto with geo. Simplscal. apply distinct_produit_vecteur with (3 := H6); auto with geo. auto with geo. elim def_representant_unitaire2 with (A := I) (B := M) (C := x); [ intros; elim H4; intros H22 H23; try discrR | auto | auto ]. auto with geo. apply distance_non_nulle. elim def_representant_unitaire2 with (A := I) (B := M) (C := x); [ intros; elim H2; intros H22 H23; rewrite H22; try discrR | auto | auto ]. Qed. Lemma deux_mes_angle_rotation : forall (I M : PO) (a b : R), image_angle a = image_angle b -> rotation I a M = rotation I b M. intros. elim (classic (I = M)); intros. rewrite <- H0; repeat rewrite <- rotation_def_centre; auto. elim (existence_rotation_Ia I M a); intros. rewrite <- H1. generalize (rotation_def (I:=I) (A:=M) (B:=x) (a:=a)); intros. elim H2; auto; intros. apply rotation_def2; auto. rewrite <- H4; rewrite <- H; auto. Qed.HighSchoolGeometry/similitudes_directes.v0000644000076500007650000003120412117747636020643 0ustar coqcoq00000000000000(* This program is free software; you can redistribute it and/or *) (* modify it under the terms of the GNU Lesser General Public License *) (* as published by the Free Software Foundation; either version 2.1 *) (* of the License, or (at your option) any later version. *) (* *) (* This program is distributed in the hope that it will be useful, *) (* but WITHOUT ANY WARRANTY; without even the implied warranty of *) (* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *) (* GNU General Public License for more details. *) (* *) (* You should have received a copy of the GNU Lesser General Public *) (* License along with this program; if not, write to the Free *) (* Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA *) (* 02110-1301 USA *) Require Export homothetie_plane. Set Implicit Arguments. Unset Strict Implicit. Parameter similitude : PO -> R -> R -> PO -> PO. Axiom similitude_def : forall (I A B : PO) (k a : R), k > 0 -> I <> A -> B = similitude I k a A -> distance I B = k * distance I A /\ image_angle a = cons_AV (vec I A) (vec I B). Axiom similitude_def_centre : forall (I : PO) (k a : R), k > 0 -> I = similitude I k a I. Axiom similitude_def2 : forall (I A B : PO) (k a : R), k > 0 -> I <> A -> distance I B = k * distance I A -> image_angle a = cons_AV (vec I A) (vec I B) -> B = similitude I k a A. Lemma composee_rotation_homothetie_pos : forall (I M M' M1 : PO) (k a : R), k > 0 -> M1 = rotation I a M -> M' = homothetie k I M1 -> M' = similitude I k a M. intros I M M' M1 k a H; try assumption. discrimine I M. rewrite <- similitude_def_centre; auto; rewrite <- rotation_def_centre; intros. rewrite H2; rewrite H1; rewrite <- homothetie_centre; auto. intros. elim rotation_def with (I := I) (A := M) (B := M1) (a := a); [ intros | auto | auto ]. cut (distance I M' = Rabs k * distance I M1); intros. 2: apply distance_homothetie with I; auto with geo. apply similitude_def2; auto. rewrite H5; rewrite H3; rewrite Rabs_right; auto. fourier. rewrite H4; auto. cut (vec I M' = mult_PP k (vec I M1)); intros. symmetry in |- *; rewrite (angle_produit_positif_r (k:=k) (A:=I) (B:=M1) (C:=M') (D:=I) (E:=M)) ; auto. apply image_distinct_centre with (2 := H1); auto. apply homothetie_vecteur; auto. Qed. Lemma composee_homothetie_pos_rotation : forall (I M M' M1 : PO) (k a : R), k > 0 -> M1 = homothetie k I M -> M' = rotation I a M1 -> M' = similitude I k a M. intros I M M' M1 k a H; try assumption. discrimine I M. rewrite <- similitude_def_centre; auto; rewrite <- homothetie_centre; intros. rewrite H2; rewrite H1; rewrite <- rotation_def_centre; auto. intros. cut (vec I M1 = mult_PP k (vec I M)); intros. cut (distance I M1 = Rabs k * distance I M); intros. 2: apply distance_homothetie with I; auto with geo. cut (I <> M1); intros. cut (I <> M'); intros. elim rotation_def with (I := I) (A := M1) (B := M') (a := a); [ intros | auto | auto ]. apply similitude_def2; auto. rewrite <- H7; rewrite H4; rewrite Rabs_right; auto. fourier. rewrite H8. apply permute_angles; auto. rewrite (angle_produit_positif_r (k:=k) (A:=I) (B:=M) (C:=M1) (D:=I) (E:=M')); auto. apply image_distinct_centre with (2 := H2); auto with geo. apply distinct_produit_vecteur with (3 := H3); auto. auto with real. apply homothetie_vecteur; auto. Qed. Lemma existence_similitude_Ika : forall (I M : PO) (k a : R), k > 0 -> exists M' : PO, M' = similitude I k a M. intros. elim existence_rotation_Ia with (I := I) (M := M) (a := a); intros M1; intros. elim existence_homothetique with (k := k) (I := I) (A := M1); intros M' H1; try clear existence_homothetique; try exact H1. exists M'. apply composee_rotation_homothetie_pos with M1; auto. Qed. Lemma similitude_rapport_un : forall (I A : PO) (a : R), rotation I a A = similitude I 1 a A. intros. discrimine I A. rewrite <- rotation_def_centre; rewrite <- similitude_def_centre; auto. fourier. elim existence_rotation_Ia with (I := I) (M := A) (a := a); intros B; intros. cut (B = homothetie 1 I B); intros. 2: apply homothetie_identite. rewrite <- H0. apply composee_rotation_homothetie_pos with B; auto. fourier. Qed. Lemma similitude_angle_nul : forall (I A : PO) (k : R), k > 0 -> homothetie k I A = similitude I k 0 A. intros. discrimine I A. rewrite <- homothetie_centre; rewrite <- similitude_def_centre; auto. cut (A = rotation I 0 A); intros. 2: apply rotation_angle_nul. elim existence_homothetique with (k := k) (I := I) (A := A); intros M'; intros. rewrite <- H2. apply composee_rotation_homothetie_pos with A; auto. Qed. Lemma similitude_identite : forall I A : PO, A = similitude I 1 0 A. intros. rewrite <- similitude_rapport_un. rewrite <- rotation_angle_nul; auto. Qed. Lemma image_sim_distinct_centre : forall (I A B : PO) (k a : R), I <> A -> k > 0 -> B = similitude I k a A -> I <> B. intros. elim similitude_def with (I := I) (A := A) (B := B) (k := k) (a := a); [ intros | auto | auto | auto ]. apply dist_non_nulle. rewrite H2. apply prod_neq_R0; auto with geo. auto with real. Qed. Lemma similitude_decomposition : forall (I M M' : PO) (k a : R), k > 0 -> M' = similitude I k a M -> exists M1 : PO, M1 = rotation I a M /\ M' = homothetie k I M1. intros. elim existence_rotation_Ia with (I := I) (M := M) (a := a); intros M1; intros. exists M1. split; [ try assumption | idtac ]. discrimine I M. rewrite <- H2 in H1; rewrite <- H2 in H0. rewrite <- similitude_def_centre in H0; auto; rewrite <- rotation_def_centre in H1. rewrite <- H2; rewrite H0; rewrite H1; auto with geo. cut (I <> M1); intros. cut (I <> M'); intros. apply vecteur_homothetie. elim similitude_def with (I := I) (A := M) (B := M') (k := k) (a := a); [ intros | auto | auto | auto ]. elim rotation_def with (I := I) (A := M) (B := M1) (a := a); [ intros | auto | auto ]. apply alignes_distance_positif_colineaire; auto. replace (cons_AV (vec I M1) (vec I M')) with (plus (cons_AV (vec I M) (vec I M')) (opp (cons_AV (vec I M) (vec I M1)))). rewrite def_opp; auto. rewrite <- (mes_oppx (A:=I) (B:=M) (C:=I) (D:=M1) (x:=a)); auto. rewrite <- H6. repeat rewrite <- add_mes_compatible. replace (a + - a) with 0; auto. ring. apply Chasles_diff; auto. rewrite <- H7; auto. apply image_sim_distinct_centre with (3 := H0); auto. apply image_distinct_centre with (2 := H1); auto. Qed. Lemma rotation_homothetie_pos_I_commutent : forall (I M M1 M2 : PO) (k a : R), k > 0 -> M1 = homothetie k I M -> M2 = rotation I a M -> homothetie k I M2 = rotation I a M1. intros. elim existence_rotation_Ia with (I := I) (M := M1) (a := a); intros N; intros. elim existence_homothetique with (k := k) (I := I) (A := M2); intros N'; intros. rewrite <- H3; rewrite <- H2. rewrite (composee_rotation_homothetie_pos (I:=I) (M:=M) (M':=N') (M1:=M2) (k:=k) (a:=a)); auto. rewrite (composee_homothetie_pos_rotation (I:=I) (M:=M) (M':=N) (M1:=M1) (k:=k) (a:=a)); auto. Qed. Lemma similitudes_meme_centre_commutent : forall (I M M1 M2 : PO) (k m a b : R), k > 0 -> m > 0 -> M1 = similitude I k a M -> M2 = similitude I m b M -> similitude I k a M2 = similitude I m b M1. intros I M M1 M2 k m a b H H0; try assumption. discrimine I M. repeat (rewrite <- similitude_def_centre; auto). intros H2 H3; try assumption. rewrite H2; rewrite H3. repeat (rewrite <- similitude_def_centre; auto). intros H2 H3; try assumption. elim existence_similitude_Ika with (I := I) (M := M1) (k := m) (a := b); [ intros N H4 | auto ]. elim existence_similitude_Ika with (I := I) (M := M2) (k := k) (a := a); [ intros M' H5 | auto ]. rewrite <- H5. cut (I <> M1); intros. 2: apply image_sim_distinct_centre with (3 := H2); auto. cut (I <> M2); intros. 2: apply image_sim_distinct_centre with (3 := H3); auto. cut (I <> M'); intros. 2: apply image_sim_distinct_centre with (3 := H5); auto. cut (I <> N); intros. 2: apply image_sim_distinct_centre with (3 := H4); auto. elim similitude_def with (I := I) (A := M2) (B := M') (k := k) (a := a); [ intros | auto | auto | auto ]. elim similitude_def with (I := I) (A := M1) (B := N) (k := m) (a := b); [ intros | auto | auto | auto ]. elim similitude_def with (I := I) (A := M) (B := M2) (k := m) (a := b); [ intros | auto | auto | auto ]. elim similitude_def with (I := I) (A := M) (B := M1) (k := k) (a := a); [ intros | auto | auto | auto ]. apply similitude_def2; auto. rewrite H16; rewrite H10; rewrite H14; ring. replace (cons_AV (vec I M1) (vec I M')) with (plus (plus (cons_AV (vec I M) (vec I M2)) (opp (cons_AV (vec I M) (vec I M1)))) (cons_AV (vec I M2) (vec I M'))). rewrite def_opp; auto. rewrite <- (mes_oppx (A:=I) (B:=M) (C:=I) (D:=M1) (x:=a)); auto. rewrite <- H15; rewrite <- H11. repeat rewrite <- add_mes_compatible. replace (b + - a + a) with b; auto. ring. rewrite Chasles_diff; auto. rewrite Chasles; auto. Qed. Lemma homothetie_neg : forall (I M M' : PO) (k : R), k < 0 -> M' = homothetie k I M -> M' = similitude I (- k) pi M. intros I M M' k H; try assumption. discrimine I M. rewrite <- homothetie_centre. rewrite <- similitude_def_centre; auto. fourier. intros. cut (vec I M' = mult_PP k (vec I M)); intros. cut (distance I M' = Rabs k * distance I M); intros. 2: apply distance_homothetie with I; auto with geo. 2: apply homothetie_vecteur; auto. cut (I <> M'); intros. apply similitude_def2; auto. fourier. rewrite <- Rabs_left; auto. rewrite (angle_produit_negatif_r (k:=k) (A:=I) (B:=M) (C:=M') (D:=I) (E:=M)); auto. rewrite <- angle_nul; auto. repeat rewrite <- add_mes_compatible. replace (0 + pi) with pi; auto. ring. apply distinct_produit_vecteur with (3 := H2); auto. auto with real. Qed. Lemma homothetie_neg2 : forall (I M : PO) (k : R), k < 0 -> homothetie k I M = similitude I (- k) pi M. intros. elim existence_homothetique with (k := k) (I := I) (A := M); intros M'; intros. rewrite <- H0. apply homothetie_neg; auto. Qed. Lemma rotation_homothetie_I_commutent : forall (I M M1 M2 : PO) (k a : R), k <> 0 -> M1 = homothetie k I M -> M2 = rotation I a M -> homothetie k I M2 = rotation I a M1. intros I M M1 M2 k a H; try assumption. repeat rewrite similitude_rapport_un. elim Rtotal_order with (r1 := k) (r2 := 0); [ intros H4; try clear total_order | intros H4; (elim H4; [ intros H5; try clear H4 total_order | intros H5; try clear H4 total_order; try exact H5 ]) ]. repeat (rewrite homothetie_neg2; auto). intros. apply similitudes_meme_centre_commutent with (3 := H0) (4 := H1); auto. auto with real. fourier. absurd (k = 0); auto with real. repeat (rewrite similitude_angle_nul; auto). intros. apply similitudes_meme_centre_commutent with (3 := H0) (4 := H1); auto. fourier. Qed. Lemma similitude_conserve_angle : forall (I A B C A' B' C' : PO) (k a : R), k > 0 -> A <> B -> A <> C -> A' = similitude I k a A -> B' = similitude I k a B -> C' = similitude I k a C -> cons_AV (vec A B) (vec A C) = cons_AV (vec A' B') (vec A' C'). intros. elim similitude_decomposition with (I := I) (M := A) (M' := A') (k := k) (a := a); [ intros A1 H7; elim H7; intros H8 H9; try clear H7 | auto | auto ]. elim similitude_decomposition with (I := I) (M := B) (M' := B') (k := k) (a := a); [ intros B1 H7; elim H7; intros H10 H11; try clear H7; try exact H11 | auto | auto ]. elim similitude_decomposition with (I := I) (M := C) (M' := C') (k := k) (a := a); [ intros C1 H7; elim H7; intros H12 H13; try clear H7; try exact H13 | auto | auto ]. cut (A1 <> B1); intros. cut (A1 <> C1); intros. cut (cons_AV (vec A B) (vec A C) = cons_AV (vec A1 B1) (vec A1 C1)); intros. rewrite H7. apply (homothetie_conserve_angle (I:=I) (A:=A1) (B:=B1) (C:=C1) (A':=A') (B':=B') (C':=C') (k:=k)); auto with real. apply (rotation_conserve_angle (I:=I) (A:=A) (B:=B) (C:=C) (A':=A1) (B':=B1) (C':=C1) (a:=a)); auto. apply image_bipoint_distinct with (2 := H8) (3 := H12); auto. apply image_bipoint_distinct with (2 := H8) (3 := H10); auto. Qed. Lemma distance_similitude : forall (k a : R) (I A B A' B' : PO), k > 0 -> A' = similitude I k a A -> B' = similitude I k a B -> distance A' B' = k * distance A B. intros. elim similitude_decomposition with (I := I) (M := A) (M' := A') (k := k) (a := a); [ intros A1 H7; elim H7; intros H8 H9; try clear H7 | auto | auto ]. elim similitude_decomposition with (I := I) (M := B) (M' := B') (k := k) (a := a); [ intros B1 H7; elim H7; intros H10 H11; try clear H7; try exact H11 | auto | auto ]. cut (distance A1 B1 = distance A B); intros. rewrite <- H2. rewrite (distance_homothetie (k:=k) (I:=I) (A:=A1) (A':=A') (B:=B1) (B':=B')); auto. rewrite Rabs_right; auto. red in |- *; auto. apply rotation_isometrie with (1 := H8) (2 := H10). Qed.HighSchoolGeometry/tactiques_construction.v0000644000076500007650000000644512073525613021241 0ustar coqcoq00000000000000(* This program is free software; you can redistribute it and/or *) (* modify it under the terms of the GNU Lesser General Public License *) (* as published by the Free Software Foundation; either version 2.1 *) (* of the License, or (at your option) any later version. *) (* *) (* This program is distributed in the hope that it will be useful, *) (* but WITHOUT ANY WARRANTY; without even the implied warranty of *) (* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *) (* GNU General Public License for more details. *) (* *) (* You should have received a copy of the GNU Lesser General Public *) (* License along with this program; if not, write to the Free *) (* Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA *) (* 02110-1301 USA *) Require Export droite_Euler. Require Export parallelisme_concours. Require Export orthogonalite_espace. Require Export transformations_contact. Ltac DecompEx H P := elim H;intro P;intro;clear H. Ltac DecompExAnd H P := elim H;intro P;let id:=fresh in (intro id;decompose [and] id;clear id;clear H). Ltac soit_milieu I A B := let id1 := fresh in ((assert (id1:exists I, I = milieu A B); [apply (existence_milieu A B)|DecompEx id1 I])). Ltac soit_intersection I A B C D := let id1 := fresh in ((assert (id1:exists I, I = pt_intersection (droite A B) (droite C D)); [apply (existence_pt_intersection)|DecompEx id1 I])). Ltac soit_mediatrice I A B := let id1 := fresh in ((assert (id1:exists J, milieu A B <> J /\ mediatrice A B J); [apply (existence_mediatrice)|DecompExAnd id1 I])). Ltac soit_perpendiculaire I A B C := let id1 := fresh in ((assert (id1:exists D, orthogonal (vec A B) (vec C D)); [apply (existence_perpendiculaire)|DecompEx id1 I])). Check existence_homothetique. Ltac soit_image C A B := let id1 := fresh in ((assert (id1: exists C, A = milieu B C); [apply (existence_symetrique_milieu)|DecompEx id1 C])). Lemma existence_parallele : forall A B C : PO, A <> B -> exists D, paralleles (droite A B) (droite C D). intros. soit_milieu M A C. soit_image D M B. exists D. eapply colineaires_paralleles with (k:=-1);auto. unfold not;intro;subst C. assert (A=B). rewrite H2 in H1. eapply unicite_symetrique;eauto. auto. VReplace (mult_PP (-1) (vec C D)) (vec D C). assert (parallelogramme A B C D). assert (T:=(caract_milieu_parallelogramme A B C D)). rewrite H1 in H2. tauto. auto. Qed. Ltac soit_parallele I A B C := let id1 := fresh in ((assert (id1:exists D, paralleles (droite A B) (droite C D)); [apply (existence_parallele)|DecompEx id1 I])). Ltac soit_point_droite I A B := let id1 := fresh in ((assert (id1:exists C, alignes A B C); [apply (existence_point_droite)|DecompEx id1 I])). Ltac soit_point_cercle I O A := let id1 := fresh in ((assert (id1:exists C, cercle_rayon O A C); [apply (existence_point_droite)|DecompEx id1 I])). Ltac soit_centre_cercle_circonscrit O A B C := let id1 := fresh in ((assert (id1:exists O, circonscrit O A B C); [apply (existence_cercle_circonscrit)|DecompEx id1 I])). (* existence_intersection_droite_cercle_centre existence_reflexion_AB existence_rotation_Ia *)HighSchoolGeometry/transformations_contact.v0000755000076500007650000004310312073525611021362 0ustar coqcoq00000000000000(* This program is free software; you can redistribute it and/or *) (* modify it under the terms of the GNU Lesser General Public License *) (* as published by the Free Software Foundation; either version 2.1 *) (* of the License, or (at your option) any later version. *) (* *) (* This program is distributed in the hope that it will be useful, *) (* but WITHOUT ANY WARRANTY; without even the implied warranty of *) (* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *) (* GNU General Public License for more details. *) (* *) (* You should have received a copy of the GNU Lesser General Public *) (* License along with this program; if not, write to the Free *) (* Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA *) (* 02110-1301 USA *) Require Export contact. Require Export reflexion_plane. Require Export similitudes_directes. Set Implicit Arguments. Unset Strict Implicit. Hint Resolve translation_trivial rec_translation_vecteur: geo. Lemma translation_isometrie : forall A A' B B' C C' : PO, B' = translation A A' B -> C' = translation A A' C -> distance B' C' = distance B C. intros. apply Rsqr_inj; auto with real geo. unfold Rsqr in |- *. repeat rewrite <- carre_scalaire_distance. rewrite <- (translation_bipoint (I:=A) (J:=A') (A:=B) (A':=B') (B:=C) (B':=C')) ; auto. Qed. Lemma translation_conserve_orthogonalite : forall I J A A' B B' M M' : PO, A' = translation I J A -> B' = translation I J B -> M' = translation I J M -> orthogonal (vec A B) (vec A M) -> orthogonal (vec A' B') (vec A' M'). intros. rewrite <- (translation_bipoint (I:=I) (J:=J) (A:=A) (A':=A') (B:=M) (B':=M')) ; auto. rewrite <- (translation_bipoint (I:=I) (J:=J) (A:=A) (A':=A') (B:=B) (B':=B')) ; auto. Qed. Lemma translation_conserve_contact_cercle_droite : forall I J A A' B B' M M' O O' : PO, A' = translation I J A -> B' = translation I J B -> M' = translation I J M -> O' = translation I J O -> tangente_cercle O A B M -> tangente_cercle O' A' B' M'. icercle. rewrite (translation_isometrie (A:=I) (A':=J) (B:=O) (B':=O') (C:=A) (C':=A')) ; auto. rewrite (translation_isometrie (A:=I) (A':=J) (B:=O) (B':=O') (C:=B) (C':=B')) ; auto. apply (translation_conserve_orthogonalite (I:=I) (J:=J) (A:=B) (A':=B') (B:=M) (B':=M') (M:=O) (M':=O')); auto. Qed. Lemma translation_conserve_contact_cercle_cercle : forall I J A A' B B' K K' O O' : PO, O <> A -> K <> B -> A' = translation I J A -> B' = translation I J B -> K' = translation I J K -> O' = translation I J O -> cercles_tangents O A K B -> cercles_tangents O' A' K' B'. intros. elim cercles_tangents_tangente_commune with (O := O) (A := A) (O' := K) (A' := B); [ intros T H6; elim H6; [ intros M H7; elim H7; [ intros H8 H9; elim H9; [ intros H10 H11; try clear H9 H7 H6; try exact H10 ] ] ] | auto | auto | auto ]. elim existence_representant_vecteur with (A := T) (B := I) (C := J); [ intros T' H6; try clear existence_representant_vecteur; try exact H6 ]. elim existence_representant_vecteur with (A := M) (B := I) (C := J); [ intros M' H7; try clear existence_representant_vecteur; try exact H7 ]. assert (distance O' A' = distance O A). rewrite <- (translation_isometrie (A:=I) (A':=J) (B:=O) (B':=O') (C:=A) (C':=A')) ; auto with geo. assert (distance K' B' = distance K B). rewrite <- (translation_isometrie (A:=I) (A':=J) (B:=K) (B':=K') (C:=B) (C':=B')) ; auto with geo. assert (O' <> A'). apply (isometrie_distinct (A:=O) (B:=A) (A':=O') (B':=A')); auto. assert (K' <> B'). apply (isometrie_distinct (A:=K) (B:=B) (A':=K') (B':=B')); auto. assert (distance T' M' = distance T M). rewrite <- (translation_isometrie (A:=I) (A':=J) (B:=T) (B':=T') (C:=M) (C':=M')) ; auto with geo. assert (T' <> M'). apply (isometrie_distinct (A:=T) (B:=M) (A':=T') (B':=M')); auto. apply tangente_commune_cercles_tangents with (B := T') (M := M'); auto. apply translation_conserve_contact_cercle_droite with (1 := H1) (5 := H10); auto with geo. apply translation_conserve_contact_cercle_droite with (1 := H2) (5 := H11); auto with geo. Qed. Lemma homothetie_conserve_orthogonalite : forall (k : R) (I A A' B B' M M' : PO), k <> 0 :>R -> A' = homothetie k I A :>PO -> B' = homothetie k I B :>PO -> M' = homothetie k I M :>PO -> orthogonal (vec A B) (vec A M) -> orthogonal (vec A' B') (vec A' M'). intros. generalize (homothetie_bipoint (k:=k) (I:=I) (A:=A) (B:=B) (A':=A') (B':=B')); intros. generalize (homothetie_bipoint (k:=k) (I:=I) (A:=A) (B:=M) (A':=A') (B':=M')); intros. assert (orthogonal (vec A B) (vec A' M')). apply ortho_sym; rewrite H5; auto with geo. rewrite H4; auto with geo. Qed. Lemma homothetie_conserve_contact_cercle_droite : forall (k : R) (I A A' B B' M M' O O' : PO), k <> 0 :>R -> A' = homothetie k I A :>PO -> B' = homothetie k I B :>PO -> M' = homothetie k I M :>PO -> O' = homothetie k I O -> tangente_cercle O A B M -> tangente_cercle O' A' B' M'. icercle. rewrite (distance_homothetie (k:=k) (I:=I) (A:=O) (A':=O') (B:=A) (B':=A')); auto. rewrite (distance_homothetie (k:=k) (I:=I) (A:=O) (A':=O') (B:=B) (B':=B')); auto. rewrite H5; auto. apply (homothetie_conserve_orthogonalite (k:=k) (I:=I) (A:=B) (A':=B') (B:=M) (B':=M') (M:=O) (M':=O')); auto. Qed. Lemma produit_distance_distinct : forall (A B C D : PO) (k : R), k <> 0 -> A <> B -> distance C D = k * distance A B -> C <> D. intros. contrapose H0. assert (distance A B = 0); auto with geo. replace (distance A B) with (/ k * distance C D). rewrite H2. replace (distance D D) with 0. ring. symmetry in |- *; auto with geo. rewrite H1. field; auto. Qed. Lemma homothetie_conserve_contact_cercle_cercle : forall (k : R) (I J A A' B B' K K' O O' : PO), O <> A -> K <> B -> k <> 0 -> A' = homothetie k I A -> B' = homothetie k I B -> K' = homothetie k I K -> O' = homothetie k I O -> cercles_tangents O A K B -> cercles_tangents O' A' K' B'. intros. elim cercles_tangents_tangente_commune with (O := O) (A := A) (O' := K) (A' := B); [ intros T H7; elim H7; [ intros M H8; elim H8; [ intros H9 H10; elim H10; [ intros H11 H12; try clear H10 H8 H7; try exact H11 ] ] ] | auto | auto | auto ]. elim existence_homothetique with (k := k) (I := I) (A := T); [ intros T' H7 ]. elim existence_homothetique with (k := k) (I := I) (A := M); [ intros M' H8 ]. assert (O' <> A'). apply image_homothetie_distincts with (3 := H5) (4 := H2); auto. assert (K' <> B'). apply image_homothetie_distincts with (3 := H4) (4 := H3); auto. assert (T' <> M'). apply image_homothetie_distincts with (3 := H7) (4 := H8); auto. apply tangente_commune_cercles_tangents with (B := T') (M := M'); auto. apply homothetie_conserve_contact_cercle_droite with (2 := H2) (6 := H11); auto with geo. apply homothetie_conserve_contact_cercle_droite with (2 := H3) (6 := H12); auto with geo. Qed. Lemma reflexion_conserve_orthogonalite : forall I J A A' B B' M M' : PO, I <> J -> A' = reflexion I J A :>PO -> B' = reflexion I J B :>PO -> M' = reflexion I J M :>PO -> orthogonal (vec A B) (vec A M) -> orthogonal (vec A' B') (vec A' M'). intros. assert (distance A' B' = distance A B). rewrite <- (reflexion_isometrie (A:=I) (B:=J) (M:=A) (M':=A') (N:=B) (N':=B')) ; auto with geo. assert (distance A' M' = distance A M). rewrite <- (reflexion_isometrie (A:=I) (B:=J) (M:=A) (M':=A') (N:=M) (N':=M')) ; auto with geo. discrimine A B. assert (distance A' B' = 0). rewrite H4; rewrite H6; auto with geo. assert (A' = B'); auto with geo. rewrite H8. VReplace (vec B' B') zero; auto with geo. discrimine A M. assert (distance A' M' = 0). rewrite H5; rewrite H7; auto with geo. assert (A' = M'); auto with geo. rewrite H9. VReplace (vec M' M') zero; auto with geo. assert (~ alignes A B M); auto with geo. assert (B <> M); auto with geo. apply non_alignes_distincts2 with A; auto. assert (cons_AV (vec A' B') (vec A' M') = opp (cons_AV (vec A B) (vec A M))). apply reflexion_anti_deplacement with (A := I) (B := J); auto. assert (double_AV (cons_AV (vec A M) (vec A B)) = image_angle pi). apply orthogonal_angles; auto with geo. apply angles_orthogonal. apply (isometrie_distinct (A:=A) (B:=B) (A':=A') (B':=B')); auto. apply (isometrie_distinct (A:=A) (B:=M) (A':=A') (B':=M')); auto. rewrite H10. rewrite def_opp; auto. Qed. Lemma reflexion_conserve_contact_cercle_droite : forall I J A A' B B' M M' O O' : PO, I <> J -> A' = reflexion I J A -> B' = reflexion I J B -> M' = reflexion I J M -> O' = reflexion I J O -> tangente_cercle O A B M -> tangente_cercle O' A' B' M'. icercle. rewrite <- (reflexion_isometrie (A:=I) (B:=J) (M:=O) (M':=O') (N:=A) (N':=A')) ; auto. rewrite <- (reflexion_isometrie (A:=I) (B:=J) (M:=O) (M':=O') (N:=B) (N':=B')) ; auto. apply (reflexion_conserve_orthogonalite (I:=I) (J:=J) (A:=B) (A':=B') (B:=M) (B':=M') (M:=O) (M':=O')); auto. Qed. Lemma reflexion_conserve_contact_cercle_cercle : forall I J A A' B B' K K' O O' : PO, I <> J -> O <> A -> K <> B -> A' = reflexion I J A -> B' = reflexion I J B -> K' = reflexion I J K -> O' = reflexion I J O -> cercles_tangents O A K B -> cercles_tangents O' A' K' B'. intros. elim cercles_tangents_tangente_commune with (O := O) (A := A) (O' := K) (A' := B); [ intros T H7; elim H7; [ intros M H8; elim H8; [ intros H9 H10; elim H10; [ intros H11 H12; try clear H10 H8 H7; try exact H11 ] ] ] | auto | auto | auto ]. elim existence_reflexion_AB with (A := I) (B := J) (M := T); [ intros T' H7; try clear existence_reflexion_AB; try exact H7 | auto ]. elim existence_reflexion_AB with (A := I) (B := J) (M := M); [ intros M' H8; try clear existence_reflexion_AB; try exact H7 | auto ]. assert (distance O' A' = distance O A). rewrite <- (reflexion_isometrie (A:=I) (B:=J) (M:=O) (M':=O') (N:=A) (N':=A')) ; auto. assert (O' <> A'). apply (isometrie_distinct (A:=O) (B:=A) (A':=O') (B':=A')); auto. assert (distance K' B' = distance K B). rewrite <- (reflexion_isometrie (A:=I) (B:=J) (M:=K) (M':=K') (N:=B) (N':=B')) ; auto. assert (K' <> B'). apply (isometrie_distinct (A:=K) (B:=B) (A':=K') (B':=B')); auto. assert (distance T' M' = distance T M). rewrite <- (reflexion_isometrie (A:=I) (B:=J) (M:=T) (M':=T') (N:=M) (N':=M')) ; auto. assert (T' <> M'). apply (isometrie_distinct (A:=T) (B:=M) (A':=T') (B':=M')); auto. apply tangente_commune_cercles_tangents with (B := T') (M := M'); auto. apply reflexion_conserve_contact_cercle_droite with (2 := H2) (6 := H11); auto with geo. apply reflexion_conserve_contact_cercle_droite with (2 := H3) (6 := H12); auto with geo. Qed. Lemma rotation_conserve_orthogonalite : forall (I A B M A' B' M' : PO) (a : R), A' = rotation I a A -> B' = rotation I a B -> M' = rotation I a M -> orthogonal (vec A B) (vec A M) -> orthogonal (vec A' B') (vec A' M'). intros. assert (distance A' B' = distance A B). rewrite <- (rotation_isometrie (I:=I) (A:=A) (B:=B) (A':=A') (B':=B') (a:=a)); auto with geo. assert (distance A' M' = distance A M). rewrite <- (rotation_isometrie (I:=I) (A:=A) (B:=M) (A':=A') (B':=M') (a:=a)); auto with geo. discrimine A B. assert (distance A' B' = 0). rewrite H3; rewrite H5; auto with geo. assert (A' = B'); auto with geo. rewrite H7. VReplace (vec B' B') zero; auto with geo. discrimine A M. assert (distance A' M' = 0). rewrite H4; rewrite H6; auto with geo. assert (A' = M'); auto with geo. rewrite H8. VReplace (vec M' M') zero; auto with geo. assert (cons_AV (vec A B) (vec A M) = cons_AV (vec A' B') (vec A' M')). apply rotation_conserve_angle with (a := a) (I := I); auto. assert (double_AV (cons_AV (vec A B) (vec A M)) = image_angle pi). apply orthogonal_angles; auto with geo. apply angles_orthogonal. apply (isometrie_distinct (A:=A) (B:=B) (A':=A') (B':=B')); auto. apply (isometrie_distinct (A:=A) (B:=M) (A':=A') (B':=M')); auto. rewrite <- H7; auto. Qed. Lemma rotation_conserve_contact_cercle_droite : forall (I A A' B B' M M' O O' : PO) (a : R), A' = rotation I a A -> B' = rotation I a B -> M' = rotation I a M -> O' = rotation I a O -> tangente_cercle O A B M -> tangente_cercle O' A' B' M'. icercle. rewrite (rotation_isometrie (I:=I) (A:=O) (B:=A) (A':=O') (B':=A') (a:=a)); auto. rewrite (rotation_isometrie (I:=I) (A:=O) (B:=B) (A':=O') (B':=B') (a:=a)); auto. apply (rotation_conserve_orthogonalite (I:=I) (A:=B) (B:=M) (M:=O) (A':=B') (B':=M') (M':=O') (a:=a)); auto. Qed. Lemma rotation_conserve_contact_cercle_cercle : forall (I A A' B B' K K' O O' : PO) (a : R), O <> A -> K <> B -> A' = rotation I a A -> B' = rotation I a B -> K' = rotation I a K -> O' = rotation I a O -> cercles_tangents O A K B -> cercles_tangents O' A' K' B'. intros. elim cercles_tangents_tangente_commune with (O := O) (A := A) (O' := K) (A' := B); [ intros T H6; elim H6; [ intros M H7; elim H7; [ intros H8 H9; elim H9; [ intros H10 H11; try clear H9 H7 H6; try exact H10 ] ] ] | auto | auto | auto ]. elim existence_rotation_Ia with (I := I) (M := T) (a := a); [ intros T' H6; try clear existence_rotation_Ia; try exact H6 ]. elim existence_rotation_Ia with (I := I) (M := M) (a := a); [ intros M' H7; try clear existence_rotation_Ia; try exact H7 ]. assert (O' <> A'). apply (image_bipoint_distinct (I:=I) (A:=O) (B:=A) (A':=O') (B':=A') (a:=a)); auto. assert (K' <> B'). apply (image_bipoint_distinct (I:=I) (A:=K) (B:=B) (A':=K') (B':=B') (a:=a)); auto. assert (T' <> M'). apply (image_bipoint_distinct (I:=I) (A:=T) (B:=M) (A':=T') (B':=M') (a:=a)); auto. apply tangente_commune_cercles_tangents with (B := T') (M := M'); auto. apply rotation_conserve_contact_cercle_droite with (1 := H1) (5 := H10); auto with geo. apply rotation_conserve_contact_cercle_droite with (1 := H2) (5 := H11); auto with geo. Qed. Lemma similitude_conserve_orthogonalite : forall (I A B M A' B' M' : PO) (k a : R), k > 0 -> A' = similitude I k a A -> B' = similitude I k a B -> M' = similitude I k a M -> orthogonal (vec A B) (vec A M) -> orthogonal (vec A' B') (vec A' M'). intros. assert (distance A' B' = k * distance A B). rewrite <- (distance_similitude (k:=k) (a:=a) (I:=I) (A:=A) (B:=B) (A':=A') (B':=B')) ; auto with geo. assert (distance A' M' = k * distance A M). rewrite <- (distance_similitude (k:=k) (a:=a) (I:=I) (A:=A) (B:=M) (A':=A') (B':=M')) ; auto with geo. discrimine A B. assert (distance A' B' = 0). rewrite H4; rewrite H6. replace (distance B B) with 0. ring. symmetry in |- *; auto with geo. assert (A' = B'); auto with geo. rewrite H8. VReplace (vec B' B') zero; auto with geo. discrimine A M. assert (distance A' M' = 0). rewrite H5; rewrite H7. replace (distance M M) with 0. ring. symmetry in |- *; auto with geo. assert (A' = M'); auto with geo. rewrite H9. VReplace (vec M' M') zero; auto with geo. assert (cons_AV (vec A B) (vec A M) = cons_AV (vec A' B') (vec A' M')). apply similitude_conserve_angle with (a := a) (k := k) (I := I); auto. assert (double_AV (cons_AV (vec A B) (vec A M)) = image_angle pi). apply orthogonal_angles; auto with geo. assert (k <> 0); auto with real. apply angles_orthogonal. apply produit_distance_distinct with (3 := H4); auto. apply produit_distance_distinct with (3 := H5); auto. rewrite <- H8; auto. Qed. Lemma similitude_conserve_contact_cercle_droite : forall (I A B M A' B' M' O O' : PO) (k a : R), k > 0 -> A' = similitude I k a A -> B' = similitude I k a B -> M' = similitude I k a M -> O' = similitude I k a O -> tangente_cercle O A B M -> tangente_cercle O' A' B' M'. icercle. rewrite (distance_similitude (k:=k) (a:=a) (I:=I) (A:=O) (B:=A) (A':=O') (B':=A')) ; auto. rewrite (distance_similitude (k:=k) (a:=a) (I:=I) (A:=O) (B:=B) (A':=O') (B':=B')) ; auto. rewrite H5; auto. apply (similitude_conserve_orthogonalite (I:=I) (A:=B) (B:=M) (M:=O) (A':=B') (B':=M') (M':=O') (k:=k) (a:=a)); auto. Qed. Lemma similitude_conserve_contact_cercle_cercle : forall (I A A' B B' K K' O O' : PO) (k a : R), k > 0 -> O <> A -> K <> B -> A' = similitude I k a A -> B' = similitude I k a B -> K' = similitude I k a K -> O' = similitude I k a O -> cercles_tangents O A K B -> cercles_tangents O' A' K' B'. intros. elim cercles_tangents_tangente_commune with (O := O) (A := A) (O' := K) (A' := B); [ intros T H7; elim H7; [ intros M H8; elim H8; [ intros H9 H10; elim H10; [ intros H11 H12; try clear H10 H8 H7 cercles_tangents_tangente_commune; try exact H11 ] ] ] | auto | auto | auto ]. elim existence_similitude_Ika with (I := I) (M := T) (k := k) (a := a); [ intros T' H13; try clear existence_similitude_Ika; try exact H13 | auto ]. elim existence_similitude_Ika with (I := I) (M := M) (k := k) (a := a); [ intros M' H14; try clear existence_similitude_Ika; try exact H14 | auto ]. assert (distance O' A' = k * distance O A). rewrite <- (distance_similitude (k:=k) (a:=a) (I:=I) (A:=O) (B:=A) (A':=O') (B':=A')) ; auto with geo. assert (distance K' B' = k * distance K B). rewrite <- (distance_similitude (k:=k) (a:=a) (I:=I) (A:=K) (B:=B) (A':=K') (B':=B')) ; auto with geo. assert (distance T' M' = k * distance T M). rewrite <- (distance_similitude (k:=k) (a:=a) (I:=I) (A:=T) (B:=M) (A':=T') (B':=M')) ; auto with geo. assert (k <> 0); auto with real. assert (O' <> A'). apply produit_distance_distinct with (3 := H15); auto. assert (K' <> B'). apply produit_distance_distinct with (3 := H16); auto. assert (T' <> M'). apply produit_distance_distinct with (3 := H17); auto. apply tangente_commune_cercles_tangents with (B := T') (M := M'); auto. apply similitude_conserve_contact_cercle_droite with (2 := H2) (6 := H11); auto with geo. apply similitude_conserve_contact_cercle_droite with (2 := H3) (6 := H12); auto with geo. Qed.HighSchoolGeometry/trigo.v0000644000076500007650000005457212117747636015567 0ustar coqcoq00000000000000(* This program is free software; you can redistribute it and/or *) (* modify it under the terms of the GNU Lesser General Public License *) (* as published by the Free Software Foundation; either version 2.1 *) (* of the License, or (at your option) any later version. *) (* *) (* This program is distributed in the hope that it will be useful, *) (* but WITHOUT ANY WARRANTY; without even the implied warranty of *) (* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *) (* GNU General Public License for more details. *) (* *) (* You should have received a copy of the GNU Lesser General Public *) (* License along with this program; if not, write to the Free *) (* Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA *) (* 02110-1301 USA *) Require Export angles_vecteurs. Set Implicit Arguments. Unset Strict Implicit. (* Le plan est orienté et on utilise le cercle trigonométrique*) Definition repere_orthonormal_direct (O I J : PO) := image_angle pisurdeux = cons_AV (vec O I) (vec O J) /\ scalaire (vec O I) (vec O I) = 1 /\ scalaire (vec O J) (vec O J) = 1. Parameter cos : R -> R. Parameter sin : R -> R. Parameter Cos : AV -> R. Parameter Sin : AV -> R. (* cosinus et sinus d'un angle (ou d'un réel) sont obtenus par projections du point image du cercle trigonométrique sur les axes de coordonnées*) Axiom def_cos : forall (A B C : PO) (x : R), distance A B = 1 -> distance A C = 1 -> image_angle x = cons_AV (vec A B) (vec A C) -> cos x = scalaire (vec A B) (vec A C). Axiom def_sin : forall (A B C D : PO) (x : R), distance A B = 1 -> distance A C = 1 -> image_angle x = cons_AV (vec A B) (vec A C) -> repere_orthonormal_direct A B D -> sin x = scalaire (vec A C) (vec A D). Axiom def_Cos : forall A B C : PO, distance A B = 1 -> distance A C = 1 -> Cos (cons_AV (vec A B) (vec A C)) = scalaire (vec A B) (vec A C). Axiom def_Sin : forall A B C D : PO, distance A B = 1 -> distance A C = 1 -> repere_orthonormal_direct A B D -> Sin (cons_AV (vec A B) (vec A C)) = scalaire (vec A C) (vec A D). Lemma ROND_RON : forall O I J : PO, repere_orthonormal_direct O I J -> repere_orthonormal O I J. unfold repere_orthonormal_direct, repere_orthonormal in |- *; intros. elim H; intros H0 H1; try clear H; try exact H1. split; [ auto with geo | try assumption ]. Qed. Hint Resolve ROND_RON: geo. Definition repere_orthonormal_indirect (O I J : PO) := image_angle pisurdeux = cons_AV (vec O J) (vec O I) /\ scalaire (vec O I) (vec O I) = 1 /\ scalaire (vec O J) (vec O J) = 1. Lemma ROND_RONI : forall O I J : PO, repere_orthonormal_direct O I J -> repere_orthonormal_indirect O J I. unfold repere_orthonormal_indirect, repere_orthonormal_direct in |- *. intros O I J H; try assumption. elim H; intros H0 H1; try clear H; try exact H1. elim H1; intros H H2; try clear H1; try exact H2. split; [ auto | split; [ auto | try assumption ] ]. Qed. Lemma ROND_new : forall O I J K : PO, repere_orthonormal_direct O I J -> vec O K = mult_PP (-1) (vec O I) -> repere_orthonormal_direct O J K. unfold repere_orthonormal_indirect, repere_orthonormal_direct in |- *. intros O I J K H H0; try assumption. elim H; intros H1 H2; elim H2; intros H3 H4; try clear H2 H; try exact H4. cut (scalaire (vec O K) (vec O K) = 1); intros. split; [ auto | split; [ auto | try assumption ] ]. replace pisurdeux with (- pisurdeux + pi). cut (image_angle (- pisurdeux) = cons_AV (vec O J) (vec O I)); intros. cut (image_angle pi = cons_AV (vec O I) (vec O K)); intros. rewrite add_mes_compatible. rewrite H5; rewrite H2; rewrite Chasles; auto with geo. replace (vec O K) with (vec I O). rewrite <- angle_plat; auto with geo. rewrite H0. unfold vec in |- *; RingPP. apply mes_oppx; auto with geo. unfold pi in |- *; ring. rewrite H0. Simplscal; rewrite H3; ring. Qed. Lemma existence_ROND_AB : forall A B : PO, distance A B = 1 -> exists C : PO, repere_orthonormal_direct A B C. intros. elim existence_representant_angle with (A := A) (B := B) (C := A) (x := pisurdeux); [ intros C H0; elim H0; intros H1 H2; try clear H0; try exact H2 | auto ]. exists C; unfold repere_orthonormal_direct in |- *. split; [ try assumption | idtac ]. split; auto with geo. Qed. Lemma cos_deux_mes : forall x y : R, image_angle x = image_angle y -> cos x = cos y. intros. elim existence_AB_unitaire; intros A H1; elim H1; intros B H0; try clear H1. elim existence_representant_angle with (A := A) (B := B) (C := A) (x := x); [ intros C H1; elim H1; intros; try clear H1 | auto ]. rewrite (def_cos (A:=A) (B:=B) (C:=C) (x:=x)); auto. rewrite (def_cos (A:=A) (B:=B) (C:=C) (x:=y)); auto. rewrite <- H3; auto. Qed. Lemma cos_paire : forall x : R, cos (- x) = cos x. intros. elim existence_AB_unitaire; intros A H; elim H; intros B H0; try clear H; try exact H0. elim existence_representant_angle with (A := A) (B := B) (C := A) (x := x); [ intros C H; elim H; intros H1 H2; try clear H; try exact H2 | auto ]. rewrite (def_cos (A:=A) (B:=B) (C:=C) (x:=x)); auto. cut (image_angle (- x) = cons_AV (vec A C) (vec A B)); intros. rewrite (def_cos (A:=A) (B:=C) (C:=B) (x:=- x)); auto. rewrite scalaire_sym; auto. apply mes_oppx; auto with geo. Qed. Lemma cos_periodique : forall x : R, cos (x + deuxpi) = cos x. intros. elim existence_AB_unitaire; intros A H; elim H; intros B H0; try clear H; try exact H0. elim existence_representant_angle with (A := A) (B := B) (C := A) (x := x); [ intros C H; elim H; intros H1 H2; try clear H; try exact H2 | auto ]. rewrite (def_cos (A:=A) (B:=B) (C:=C) (x:=x)); auto. cut (image_angle (x + deuxpi) = cons_AV (vec A B) (vec A C)); intros. rewrite (def_cos (A:=A) (B:=B) (C:=C) (x:=x + deuxpi)); auto. apply mesure_mod_deuxpi; auto with geo. Qed. Lemma sin_deux_mes : forall x y : R, image_angle x = image_angle y -> sin x = sin y. intros. elim existence_AB_unitaire; intros A H1; elim H1; clear H1; intros B H0. elim existence_ROND_AB with (A := A) (B := B); [ intros D H10 | auto ]. elim existence_representant_angle with (A := A) (B := B) (C := A) (x := x); [ intros C H1; elim H1; intros; try clear H1 | auto ]. rewrite (def_sin (A:=A) (B:=B) (C:=C) (D:=D) (x:=x)); auto. rewrite (def_sin (A:=A) (B:=B) (C:=C) (D:=D) (x:=y)); auto. rewrite <- H3; auto. Qed. Lemma sin_periodique : forall x : R, sin (x + deuxpi) = sin x. intros. elim existence_AB_unitaire; intros A H; elim H; intros B H0; try clear H; try exact H0. elim existence_ROND_AB with (A := A) (B := B); [ intros D H10 | auto ]. elim existence_representant_angle with (A := A) (B := B) (C := A) (x := x); [ intros C H; elim H; intros H1 H2; try clear H; try exact H2 | auto ]. rewrite (def_sin (A:=A) (B:=B) (C:=C) (D:=D) (x:=x)); auto. cut (image_angle (x + deuxpi) = cons_AV (vec A B) (vec A C)); intros. rewrite (def_sin (A:=A) (B:=B) (C:=C) (D:=D) (x:=x + deuxpi)); auto. apply mesure_mod_deuxpi; auto with geo. Qed. Lemma sin_cos_pisurdeux_moins_x : forall x : R, sin x = cos (pisurdeux + - x). intros. elim existence_AB_unitaire; intros A H; elim H; intros B H0; try clear H; try exact H0. elim existence_representant_angle with (A := A) (B := B) (C := A) (x := x); [ intros C H; elim H; intros H1 H2; try clear H; try exact H2 | auto ]. elim existence_ROND_AB with (A := A) (B := B); [ intros D H; try exact H | auto ]. rewrite (def_sin (A:=A) (B:=B) (C:=C) (D:=D) (x:=x)); auto. cut (image_angle (- x) = cons_AV (vec A C) (vec A B)); intros. replace (pisurdeux + - x) with (- x + pisurdeux); try ring. elim H; intros. elim H5; intros H6 H7; try clear H5; try exact H7. rewrite (def_cos (A:=A) (B:=C) (C:=D) (x:=- x + pisurdeux)); auto with geo. rewrite add_mes_compatible. rewrite H3; rewrite H4; rewrite Chasles; auto with geo. apply mes_oppx; auto with geo. Qed. Lemma cos_sin_pisurdeux_moins_x : forall x : R, cos x = sin (pisurdeux + - x). intros. rewrite sin_cos_pisurdeux_moins_x. replace (pisurdeux + - (pisurdeux + - x)) with x; try ring. Qed. Lemma cos_zero : cos 0 = 1. elim existence_AB_unitaire; intros A H; elim H; intros B H0; try clear H; try exact H0. rewrite (def_cos (A:=A) (B:=B) (C:=B) (x:=0)); auto with geo. rewrite <- angle_nul; auto with geo. Qed. Lemma sin_zero : sin 0 = 0. elim existence_AB_unitaire; intros A H; elim H; intros B H0; try clear H; try exact H0. elim existence_ROND_AB with (A := A) (B := B); [ intros D H | auto ]. elim H; intros. rewrite (def_sin (A:=A) (B:=B) (C:=B) (D:=D) (x:=0)); auto with geo. rewrite <- angle_nul; auto with geo. Qed. Lemma cos_pisurdeux : cos pisurdeux = 0. elim existence_AB_unitaire; intros A H; elim H; intros B H0; try clear H; try exact H0. elim existence_ROND_AB with (A := A) (B := B); [ intros D H | auto ]. elim H; intros. elim H2; intros H3 H4; try clear H2; try exact H4. rewrite (def_cos (A:=A) (B:=B) (C:=D) (x:=pisurdeux)); auto with geo. Qed. Lemma sin_pisurdeux : sin pisurdeux = 1. elim existence_AB_unitaire; intros A H; elim H; intros B H0; try clear H; try exact H0. elim existence_ROND_AB with (A := A) (B := B); [ intros D H | auto ]. elim H; intros. elim H2; intros H3 H4; try clear H2; try exact H4. rewrite (def_sin (A:=A) (B:=B) (C:=D) (D:=D) (x:=pisurdeux)); auto with geo. Qed. Lemma cos_pi : cos pi = -1. elim existence_AB_unitaire; intros A H; elim H; intros B H0; try clear H; try exact H0. elim existence_representant_mult_vecteur with (A := A) (B := A) (C := B) (k := -1); intros D H1. cut (scalaire (vec A D) (vec A D) = 1); intros. rewrite (def_cos (A:=A) (B:=B) (C:=D) (x:=pi)); auto with geo. rewrite H1. Simplscal; rewrite carre_scalaire_distance; rewrite H0; ring. replace (vec A D) with (vec B A). rewrite <- angle_plat; auto with geo. rewrite H1. Ringvec. rewrite H1. Simplscal; rewrite carre_scalaire_distance; rewrite H0; ring. Qed. Lemma sin_pi : sin pi = 0. elim existence_AB_unitaire; intros A H; elim H; intros B H0; try clear H; try exact H0. elim existence_ROND_AB with (A := A) (B := B); [ intros D H | auto ]. elim H; intros. elim H2; intros H4 H5; try clear H2; try exact H4. elim existence_representant_mult_vecteur with (A := A) (B := A) (C := B) (k := -1); intros E H3. rewrite (def_sin (A:=A) (B:=B) (C:=E) (D:=D) (x:=pi)); auto. rewrite H3. cut (scalaire (vec A B) (vec A D) = 0); auto with geo; intros. Simplscal; rewrite H2; ring. cut (scalaire (vec A E) (vec A E) = 1); auto with geo; intros. rewrite H3. Simplscal; rewrite H4; ring. replace (vec A E) with (vec B A). rewrite <- angle_plat; auto with geo. rewrite H3. Ringvec. Qed. Lemma coordonnees_cos_sin : forall (x : R) (O I J M : PO), repere_orthonormal_direct O I J -> image_angle x = cons_AV (vec O I) (vec O M) -> distance O M = 1 -> vec O M = add_PP (mult_PP (cos x) (vec O I)) (mult_PP (sin x) (vec O J)) :>PP. intros. elim H; intros. elim H3; intros H4 H5; try clear H3; try exact H5. rewrite (def_sin (A:=O) (B:=I) (C:=M) (D:=J) (x:=x)); auto with geo. rewrite (def_cos (A:=O) (B:=I) (C:=M) (x:=x)); auto with geo. pattern (vec O M) at 1 in |- *. rewrite (coordonnees_scalaire_base (O:=O) (I:=I) (J:=J) M); auto with geo. rewrite scalaire_sym; auto. Qed. Lemma calcul_cos_sin : forall (x a b : R) (O I J M : PO), repere_orthonormal_direct O I J -> image_angle x = cons_AV (vec O I) (vec O M) -> distance O M = 1 -> vec O M = add_PP (mult_PP a (vec O I)) (mult_PP b (vec O J)) :>PP -> a = cos x /\ b = sin x. intros. apply unicite_coordonnees with (2 := H2); auto with geo. apply coordonnees_cos_sin; auto. Qed. Lemma trigo_Pythagore : forall x : R, Rsqr (cos x) + Rsqr (sin x) = 1. unfold Rsqr in |- *; intros. elim existence_AB_unitaire; intros A H; elim H; intros B H0; try clear H; try exact H0. elim existence_representant_angle with (A := A) (B := B) (C := A) (x := x); [ intros C H; elim H; intros H1 H2; try clear H; try exact H2 | auto ]. elim existence_ROND_AB with (A := A) (B := B); [ intros D H | auto ]. elim H; intros. cut (vec A C = add_PP (mult_PP (cos x) (vec A B)) (mult_PP (sin x) (vec A D))); intros. replace 1 with (scalaire (vec A C) (vec A C)); auto with geo. rewrite H5. Simplscal. elim H4; intros H6 H7; try clear H4; try exact H7. rewrite H7; rewrite H6. rewrite (pisurdeux_scalaire_nul (A:=A) (B:=B) (C:=D)); auto. rewrite scalaire_sym. rewrite (pisurdeux_scalaire_nul (A:=A) (B:=B) (C:=D)); auto. ring. apply coordonnees_cos_sin; auto. Qed. Lemma pisurdeux_plus_x : forall x : R, cos (pisurdeux + x) = - sin x /\ sin (pisurdeux + x) = cos x. intros. elim existence_AB_unitaire; intros A H; elim H; intros B H0; try clear H; try exact H0. elim existence_ROND_AB with (A := A) (B := B); [ intros D H10 | auto ]. elim existence_representant_angle with (A := A) (B := B) (C := A) (x := pisurdeux + x); [ intros C H; elim H; intros H1 H2; try clear H; try exact H2 | auto ]. elim H10; intros. elim H3; intros H6 H7; try clear H3; try exact H7. elim existence_representant_mult_vecteur with (A := A) (B := A) (C := B) (k := -1); intros E H4. cut (image_angle x = cons_AV (vec A D) (vec A C)); intros. generalize (coordonnees_cos_sin (x:=pisurdeux + x) (O:=A) (I:=B) (J:=D) (M:=C)); intros. generalize (coordonnees_cos_sin (x:=x) (O:=A) (I:=D) (J:=E) (M:=C)); intros. cut (vec A C = add_PP (mult_PP (- sin x) (vec A B)) (mult_PP (cos x) (vec A D))); intros. apply unicite_coordonnees with (3 := H9); auto with geo. rewrite H8; auto. rewrite H4. unfold vec in |- *; RingPP. apply ROND_new with B; auto. replace x with (- pisurdeux + (pisurdeux + x)); try ring. replace (cons_AV (vec A D) (vec A C)) with (plus (cons_AV (vec A D) (vec A B)) (cons_AV (vec A B) (vec A C))). replace (cons_AV (vec A D) (vec A B)) with (image_angle (- pisurdeux)). rewrite <- H2. apply add_mes_compatible. apply mes_oppx; auto with geo. apply Chasles; auto with geo. Qed. Lemma sin_impaire : forall x : R, sin (- x) = - sin x. intros. elim pisurdeux_plus_x with (x := - x); intros H H0; try clear pisurdeux_plus_x; try exact H. replace (sin (- x)) with (-1 * - sin (- x)). rewrite <- H. replace (- x + pisurdeux) with (pisurdeux + - x). rewrite <- sin_cos_pisurdeux_moins_x. ring. ring. ring. Qed. Lemma pi_moins_x : forall x : R, cos (pi + - x) = - cos x /\ sin (pi + - x) = sin x. intros. unfold pi in |- *. replace (pisurdeux + pisurdeux + - x) with (pisurdeux + (pisurdeux + - x)). elim pisurdeux_plus_x with (x := pisurdeux + - x); intros H H0; try clear pisurdeux_plus_x; try exact H0. rewrite H0; rewrite H. split; [ try assumption | idtac ]. rewrite cos_sin_pisurdeux_moins_x; auto. rewrite sin_cos_pisurdeux_moins_x; auto. ring. Qed. Lemma pi_plus_x : forall x : R, cos (pi + x) = - cos x /\ sin (pi + x) = - sin x. intros. elim pi_moins_x with (x := - x); intros H H0; try clear pi_moins_x; try exact H0. replace (pi + x) with (pi + - - x). rewrite H0; rewrite H. split; [ try assumption | idtac ]. rewrite cos_paire; auto. rewrite sin_impaire; auto. ring. Qed. Theorem cos_diff : forall a b : R, cos (a + - b) = cos a * cos b + sin a * sin b. intros. elim existence_AB_unitaire; intros A H; elim H; intros B H0; try clear H; try exact H0. elim existence_ROND_AB with (A := A) (B := B); [ intros D H10 | auto ]. elim existence_representant_angle with (A := A) (B := B) (C := A) (x := a); [ intros C H; elim H; intros H1 H2; try clear H; try exact H2 | auto ]. elim existence_representant_angle with (A := A) (B := B) (C := A) (x := b); [ intros E H; elim H; intros H3 H4; try clear H; try exact H4 | auto ]. generalize (coordonnees_cos_sin (x:=a) (O:=A) (I:=B) (J:=D) (M:=C)); intros H. generalize (coordonnees_cos_sin (x:=b) (O:=A) (I:=B) (J:=D) (M:=E)); intros. replace (cos a * cos b + sin a * sin b) with (scalaire (vec A C) (vec A E)). cut (image_angle (a + - b) = cons_AV (vec A E) (vec A C)); intros. rewrite (def_cos (A:=A) (B:=E) (C:=C) (x:=a + - b)); auto. rewrite scalaire_sym; auto. replace (cons_AV (vec A E) (vec A C)) with (plus (cons_AV (vec A E) (vec A B)) (cons_AV (vec A B) (vec A C))). replace (cons_AV (vec A E) (vec A B)) with (image_angle (- b)). rewrite <- H2. replace (a + - b) with (- b + a). apply add_mes_compatible. ring. apply mes_oppx; auto with geo. apply Chasles; auto with geo. rewrite H5; auto. rewrite H; auto. Simplscal. elim H10; intros. elim H7; intros H8 H9; try clear H7; try exact H9. cut (scalaire (vec A B) (vec A D) = 0); auto with geo; intros. rewrite H9; rewrite H8; rewrite H7. rewrite scalaire_sym; rewrite H7. ring. Qed. Lemma cos_som : forall a b : R, cos (a + b) = cos a * cos b + - (sin a * sin b). intros. replace (a + b) with (a + - - b). rewrite (cos_diff a (- b)). rewrite cos_paire. rewrite sin_impaire. ring. ring. Qed. Lemma sin_som : forall a b : R, sin (a + b) = sin a * cos b + sin b * cos a. intros. replace (sin (a + b)) with (cos (pisurdeux + - (a + b))). replace (pisurdeux + - (a + b)) with (pisurdeux + - a + - b). rewrite cos_diff. rewrite <- sin_cos_pisurdeux_moins_x. rewrite <- cos_sin_pisurdeux_moins_x. ring. ring. rewrite <- sin_cos_pisurdeux_moins_x; auto. Qed. Lemma sin_diff : forall a b : R, sin (a + - b) = sin a * cos b + - (sin b * cos a). intros. rewrite sin_som. rewrite cos_paire. rewrite sin_impaire. ring. Qed. Lemma duplication_cos : forall a : R, cos (2 * a) = 2 * Rsqr (cos a) + -1. intros. repeat rewrite double. rewrite cos_som. rewrite <- (trigo_Pythagore a). unfold Rsqr; ring. Qed. Lemma duplication_cos2 : forall a : R, cos (2 * a) = 1 + - (2 * Rsqr (sin a)). intros. repeat rewrite double. rewrite cos_som. rewrite <- (trigo_Pythagore a). unfold Rsqr; ring. Qed. Lemma duplication_sin : forall a : R, sin (2 * a) = 2 * (sin a * cos a). intros. repeat rewrite double. rewrite sin_som; auto. Qed. Lemma coordonnees_polaires_cartesiennes : forall (x y a r : R) (O I J M : PO), repere_orthonormal_direct O I J -> O <> M -> r = distance O M -> image_angle a = cons_AV (vec O I) (vec O M) -> vec O M = add_PP (mult_PP x (vec O I)) (mult_PP y (vec O J)) :>PP -> x = r * cos a /\ y = r * sin a. intros. apply unicite_coordonnees with (2 := H3); auto with geo. elim existence_representant_unitaire with (A := O) (B := M); [ intros C H4; try clear existence_unitaire; try exact H4 | auto ]. rewrite (distance_vecteur (A:=O) (B:=M)); auto. rewrite <- H4. rewrite (coordonnees_cos_sin (x:=a) (O:=O) (I:=I) (J:=J) (M:=C)); auto. rewrite <- H1. unfold vec in |- *; RingPP. rewrite H2. rewrite H4. inversion H. elim H6; intros H7 H8; try clear H6; try exact H7. rewrite angles_representants_unitaires; auto with geo. replace (representant_unitaire (vec O I)) with (vec O I); auto with geo. elim def_representant_unitaire2 with (A := O) (B := M) (C := C); [ intros; elim H6; intros H7 H8; try clear H6 def_representant_unitaire2; auto with geo | auto | auto ]. Qed. Lemma trivial_cos_Cos : forall (A B C : PO) (x : R), distance A B = 1 -> distance A C = 1 -> image_angle x = cons_AV (vec A B) (vec A C) -> cos x = Cos (cons_AV (vec A B) (vec A C)). intros. rewrite (def_cos (A:=A) (B:=B) (C:=C) (x:=x)); auto. rewrite (def_Cos (A:=A) (B:=B) (C:=C)); auto. Qed. Lemma egalite_cos_Cos : forall (A B C : PO) (x : R), A <> B -> A <> C -> image_angle x = cons_AV (vec A B) (vec A C) -> cos x = Cos (cons_AV (vec A B) (vec A C)). intros. elim existence_representant_unitaire with (A := A) (B := B); [ intros B' H2; try clear existence_representant_unitaire; try exact H2 | auto ]. elim existence_representant_unitaire with (A := A) (B := C); [ intros C' H3; try clear existence_representant_unitaire; try exact H3 | auto ]. rewrite (trivial_cos_Cos (A:=A) (B:=B') (C:=C') (x:=x)); auto. rewrite H2; rewrite H3; auto. rewrite angles_representants_unitaires; auto. elim def_representant_unitaire2 with (A := A) (B := B) (C := B'); auto; intros. elim H5; auto with geo. elim def_representant_unitaire2 with (A := A) (B := C) (C := C'); auto; intros. elim H5; auto with geo. rewrite H2; rewrite H3; rewrite H1; rewrite angles_representants_unitaires; auto with geo. Qed. Lemma trivial_sin_Sin : forall (A B C D : PO) (x : R), distance A B = 1 -> distance A C = 1 -> image_angle x = cons_AV (vec A B) (vec A C) -> repere_orthonormal_direct A B D -> sin x = Sin (cons_AV (vec A B) (vec A C)). intros. rewrite (def_sin (A:=A) (B:=B) (C:=C) (D:=D) (x:=x)); auto. rewrite (def_Sin (A:=A) (B:=B) (C:=C) (D:=D)); auto. Qed. Lemma egalite_sin_Sin : forall (A B C : PO) (x : R), A <> B -> A <> C -> image_angle x = cons_AV (vec A B) (vec A C) -> sin x = Sin (cons_AV (vec A B) (vec A C)). intros. elim existence_representant_unitaire with (A := A) (B := B); [ intros B' H2; try clear existence_representant_unitaire; try exact H2 | auto ]. elim existence_ROND_AB with (A := A) (B := B'); [ intros D H10 | auto ]. elim existence_representant_unitaire with (A := A) (B := C); [ intros C' H3; try clear existence_representant_unitaire; try exact H3 | auto ]. rewrite (trivial_sin_Sin (A:=A) (B:=B') (C:=C') (D:=D) (x:=x)); auto. rewrite H2; rewrite H3; auto. rewrite angles_representants_unitaires; auto. elim def_representant_unitaire2 with (A := A) (B := B) (C := B'); auto; intros. elim H5; auto with geo. elim def_representant_unitaire2 with (A := A) (B := C) (C := C'); auto; intros. elim H5; auto with geo. rewrite H2; rewrite H3; rewrite H1; rewrite angles_representants_unitaires; auto. elim def_representant_unitaire2 with (A := A) (B := B) (C := B'); auto with geo; intros. elim H4; auto with geo. Qed. Lemma coordonnees_Cos_Sin : forall O I J M : PO, repere_orthonormal_direct O I J -> distance O M = 1 -> vec O M = add_PP (mult_PP (Cos (cons_AV (vec O I) (vec O M))) (vec O I)) (mult_PP (Sin (cons_AV (vec O I) (vec O M))) (vec O J)) :>PP. intros. elim H; intros. elim H2; intros H4 H5; try clear H2. mesure O I O M. rewrite H2. rewrite <- (trivial_sin_Sin (A:=O) (B:=I) (C:=M) (D:=J) (x:=x)); auto with geo. rewrite <- (trivial_cos_Cos (A:=O) (B:=I) (C:=M) (x:=x)); auto with geo. apply coordonnees_cos_sin; auto. Qed. Lemma calcul_Cos_Sin : forall (a b : R) (O I J M : PO), repere_orthonormal_direct O I J -> distance O M = 1 -> vec O M = add_PP (mult_PP a (vec O I)) (mult_PP b (vec O J)) :>PP -> a = Cos (cons_AV (vec O I) (vec O M)) /\ b = Sin (cons_AV (vec O I) (vec O M)). intros. elim H; intros. elim H3; intros H4 H5; try clear H3. mesure O I O M. rewrite H3. rewrite <- (trivial_sin_Sin (A:=O) (B:=I) (C:=M) (D:=J) (x:=x)); auto with geo. rewrite <- (trivial_cos_Cos (A:=O) (B:=I) (C:=M) (x:=x)); auto with geo. apply (calcul_cos_sin (x:=x) (a:=a) (b:=b) (O:=O) (I:=I) (J:=J) (M:=M)); auto. Qed. Axiom egalite_angle_trigo : forall x y : R, sin x = sin y -> cos x = cos y -> image_angle x = image_angle y. Hint Resolve egalite_angle_trigo: geo. HighSchoolGeometry/vecteur.v0000644000076500007650000001667712353122777016117 0ustar coqcoq00000000000000(* This program is free software; you can redistribute it and/or *) (* modify it under the terms of the GNU Lesser General Public License *) (* as published by the Free Software Foundation; either version 2.1 *) (* of the License, or (at your option) any later version. *) (* *) (* This program is distributed in the hope that it will be useful, *) (* but WITHOUT ANY WARRANTY; without even the implied warranty of *) (* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *) (* GNU General Public License for more details. *) (* *) (* You should have received a copy of the GNU Lesser General Public *) (* License along with this program; if not, write to the Free *) (* Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA *) (* 02110-1301 USA *) Require Export Classical. Require Export Field_affine. Set Implicit Arguments. Unset Strict Implicit. Definition vec (A B : PO) := add_PP (cons (-1) A) (cons 1 B). Ltac Ringvec := unfold vec in |- *; RingPP. Ltac Fieldvec k := unfold vec in |- *; FieldPP k. Ltac contrapose H := match goal with | h:(~ _) |- (~ _) => red in |- *; intros; apply h end. Lemma Chasles_vec : forall A B C : PO, add_PP (vec A B) (vec B C) = vec A C. intros; Ringvec. Qed. Lemma opp_vecteur : forall A B : PO, vec B A = mult_PP (-1) (vec A B). intros; Ringvec. Qed. Lemma egalite_vecteur : forall A B C D : PO, vec A B = vec C D -> vec A C = vec B D. unfold vec in |- *; intros. RingPP1 H. RingPP. Qed. Hint Resolve egalite_vecteur: geo. Definition parallelogramme (A B C D : PO) := vec A B = vec D C. Hint Unfold parallelogramme: geo. Lemma parallelogramme_ordre_cycle : forall A B C D : PO, parallelogramme A B C D -> parallelogramme B C D A. unfold parallelogramme in |- *; intros. symmetry in |- *; auto with geo. Qed. Lemma parallelogramme_ordre_permute : forall A B C D : PO, parallelogramme A B C D -> parallelogramme A D C B. unfold parallelogramme in |- *; intros. auto with geo. Qed. Hint Immediate parallelogramme_ordre_permute: geo. Hint Resolve parallelogramme_ordre_cycle: geo. Lemma add_PP_vecteur : forall (a b : R) (A B C M : PO), a + b <> 0 -> add_PP (cons a A) (cons b B) = cons (a + b) C -> add_PP (mult_PP a (vec M A)) (mult_PP b (vec M B)) = mult_PP (a + b) (vec M C). unfold vec in |- *; intros. repeat rewrite <- distrib_mult_cons; auto. replace (a * 1) with a; try ring; auto. RingPP1 H0. RingPP. Qed. Lemma calcul : forall P Q T U : PP, add_PP (add_PP P Q) (add_PP T U) = add_PP (add_PP P T) (add_PP Q U). intros P Q T U; RingPP. Qed. Lemma add_PP_vecteur_rec : forall (a b : R) (A B C M : PO), a + b <> 0 -> add_PP (mult_PP a (vec M A)) (mult_PP b (vec M B)) = mult_PP (a + b) (vec M C) -> add_PP (cons a A) (cons b B) = cons (a + b) C. unfold vec in |- *; intros. repeat rewrite <- distrib_mult_cons in H0; auto. replace a with (a * 1); try ring; auto. rewrite calcul in H0. replace b with (b * 1). RingPP2 H0. RingPP. ring. Qed. Lemma add_PP_vecteur_opp : forall (a : R) (A B C M : PO), add_PP (mult_PP a (vec M A)) (mult_PP (- a) (vec M B)) = mult_PP a (vec B A). intros; Ringvec. Qed. Lemma add_PP_assoc_permute : forall P Q T : PP, add_PP P (add_PP Q T) = add_PP (add_PP P T) Q :>PP. intros P Q T; RingPP. Qed. Lemma vecteur_nul : forall (a : R) (A : PO), zero = mult_PP a (vec A A). intros; Ringvec. Qed. Lemma mult_1_vec : forall A B : PO, mult_PP 1 (vec A B) = vec A B. intros; Ringvec. Qed. Lemma add_PP_vec_reg : forall (P Q : PP) (a : R) (A B : PO), add_PP (mult_PP a (vec A B)) P = add_PP (mult_PP a (vec A B)) Q -> P = Q. unfold vec in |- *; intros. RingPP2 H. RingPP. Qed. Lemma add_opp_vec : forall (k : R) (A B : PO), add_PP (mult_PP k (vec A B)) (mult_PP (- k) (vec A B)) = zero. intros; Ringvec. Qed. Lemma mult_mult_vec : forall (A B : PO) (k k' : R), mult_PP k (mult_PP k' (vec A B)) = mult_PP (k * k') (vec A B) :>PP. intros; Ringvec. Qed. Lemma distrib_mult_vec : forall (A B C D : PO) (k : R), mult_PP k (add_PP (vec A B) (vec C D)) = add_PP (mult_PP k (vec A B)) (mult_PP k (vec C D)) :>PP. intros; Ringvec. Qed. Lemma conversion_PP : forall (a b : R) (A B : PO), cons a A = cons b B :>PP -> a <> 0 :>R -> a = b :>R -> A = B :>PO. intros a b A B H H0 H1; try assumption. elim cons_inj with (a := a) (b := b) (A := A) (B := B); intros; try assumption. Qed. Lemma produit_vecteur_nul : forall (a : R) (A B : PO), mult_PP a (vec A B) = zero -> a = 0 \/ A = B. unfold vec in |- *; intros. elim (classic (a = 0)); intros. left; try assumption. right; try assumption. apply conversion_PP with (a := a) (b := a); try ring; auto. cut (add_PP (cons (- a) A) (cons a B) = zero); intros. RingPP2 H1. RingPP. rewrite <- H. RingPP. Qed. Lemma vecteur_egalite_point : forall (a : R) (A B : PO), mult_PP a (vec A B) = zero -> a <> 0 -> A = B. intros a A B H H0; try assumption. generalize produit_vecteur_nul; intros. elim H1 with (a := a) (A := A) (B := B); [ intros H2; try clear H1 | intros H2; try clear H1; try exact H2 | try clear H1 ]. absurd (a = 0); auto. auto. Qed. Lemma distinct_produit_vecteur : forall (A B C : PO) (a : R), A <> B -> a <> 0 -> vec A C = mult_PP a (vec A B) :>PP -> A <> C. intros; red in |- *; intros. cut (~ (a = 0 \/ A = B)); intros. apply H3. apply produit_vecteur_nul. rewrite <- H1. rewrite H2; Ringvec. intuition. Qed. Lemma vecteur_nul_conf : forall A B : PO, vec A B = zero -> A = B. unfold vec in |- *; intros. apply conversion_PP with (a := 1) (b := 1); auto. RingPP2 H; RingPP. discrR. Qed. Lemma distinct_egalite_vecteur : forall A B C D : PO, A <> B :>PO -> vec C D = vec A B :>PP -> C <> D :>PO. red in |- *; intros. apply H; apply vecteur_nul_conf. rewrite <- H0; rewrite <- H1; Ringvec. Qed. Lemma inversion_colineaire : forall (k : R) (A B C : PO), A <> C -> vec A C = mult_PP k (vec A B) -> vec A B = mult_PP (/ k) (vec A C). intros. cut (k <> 0); intros. rewrite H0. Fieldvec k. contrapose H. apply vecteur_nul_conf. rewrite H0; rewrite H1; Ringvec. Qed. Hint Resolve inversion_colineaire: geo. Ltac subst_ A B := match goal with | h:(A = B) |- _ => rewrite h || (try rewrite <- h); auto with geo end. Ltac discrimine A B := elim (classic (A = B)); intro; [ subst_ A B | idtac ]. Lemma produit_zero_conf : forall (k : R) (A B C D : PO), vec A B = mult_PP k (vec C D) -> k = 0 -> A = B. intros. apply vecteur_nul_conf. rewrite H; rewrite H0; Ringvec. Qed. Lemma egalite_vecteur_point : forall A B C : PO, vec C A = vec C B :>PP -> A = B :>PO. intros. apply vecteur_nul_conf. replace (vec A B) with (add_PP (vec C B) (mult_PP (-1) (vec C A))); [ idtac | Ringvec ]. rewrite H; Ringvec. Qed. Ltac RReplace a b := replace a with b; [ idtac | try ring; auto with real ]. Ltac VReplace a b := replace a with b; [ idtac | Ringvec ]. Ltac FVReplace a b k := replace a with b; [ idtac | Fieldvec k ]. Lemma distinct_col_nonzero : forall (A B C D : PO) (x : R), A <> B -> vec A B = mult_PP x (vec C D) -> x <> 0. intros. contrapose H. apply vecteur_nul_conf. rewrite H0; rewrite H1. Ringvec. Qed. Lemma distinct_col_nonun : forall (A B C : PO) (x : R), B <> C -> vec A C = mult_PP x (vec A B) -> 1 + - x <> 0. intros. contrapose H. cut (x = 1); intros. apply vecteur_nul_conf. VReplace (vec B C) (add_PP (vec B A) (vec A C)). rewrite H0. subst_ x 1; Ringvec. RReplace x (x + 0). rewrite <- H1; ring. Qed.