| inductive Foo (α : Type u) where | |
| | mk1 (val : α) | |
| | mk2 (left : Foo α) (right : Foo α) | |
| | mk3 (val : Nat) | |
| | mk4 (val : String) | |
| | mk5 (head : α) (tail : Foo α) | |
| def Foo.ctorIdx : Foo α → Nat | |
| | .mk1 .. => 0 | |
| | .mk2 .. => 1 | |
| | .mk3 .. => 2 | |
| | .mk4 .. => 3 | |
| | .mk5 .. => 4 | |
| @[elab_as_elim] | |
| def Foo.elimCtor1 {motive : Foo α → Sort v} (a : Foo α) (hIdx : a.ctorIdx == 0) (h : (val : α) → motive (Foo.mk1 val)) : motive a := | |
| match a with | |
| | .mk1 a => h a | |
| | .mk2 .. => Bool.noConfusion hIdx | |
| | .mk3 .. => Bool.noConfusion hIdx | |
| | .mk4 .. => Bool.noConfusion hIdx | |
| | .mk5 .. => Bool.noConfusion hIdx | |
| @[elab_as_elim] | |
| def Foo.elimCtor2 {motive : Foo α → Sort v} (a : Foo α) (hIdx : a.ctorIdx == 1) (h : (left : Foo α) → (right : Foo α) → motive (Foo.mk2 left right)) : motive a := | |
| match a with | |
| | .mk1 .. => Bool.noConfusion hIdx | |
| | .mk2 left right => h left right | |
| | .mk3 .. => Bool.noConfusion hIdx | |
| | .mk4 .. => Bool.noConfusion hIdx | |
| | .mk5 .. => Bool.noConfusion hIdx | |
| @[elab_as_elim] | |
| def Foo.elimCtor3 {motive : Foo α → Sort v} (a : Foo α) (hIdx : a.ctorIdx == 2) (h : (val : Nat) → motive (Foo.mk3 val)) : motive a := | |
| match a with | |
| | .mk1 .. => Bool.noConfusion hIdx | |
| | .mk2 .. => Bool.noConfusion hIdx | |
| | .mk3 val => h val | |
| | .mk4 .. => Bool.noConfusion hIdx | |
| | .mk5 .. => Bool.noConfusion hIdx | |
| @[elab_as_elim] | |
| def Foo.elimCtor4 {motive : Foo α → Sort v} (a : Foo α) (hIdx : a.ctorIdx == 3) (h : (val : String) → motive (Foo.mk4 val)) : motive a := | |
| match a with | |
| | .mk1 .. => Bool.noConfusion hIdx | |
| | .mk2 .. => Bool.noConfusion hIdx | |
| | .mk3 .. => Bool.noConfusion hIdx | |
| | .mk4 val => h val | |
| | .mk5 .. => Bool.noConfusion hIdx | |
| @[elab_as_elim] | |
| def Foo.elimCtor5 {motive : Foo α → Sort v} (a : Foo α) (hIdx : a.ctorIdx == 4) (h : (head : α) → (tail : Foo α) → motive (Foo.mk5 head tail)) : motive a := | |
| match a with | |
| | .mk1 .. => Bool.noConfusion hIdx | |
| | .mk2 .. => Bool.noConfusion hIdx | |
| | .mk3 .. => Bool.noConfusion hIdx | |
| | .mk4 .. => Bool.noConfusion hIdx | |
| | .mk5 head tail => h head tail | |
| @[reducible] def Foo.noConfusionType' {α : Type u} (P : Sort v) (a b : Foo α) : Sort v := | |
| if h : b.ctorIdx == a.ctorIdx then | |
| match a with | |
| | .mk1 val1 => Foo.elimCtor1 (motive := fun _ => Sort v) b h (fun val2 => (val1 = val2 → P) → P) | |
| | .mk2 left1 right1 => Foo.elimCtor2 (motive := fun _ => Sort v) b h (fun left2 right2 => (left1 = left2 → right1 = right2 → P) → P) | |
| | .mk3 val1 => Foo.elimCtor3 (motive := fun _ => Sort v) b h (fun val2 => (val1 = val2 → P) → P) | |
| | .mk4 val1 => Foo.elimCtor4 (motive := fun _ => Sort v) b h (fun val2 => (val1 = val2 → P) → P) | |
| | .mk5 head1 tail1 => Foo.elimCtor5 (motive := fun _ => Sort v) b h (fun head2 tail2 => (head1 = head2 → tail1 = tail2 → P) → P) | |
| else | |
| P | |
| @[reducible] def Foo.noConfusion' {α : Type u} {P : Sort u_1} {v1 v2 : Foo α} (h : v1 = v2) : Foo.noConfusionType' P v1 v2 := | |
| Eq.ndrec (motive := fun a => v1 = a → Foo.noConfusionType' P v1 a) | |
| (fun (_ : v1 = v1) => | |
| Foo.casesOn v1 (fun _ h => h rfl) (fun _ _ h => h rfl rfl) (fun _ h => h rfl) (fun _ h => h rfl) (fun _ _ h => h rfl rfl)) | |
| h h | |
| def Foo.decEq {α : Type u} [DecidableEq α] (a b : Foo α) : Decidable (a = b) := | |
| if hc : b.ctorIdx == a.ctorIdx then | |
| match a with | |
| | mk1 val1 => Foo.elimCtor1 b hc fun val2 => if he : val1 = val2 then isTrue (he ▸ rfl) else isFalse (fun h => Foo.noConfusion' h fun h => he h) | |
| | mk2 left1 right1 => Foo.elimCtor2 b hc fun left2 right2 => | |
| match decEq left1 left2 with | |
| | isTrue he1 => match decEq right1 right2 with | |
| | isTrue he2 => isTrue (he1 ▸ he2 ▸ rfl) | |
| | isFalse he2 => isFalse (fun h => Foo.noConfusion' h fun _ h => he2 h) | |
| | isFalse he1 => isFalse (fun h => Foo.noConfusion' h fun h _ => he1 h) | |
| | mk3 val1 => Foo.elimCtor3 b hc fun val2 => if he : val1 = val2 then isTrue (he ▸ rfl) else isFalse (fun h => Foo.noConfusion' h fun h => he h) | |
| | mk4 val1 => Foo.elimCtor4 b hc fun val2 => if he : val1 = val2 then isTrue (he ▸ rfl) else isFalse (fun h => Foo.noConfusion' h fun h => he h) | |
| | mk5 head1 tail1 => Foo.elimCtor5 b hc fun head2 tail2 => | |
| if he1 : head1 = head2 then | |
| match decEq tail1 tail2 with | |
| | isTrue he2 => isTrue (he1 ▸ he2 ▸ rfl) | |
| | isFalse he2 => isFalse (fun h => Foo.noConfusion' h fun _ h => he2 h) | |
| else | |
| isFalse (fun h => Foo.noConfusion' h fun h _ => he1 h) | |
| else | |
| isFalse (fun h => have : ¬ b.ctorIdx == b.ctorIdx := h ▸ hc; this LawfulBEq.rfl) |