Avoid repetition in Coq - dry

Question

I'm currently trying to implement Hilbert's geometry in Coq. When proving, very often a section of the proof is repeated multiple times; for example, here I'm trying to prove that there exists 3 lines which are different from each other.
Proposition prop3_2 : (exists l m n: Line, (l<>m/\m<>n/\n<>l)).
Proof.
destruct I3 as [A [B [C [[AneB [BneC CneA]] nAlgn]]]].
destruct ((I1 A B) AneB) as [AB [incAB unAB]].
destruct ((I1 B C) BneC) as [BC [incBC unBC]].
destruct ((I1 C A) CneA) as [CA [incCA unCA]].
refine (ex_intro _ AB _).
refine (ex_intro _ BC _).
refine (ex_intro _ CA _).
split.
(* Proving AB <> BC through contradiction *)
case (classic (AB = BC)).
intros AB_e_BC.
rewrite AB_e_BC in incAB.
pose (conj incBC (proj2 incAB)) as incABC.
specialize (nAlgn BC).
tauto.
trivial.
split.
(* Proving BC <> CA through contradiction *)
case (classic (BC = CA)).
intros BC_e_CA.
rewrite BC_e_CA in incBC.
pose (conj incCA (proj2 incBC)) as incABC.
specialize (nAlgn CA).
tauto.
trivial.
(* Proving CA <> AB through contradiction *)
case (classic (CA = AB)).
intros CA_e_AB.
rewrite CA_e_AB in incCA.
pose (conj incAB (proj2 incCA)) as incABC.
specialize (nAlgn AB).
tauto.
trivial.
Qed.
It'd be very nice if there was something like a macro in these cases.
I thought about creating a sub-proof halfway through:
Lemma prop3_2_a: (forall (A B C:Point) (AB BC:Line)
(incAB:(Inc B AB /\ Inc A AB)) (incBC:(Inc C BC /\ Inc B BC))
(nAlgn : forall l : Line, ~ (Inc A l /\ Inc B l /\ Inc C l)),
AB <> BC).
Proof.
...
But that's pretty cumbersome, and I'd have to create three different versions of nAlgn ordered differently, which is manageable but annoying.
The code can be found here: https://github.com/GiacomoMaletto/Hilbert/blob/master/hilbert.v
(Btw Any other comments on style or whatever are appreciated).

Answer 1

First, some simple advice to refactor the three cases individually.
At the start of each of them, the goal looks like this:
...
--------------
AB <> BC
The subsequent case analysis on (AB = BC) is somewhat redundant. The first case (AB = BC) is the interesting one, where you need to prove a contradiction, and the second case (AB <> BC) is trivial. A shorter way is intro AB_e_BC, which asks you just to prove the first case. This works because AB <> BC actually means AB = BC -> False.
The other steps are mostly straightforward propositional reasoning that can be bruteforced via tauto, except for a bit of rewriting and a crucial use of specialize. The rewriting only uses an equality between variables AB and BC, in that case you can use the subst shorthand that rewrites using all equalities where one side is a variable. So this fragment:
(* Proving AB <> BC through contradiction *)
case (classic (AB = BC)).
intros AB_e_BC.
rewrite AB_e_BC in incAB.
pose (conj incBC (proj2 incAB)) as incABC.
specialize (nAlgn BC).
tauto.
trivial.
becomes
intro; specialize (nAlgnABC BC); subst; tauto.
Now you still don't want to write that three times. The only varying part now is the variable BC. Luckily, you can read that off the goal before intro.
--------------
AB <> BC
^----- there's BC (and in the other two cases, CA and AB)
Actually picking either AB or BC is fine, since intro makes the assumption they're equal. You can use match goal with to parameterize your tactic by bits from the goal.
match goal with
| [ |- _ <> ?l ] => intro; specialize (nAlgnABC l); subst; tauto
end.
(* The syntax is:
match goal with
| [ |- ??? ] => tactics
end.
where ??? is an expression with wildcards (_) and existential
variables (?l), that can be referred to inside the body "tactics"
(without the question mark) *)
Next, moving up before the split:
-------------------------------------------
AB <> BC /\ BC <> CA /\ CA <> AB
You can compose tactics to get three subgoals at once: split; [| split]. (meaning, split once, and in the second subgoal split again).
Finally, you want to apply the match tactic above for each subgoal, that's another semicolon:
split; [| split];
match goal with
| [ |- _ <> ?l ] => intro; specialize (nAlgnABC l); subst; tauto
end.
I would also recommend using bullets and braces to structure your proof, so that when your definitions change, you avoid entering confusing proof states because tactics get applied to the wrong subgoal. Here are some possible layouts for a three-case proof:
split.
- ...
...
- split.
+ ...
...
+ ...
...
split; [| split].
- ...
...
- ...
...
- ...
...
split; [| split].
{ ...
...
}
{ ...
...
}
{ ...
...
}