Datasets:

akjadhav
/

leandojo-lean4-formal-informal-strings-split

Dataset card Data Studio Files Files and versions Community

Split (3)

train · 47.4k rows

formal stringlengths 41 427k	informal stringclasses 1 value
Sum.elim_map α : Type u_1 β : Type u_2 ε : Sort u_3 γ : Type u_4 δ : Type u_5 f₁ : α → β f₂ : β → ε g₁ : γ → δ g₂ : δ → ε x : α ⊕ γ ⊢ Sum.elim f₂ g₂ (Sum.map f₁ g₁ x) = Sum.elim (f₂ ∘ f₁) (g₂ ∘ g₁) x cases x <;> rfl ** Qed
Sum.isLeft_map α : Type u_1 β : Type u_2 γ : Type u_3 δ : Type u_4 f : α → β g : γ → δ x : α ⊕ γ ⊢ isLeft (Sum.map f g x) = isLeft x cases x <;> rfl ** Qed
Sum.isRight_map α : Type u_1 β : Type u_2 γ : Type u_3 δ : Type u_4 f : α → β g : γ → δ x : α ⊕ γ ⊢ isRight (Sum.map f g x) = isRight x cases x <;> rfl ** Qed
Sum.getLeft?_map α : Type u_1 β : Type u_2 γ : Type u_3 δ : Type u_4 f : α → β g : γ → δ x : α ⊕ γ ⊢ getLeft? (Sum.map f g x) = Option.map f (getLeft? x) cases x <;> rfl ** Qed
Sum.getRight?_map α : Type u_1 β : Type u_2 γ : Type u_3 δ : Type u_4 f : α → β g : γ → δ x : α ⊕ γ ⊢ getRight? (Sum.map f g x) = Option.map g (getRight? x) cases x <;> rfl ** Qed
Sum.swap_swap α : Type u_1 β : Type u_2 x : α ⊕ β ⊢ swap (swap x) = x cases x <;> rfl ** Qed
Sum.isLeft_swap α : Type u_1 β : Type u_2 x : α ⊕ β ⊢ isLeft (swap x) = isRight x cases x <;> rfl ** Qed
Sum.isRight_swap α : Type u_1 β : Type u_2 x : α ⊕ β ⊢ isRight (swap x) = isLeft x cases x <;> rfl ** Qed
Sum.getLeft?_swap α : Type u_1 β : Type u_2 x : α ⊕ β ⊢ getLeft? (swap x) = getRight? x cases x <;> rfl ** Qed
Sum.getRight?_swap α : Type u_1 β : Type u_2 x : α ⊕ β ⊢ getRight? (swap x) = getLeft? x cases x <;> rfl ** Qed
Sum.LiftRel.mono α✝¹ : Type u_1 α✝ : Type u_2 r₁ r₂ : α✝¹ → α✝ → Prop β✝¹ : Type u_3 β✝ : Type u_4 s₁ s₂ : β✝¹ → β✝ → Prop x : α✝¹ ⊕ β✝¹ y : α✝ ⊕ β✝ hr : ∀ (a : α✝¹) (b : α✝), r₁ a b → r₂ a b hs : ∀ (a : β✝¹) (b : β✝), s₁ a b → s₂ a b h : LiftRel r₁ s₁ x y ⊢ LiftRel r₂ s₂ x y cases h case inl α✝¹ : Type u_1 α✝ : Type u_2 r₁ r₂ : α✝¹ → α✝ → Prop β✝¹ : Type u_3 β✝ : Type u_4 s₁ s₂ : β✝¹ → β✝ → Prop hr : ∀ (a : α✝¹) (b : α✝), r₁ a b → r₂ a b hs : ∀ (a : β✝¹) (b : β✝), s₁ a b → s₂ a b a✝¹ : α✝¹ c✝ : α✝ a✝ : r₁ a✝¹ c✝ ⊢ LiftRel r₂ s₂ (inl a✝¹) (inl c✝) exact LiftRel.inl (hr _ _ ‹_›) case inr α✝¹ : Type u_1 α✝ : Type u_2 r₁ r₂ : α✝¹ → α✝ → Prop β✝¹ : Type u_3 β✝ : Type u_4 s₁ s₂ : β✝¹ → β✝ → Prop hr : ∀ (a : α✝¹) (b : α✝), r₁ a b → r₂ a b hs : ∀ (a : β✝¹) (b : β✝), s₁ a b → s₂ a b b✝ : β✝¹ d✝ : β✝ a✝ : s₁ b✝ d✝ ⊢ LiftRel r₂ s₂ (inr b✝) (inr d✝) exact LiftRel.inr (hs _ _ ‹_›) ** Qed
Sum.LiftRel.swap α✝¹ : Type u_1 α✝ : Type u_2 r : α✝¹ → α✝ → Prop β✝¹ : Type u_3 β✝ : Type u_4 s : β✝¹ → β✝ → Prop x : α✝¹ ⊕ β✝¹ y : α✝ ⊕ β✝ h : LiftRel r s x y ⊢ LiftRel s r (swap x) (swap y) cases h case inl α✝¹ : Type u_1 α✝ : Type u_2 r : α✝¹ → α✝ → Prop β✝¹ : Type u_3 β✝ : Type u_4 s : β✝¹ → β✝ → Prop a✝¹ : α✝¹ c✝ : α✝ a✝ : r a✝¹ c✝ ⊢ LiftRel s r (swap (inl a✝¹)) (swap (inl c✝)) exact LiftRel.inr ‹_› case inr α✝¹ : Type u_1 α✝ : Type u_2 r : α✝¹ → α✝ → Prop β✝¹ : Type u_3 β✝ : Type u_4 s : β✝¹ → β✝ → Prop b✝ : β✝¹ d✝ : β✝ a✝ : s b✝ d✝ ⊢ LiftRel s r (swap (inr b✝)) (swap (inr d✝)) exact LiftRel.inl ‹_› ** Qed
Sum.LiftRel.lex α : Type u_1 β : Type u_2 r : α → α → Prop s : β → β → Prop a b : α ⊕ β h : LiftRel r s a b ⊢ Lex r s a b cases h case inl α : Type u_1 β : Type u_2 r : α → α → Prop s : β → β → Prop a✝¹ c✝ : α a✝ : r a✝¹ c✝ ⊢ Lex r s (inl a✝¹) (inl c✝) exact Lex.inl ‹_› case inr α : Type u_1 β : Type u_2 r : α → α → Prop s : β → β → Prop b✝ d✝ : β a✝ : s b✝ d✝ ⊢ Lex r s (inr b✝) (inr d✝) exact Lex.inr ‹_› ** Qed
Sum.Lex.mono α✝ : Type u_1 r₁ r₂ : α✝ → α✝ → Prop β✝ : Type u_2 s₁ s₂ : β✝ → β✝ → Prop x y : α✝ ⊕ β✝ hr : ∀ (a b : α✝), r₁ a b → r₂ a b hs : ∀ (a b : β✝), s₁ a b → s₂ a b h : Lex r₁ s₁ x y ⊢ Lex r₂ s₂ x y cases h case inl α✝ : Type u_1 r₁ r₂ : α✝ → α✝ → Prop β✝ : Type u_2 s₁ s₂ : β✝ → β✝ → Prop hr : ∀ (a b : α✝), r₁ a b → r₂ a b hs : ∀ (a b : β✝), s₁ a b → s₂ a b a₁✝ a₂✝ : α✝ h✝ : r₁ a₁✝ a₂✝ ⊢ Lex r₂ s₂ (inl a₁✝) (inl a₂✝) exact Lex.inl (hr _ _ ‹_›) case inr α✝ : Type u_1 r₁ r₂ : α✝ → α✝ → Prop β✝ : Type u_2 s₁ s₂ : β✝ → β✝ → Prop hr : ∀ (a b : α✝), r₁ a b → r₂ a b hs : ∀ (a b : β✝), s₁ a b → s₂ a b b₁✝ b₂✝ : β✝ h✝ : s₁ b₁✝ b₂✝ ⊢ Lex r₂ s₂ (inr b₁✝) (inr b₂✝) exact Lex.inr (hs _ _ ‹_›) case sep α✝ : Type u_1 r₁ r₂ : α✝ → α✝ → Prop β✝ : Type u_2 s₁ s₂ : β✝ → β✝ → Prop hr : ∀ (a b : α✝), r₁ a b → r₂ a b hs : ∀ (a b : β✝), s₁ a b → s₂ a b a✝ : α✝ b✝ : β✝ ⊢ Lex r₂ s₂ (inl a✝) (inr b✝) exact Lex.sep _ _ ** Qed
Sum.lex_acc_inl α✝ : Type u_1 r : α✝ → α✝ → Prop a : α✝ β✝ : Type u_2 s : β✝ → β✝ → Prop aca : Acc r a ⊢ Acc (Lex r s) (inl a) induction aca with \| intro _ _ IH => constructor intro y h cases h with \| inl h' => exact IH _ h' case intro α✝ : Type u_1 r : α✝ → α✝ → Prop a : α✝ β✝ : Type u_2 s : β✝ → β✝ → Prop x✝ : α✝ h✝ : ∀ (y : α✝), r y x✝ → Acc r y IH : ∀ (y : α✝), r y x✝ → Acc (Lex r s) (inl y) ⊢ Acc (Lex r s) (inl x✝) constructor case intro.h α✝ : Type u_1 r : α✝ → α✝ → Prop a : α✝ β✝ : Type u_2 s : β✝ → β✝ → Prop x✝ : α✝ h✝ : ∀ (y : α✝), r y x✝ → Acc r y IH : ∀ (y : α✝), r y x✝ → Acc (Lex r s) (inl y) ⊢ ∀ (y : α✝ ⊕ β✝), Lex r s y (inl x✝) → Acc (Lex r s) y intro y h case intro.h α✝ : Type u_1 r : α✝ → α✝ → Prop a : α✝ β✝ : Type u_2 s : β✝ → β✝ → Prop x✝ : α✝ h✝ : ∀ (y : α✝), r y x✝ → Acc r y IH : ∀ (y : α✝), r y x✝ → Acc (Lex r s) (inl y) y : α✝ ⊕ β✝ h : Lex r s y (inl x✝) ⊢ Acc (Lex r s) y cases h with \| inl h' => exact IH _ h' case intro.h.inl α✝ : Type u_1 r : α✝ → α✝ → Prop a : α✝ β✝ : Type u_2 s : β✝ → β✝ → Prop x✝ : α✝ h✝ : ∀ (y : α✝), r y x✝ → Acc r y IH : ∀ (y : α✝), r y x✝ → Acc (Lex r s) (inl y) a₁✝ : α✝ h' : r a₁✝ x✝ ⊢ Acc (Lex r s) (inl a₁✝) exact IH _ h' ** Qed
Sum.lex_acc_inr α✝ : Type u_1 r : α✝ → α✝ → Prop β✝ : Type u_2 s : β✝ → β✝ → Prop aca : ∀ (a : α✝), Acc (Lex r s) (inl a) b : β✝ acb : Acc s b ⊢ Acc (Lex r s) (inr b) induction acb with \| intro _ _ IH => constructor intro y h cases h with \| inr h' => exact IH _ h' \| sep => exact aca _ case intro α✝ : Type u_1 r : α✝ → α✝ → Prop β✝ : Type u_2 s : β✝ → β✝ → Prop aca : ∀ (a : α✝), Acc (Lex r s) (inl a) b x✝ : β✝ h✝ : ∀ (y : β✝), s y x✝ → Acc s y IH : ∀ (y : β✝), s y x✝ → Acc (Lex r s) (inr y) ⊢ Acc (Lex r s) (inr x✝) constructor case intro.h α✝ : Type u_1 r : α✝ → α✝ → Prop β✝ : Type u_2 s : β✝ → β✝ → Prop aca : ∀ (a : α✝), Acc (Lex r s) (inl a) b x✝ : β✝ h✝ : ∀ (y : β✝), s y x✝ → Acc s y IH : ∀ (y : β✝), s y x✝ → Acc (Lex r s) (inr y) ⊢ ∀ (y : α✝ ⊕ β✝), Lex r s y (inr x✝) → Acc (Lex r s) y intro y h case intro.h α✝ : Type u_1 r : α✝ → α✝ → Prop β✝ : Type u_2 s : β✝ → β✝ → Prop aca : ∀ (a : α✝), Acc (Lex r s) (inl a) b x✝ : β✝ h✝ : ∀ (y : β✝), s y x✝ → Acc s y IH : ∀ (y : β✝), s y x✝ → Acc (Lex r s) (inr y) y : α✝ ⊕ β✝ h : Lex r s y (inr x✝) ⊢ Acc (Lex r s) y cases h with \| inr h' => exact IH _ h' \| sep => exact aca _ case intro.h.inr α✝ : Type u_1 r : α✝ → α✝ → Prop β✝ : Type u_2 s : β✝ → β✝ → Prop aca : ∀ (a : α✝), Acc (Lex r s) (inl a) b x✝ : β✝ h✝ : ∀ (y : β✝), s y x✝ → Acc s y IH : ∀ (y : β✝), s y x✝ → Acc (Lex r s) (inr y) b₁✝ : β✝ h' : s b₁✝ x✝ ⊢ Acc (Lex r s) (inr b₁✝) exact IH _ h' case intro.h.sep α✝ : Type u_1 r : α✝ → α✝ → Prop β✝ : Type u_2 s : β✝ → β✝ → Prop aca : ∀ (a : α✝), Acc (Lex r s) (inl a) b x✝ : β✝ h✝ : ∀ (y : β✝), s y x✝ → Acc s y IH : ∀ (y : β✝), s y x✝ → Acc (Lex r s) (inr y) a✝ : α✝ ⊢ Acc (Lex r s) (inl a✝) exact aca _ ** Qed
Sum.elim_const_const γ : Sort u_1 α : Type u_2 β : Type u_3 c : γ ⊢ Sum.elim (const α c) (const β c) = const (α ⊕ β) c ext x case h γ : Sort u_1 α : Type u_2 β : Type u_3 c : γ x : α ⊕ β ⊢ Sum.elim (const α c) (const β c) x = const (α ⊕ β) c x cases x <;> rfl ** Qed
Std.AssocList.isEmpty_eq α : Type u_1 β : Type u_2 l : AssocList α β ⊢ isEmpty l = List.isEmpty (toList l) cases l <;> simp [, isEmpty, List.isEmpty] * Qed
Std.AssocList.foldlM_eq m : Type u_1 → Type u_2 δ : Type u_1 α : Type u_3 β : Type u_4 inst✝ : Monad m f : δ → α → β → m δ init : δ l : AssocList α β ⊢ foldlM f init l = List.foldlM (fun d x => match x with \| (a, b) => f d a b) init (toList l) induction l generalizing init <;> simp [, foldlM] * Qed
Std.AssocList.toList_eq_toListTR ⊢ @toList = @toListTR funext α β as case h.h.h α : Type u_2 β : Type u_1 as : AssocList α β ⊢ toList as = toListTR as simp [toListTR] case h.h.h α : Type u_2 β : Type u_1 as : AssocList α β ⊢ toList as = (List.foldl (fun d x => Array.push d (x.fst, x.snd)) #[] (toList as)).data exact .symm <\| (Array.foldl_data_eq_map (toList as) _ id).trans (List.map_id _) ** Qed
Std.AssocList.forM_eq m : Type u_1 → Type u_2 α : Type u_3 β : Type u_4 inst✝ : Monad m f : α → β → m PUnit l : AssocList α β ⊢ forM f l = List.forM (toList l) fun x => match x with \| (a, b) => f a b induction l <;> simp [, forM] * Qed
Std.AssocList.findEntryP?_eq α : Type u_1 β : Type u_2 p : α → β → Bool l : AssocList α β ⊢ findEntryP? p l = List.find? (fun x => match x with \| (a, b) => p a b) (toList l) induction l <;> simp [findEntryP?, List.find?_cons] case cons α : Type u_1 β : Type u_2 p : α → β → Bool key✝ : α value✝ : β tail✝ : AssocList α β tail_ih✝ : findEntryP? p tail✝ = List.find? (fun x => match x with \| (a, b) => p a b) (toList tail✝) ⊢ (bif p key✝ value✝ then some (key✝, value✝) else findEntryP? p tail✝) = match p key✝ value✝ with \| true => some (key✝, value✝) \| false => List.find? (fun x => p x.fst x.snd) (toList tail✝) split <;> simp [] * Qed
Std.AssocList.find?_eq_findEntry? α : Type u_1 β : Type u_2 inst✝ : BEq α a : α l : AssocList α β ⊢ find? a l = Option.map (fun x => x.snd) (findEntry? a l) induction l <;> simp [find?, List.find?_cons] case cons α : Type u_1 β : Type u_2 inst✝ : BEq α a key✝ : α value✝ : β tail✝ : AssocList α β tail_ih✝ : find? a tail✝ = Option.map (fun x => x.snd) (findEntry? a tail✝) ⊢ (match key✝ == a with \| true => some value✝ \| false => find? a tail✝) = Option.map (fun x => x.snd) (match key✝ == a with \| true => some (key✝, value✝) \| false => List.find? (fun x => x.fst == a) (toList tail✝)) split <;> simp [] * Qed
Std.AssocList.any_eq α : Type u_1 β : Type u_2 p : α → β → Bool l : AssocList α β ⊢ any p l = List.any (toList l) fun x => match x with \| (a, b) => p a b induction l <;> simp [any, ] * Qed
Std.AssocList.all_eq α : Type u_1 β : Type u_2 p : α → β → Bool l : AssocList α β ⊢ all p l = List.all (toList l) fun x => match x with \| (a, b) => p a b induction l <;> simp [all, ] * Qed
Std.AssocList.contains_eq α : Type u_1 β : Type u_2 inst✝ : BEq α a : α l : AssocList α β ⊢ contains a l = List.any (toList l) fun x => x.fst == a induction l <;> simp [, contains] * Qed
Std.AssocList.replace_toList α : Type u_1 β : Type u_2 inst✝ : BEq α a : α b : β l : AssocList α β ⊢ toList (replace a b l) = List.replaceF (fun x => bif x.fst == a then some (a, b) else none) (toList l) induction l <;> simp [replace] case cons α : Type u_1 β : Type u_2 inst✝ : BEq α a : α b : β key✝ : α value✝ : β tail✝ : AssocList α β tail_ih✝ : toList (replace a b tail✝) = List.replaceF (fun x => bif x.fst == a then some (a, b) else none) (toList tail✝) ⊢ toList (match key✝ == a with \| true => cons a b tail✝ \| false => cons key✝ value✝ (replace a b tail✝)) = match bif key✝ == a then some (a, b) else none with \| none => (key✝, value✝) :: List.replaceF (fun x => bif x.fst == a then some (a, b) else none) (toList tail✝) \| some a => a :: toList tail✝ split <;> simp [] * Qed
List.toAssocList_toList α : Type u_1 β : Type u_2 l : List (α × β) ⊢ toList (List.toAssocList l) = l induction l <;> simp [] * Qed
Std.AssocList.toList_toAssocList α : Type u_1 β : Type u_2 l : AssocList α β ⊢ List.toAssocList (toList l) = l induction l <;> simp [] * Qed
Int.subNatNat_of_sub_eq_zero m n : Nat h : n - m = 0 ⊢ subNatNat m n = ↑(m - n) rw [subNatNat, h, ofNat_eq_coe] ** Qed
Int.subNatNat_of_sub_eq_succ m n k : Nat h : n - m = succ k ⊢ subNatNat m n = -[k+1] rw [subNatNat, h] ** Qed
Int.negSucc_inj m n : Nat H : m = n ⊢ -[m+1] = -[n+1] simp [H] ** Qed
Int.neg_inj a b : Int h : -a = -b ⊢ a = b rw [← Int.neg_neg a, ← Int.neg_neg b, h] ** Qed
Int.subNatNat_elim m n : Nat motive : Nat → Nat → Int → Prop hp : ∀ (i n : Nat), motive (n + i) n ↑i hn : ∀ (i m : Nat), motive m (m + i + 1) -[i+1] ⊢ motive m n (subNatNat m n) unfold subNatNat m n : Nat motive : Nat → Nat → Int → Prop hp : ∀ (i n : Nat), motive (n + i) n ↑i hn : ∀ (i m : Nat), motive m (m + i + 1) -[i+1] ⊢ motive m n (match n - m with \| 0 => ofNat (m - n) \| succ k => -[k+1]) match h : n - m with \| 0 => have ⟨k, h⟩ := Nat.le.dest (Nat.le_of_sub_eq_zero h) rw [h.symm, Nat.add_sub_cancel_left]; apply hp \| succ k => rw [Nat.sub_eq_iff_eq_add (Nat.le_of_lt (Nat.lt_of_sub_eq_succ h))] at h rw [h, Nat.add_comm]; apply hn m n : Nat motive : Nat → Nat → Int → Prop hp : ∀ (i n : Nat), motive (n + i) n ↑i hn : ∀ (i m : Nat), motive m (m + i + 1) -[i+1] h : n - m = 0 ⊢ motive m n (match 0 with \| 0 => ofNat (m - n) \| succ k => -[k+1]) have ⟨k, h⟩ := Nat.le.dest (Nat.le_of_sub_eq_zero h) m n : Nat motive : Nat → Nat → Int → Prop hp : ∀ (i n : Nat), motive (n + i) n ↑i hn : ∀ (i m : Nat), motive m (m + i + 1) -[i+1] h✝ : n - m = 0 k : Nat h : n + k = m ⊢ motive m n (match 0 with \| 0 => ofNat (m - n) \| succ k => -[k+1]) rw [h.symm, Nat.add_sub_cancel_left] m n : Nat motive : Nat → Nat → Int → Prop hp : ∀ (i n : Nat), motive (n + i) n ↑i hn : ∀ (i m : Nat), motive m (m + i + 1) -[i+1] h✝ : n - m = 0 k : Nat h : n + k = m ⊢ motive (n + k) n (match 0 with \| 0 => ofNat k \| succ k => -[k+1]) apply hp m n : Nat motive : Nat → Nat → Int → Prop hp : ∀ (i n : Nat), motive (n + i) n ↑i hn : ∀ (i m : Nat), motive m (m + i + 1) -[i+1] k : Nat h : n - m = succ k ⊢ motive m n (match succ k with \| 0 => ofNat (m - n) \| succ k => -[k+1]) rw [Nat.sub_eq_iff_eq_add (Nat.le_of_lt (Nat.lt_of_sub_eq_succ h))] at h m n : Nat motive : Nat → Nat → Int → Prop hp : ∀ (i n : Nat), motive (n + i) n ↑i hn : ∀ (i m : Nat), motive m (m + i + 1) -[i+1] k : Nat h : n = succ k + m ⊢ motive m n (match succ k with \| 0 => ofNat (m - n) \| succ k => -[k+1]) rw [h, Nat.add_comm] m n : Nat motive : Nat → Nat → Int → Prop hp : ∀ (i n : Nat), motive (n + i) n ↑i hn : ∀ (i m : Nat), motive m (m + i + 1) -[i+1] k : Nat h : n = succ k + m ⊢ motive m (m + succ k) (match succ k with \| 0 => ofNat (m - (m + succ k)) \| succ k => -[k+1]) apply hn ** Qed
Int.subNatNat_add_left m n : Nat ⊢ subNatNat (m + n) m = ↑n unfold subNatNat m n : Nat ⊢ (match m - (m + n) with \| 0 => ofNat (m + n - m) \| succ k => -[k+1]) = ↑n rw [Nat.sub_eq_zero_of_le (Nat.le_add_right ..), Nat.add_sub_cancel_left, ofNat_eq_coe] ** Qed
Int.subNatNat_add_right m n : Nat ⊢ subNatNat m (m + n + 1) = -[n+1] simp [subNatNat, Nat.add_assoc, Nat.add_sub_cancel_left] ** Qed
Int.natAbs_pos a : Int ⊢ 0 < natAbs a ↔ a ≠ 0 rw [Nat.pos_iff_ne_zero, Ne, natAbs_eq_zero] ** Qed
Int.natAbs_negOfNat n : Nat ⊢ natAbs (negOfNat n) = n cases n <;> rfl ** Qed
Int.natAbs_mul_natAbs_eq ** a b : Int c : Nat h : a * b = ↑c ⊢ natAbs a * natAbs b = c rw [← natAbs_mul, h, natAbs] Qed
Int.natAbs_mul_self' ** a : Int ⊢ ↑(natAbs a) * ↑(natAbs a) = a * a rw [← Int.ofNat_mul, natAbs_mul_self] Qed
Int.natAbs_eq_natAbs_iff a b : Int ⊢ natAbs a = natAbs b ↔ a = b ∨ a = -b constructor <;> intro h case mp a b : Int h : natAbs a = natAbs b ⊢ a = b ∨ a = -b cases Int.natAbs_eq a with \| inl h₁ \| inr h₁ => cases Int.natAbs_eq b with \| inl h₂ \| inr h₂ => rw [h₁, h₂]; simp [h] case mp.inr a b : Int h : natAbs a = natAbs b h₁ : a = -↑(natAbs a) ⊢ a = b ∨ a = -b cases Int.natAbs_eq b with \| inl h₂ \| inr h₂ => rw [h₁, h₂]; simp [h] case mp.inr.inr a b : Int h : natAbs a = natAbs b h₁ : a = -↑(natAbs a) h₂ : b = -↑(natAbs b) ⊢ a = b ∨ a = -b rw [h₁, h₂] case mp.inr.inr a b : Int h : natAbs a = natAbs b h₁ : a = -↑(natAbs a) h₂ : b = -↑(natAbs b) ⊢ -↑(natAbs a) = -↑(natAbs b) ∨ -↑(natAbs a) = - -↑(natAbs b) simp [h] case mpr a b : Int h : a = b ∨ a = -b ⊢ natAbs a = natAbs b cases h with (subst a; try rfl) \| inr h => rw [Int.natAbs_neg] case mpr.inl a b : Int h✝ : a = b ⊢ natAbs a = natAbs b subst a case mpr.inl b : Int ⊢ natAbs b = natAbs b try rfl case mpr.inl b : Int ⊢ natAbs b = natAbs b rfl case mpr.inr b : Int ⊢ natAbs (-b) = natAbs b rw [Int.natAbs_neg] ** Qed
Int.natAbs_eq_iff a : Int n : Nat ⊢ natAbs a = n ↔ a = ↑n ∨ a = -↑n rw [← Int.natAbs_eq_natAbs_iff, Int.natAbs_ofNat] ** Qed
Int.sign_neg z : Int ⊢ sign (-z) = -sign z match z with \| 0 \| succ _ \| -[_+1] => rfl z : Int a✝ : Nat ⊢ sign (- -[a✝+1]) = -sign -[a✝+1] rfl ** Qed
Int.add_comm n m : Nat ⊢ ofNat n + ofNat m = ofNat m + ofNat n simp [Nat.add_comm] a✝¹ a✝ : Nat ⊢ -[a✝¹+1] + -[a✝+1] = -[a✝+1] + -[a✝¹+1] simp [Nat.add_comm] ** Qed
Int.ofNat_add_negSucc_of_lt m n : Nat h : m < succ n ⊢ subNatNat m (succ n) = -[n - m+1] simp [succ_sub (le_of_lt_succ h), subNatNat] ** Qed
Int.subNatNat_sub n m : Nat h : n ≤ m k : Nat ⊢ subNatNat (m - n) k = subNatNat m (k + n) rwa [← subNatNat_add_add _ _ n, Nat.sub_add_cancel] ** Qed
Int.subNatNat_add m n k : Nat ⊢ subNatNat (m + n) k = ↑m + subNatNat n k cases n.lt_or_ge k with \| inl h' => simp [subNatNat_of_lt h', succ_pred_eq_of_pos (Nat.sub_pos_of_lt h')] conv => lhs; rw [← Nat.sub_add_cancel (Nat.le_of_lt h')] apply subNatNat_add_add \| inr h' => simp [subNatNat_of_le h', subNatNat_of_le (Nat.le_trans h' (le_add_left ..)), Nat.add_sub_assoc h'] case inl m n k : Nat h' : n < k ⊢ subNatNat (m + n) k = ↑m + subNatNat n k simp [subNatNat_of_lt h', succ_pred_eq_of_pos (Nat.sub_pos_of_lt h')] case inl m n k : Nat h' : n < k ⊢ subNatNat (m + n) k = subNatNat m (k - n) conv => lhs; rw [← Nat.sub_add_cancel (Nat.le_of_lt h')] case inl m n k : Nat h' : n < k ⊢ subNatNat (m + n) (k - n + n) = subNatNat m (k - n) apply subNatNat_add_add case inr m n k : Nat h' : n ≥ k ⊢ subNatNat (m + n) k = ↑m + subNatNat n k simp [subNatNat_of_le h', subNatNat_of_le (Nat.le_trans h' (le_add_left ..)), Nat.add_sub_assoc h'] ** Qed
Int.add_left_comm a b c : Int ⊢ a + (b + c) = b + (a + c) rw [← Int.add_assoc, Int.add_comm a, Int.add_assoc] ** Qed
Int.add_right_comm a b c : Int ⊢ a + b + c = a + c + b rw [Int.add_assoc, Int.add_comm b, ← Int.add_assoc] ** Qed
Int.subNatNat_self m : Nat ⊢ subNatNat (succ m) (succ m) = 0 rw [subNatNat_of_sub_eq_zero (Nat.sub_self ..), Nat.sub_self, ofNat_zero] ** Qed
Int.add_left_neg m : Nat ⊢ -↑(succ m) + ↑(succ m) = 0 simp m : Nat ⊢ - -[m+1] + -[m+1] = 0 simp ** Qed
Int.add_right_neg a : Int ⊢ a + -a = 0 rw [Int.add_comm, Int.add_left_neg] ** Qed
Int.neg_eq_of_add_eq_zero a b : Int h : a + b = 0 ⊢ -a = b rw [← Int.add_zero (-a), ← h, ← Int.add_assoc, Int.add_left_neg, Int.zero_add] ** Qed
Int.eq_neg_of_eq_neg a b : Int h : a = -b ⊢ b = -a rw [h, Int.neg_neg] ** Qed
Int.neg_eq_comm a b : Int ⊢ -a = b ↔ -b = a rw [eq_comm, Int.eq_neg_comm, eq_comm] ** Qed
Int.neg_add_cancel_left a b : Int ⊢ -a + (a + b) = b rw [← Int.add_assoc, Int.add_left_neg, Int.zero_add] ** Qed
Int.add_neg_cancel_left a b : Int ⊢ a + (-a + b) = b rw [← Int.add_assoc, Int.add_right_neg, Int.zero_add] ** Qed
Int.add_neg_cancel_right a b : Int ⊢ a + b + -b = a rw [Int.add_assoc, Int.add_right_neg, Int.add_zero] ** Qed
Int.neg_add_cancel_right a b : Int ⊢ a + -b + b = a rw [Int.add_assoc, Int.add_left_neg, Int.add_zero] ** Qed
Int.add_left_cancel a b c : Int h : a + b = a + c ⊢ b = c have h₁ : -a + (a + b) = -a + (a + c) := by rw [h] a b c : Int h : a + b = a + c h₁ : -a + (a + b) = -a + (a + c) ⊢ b = c simp [← Int.add_assoc, Int.add_left_neg, Int.zero_add] at h₁ a b c : Int h : a + b = a + c h₁ : b = c ⊢ b = c exact h₁ a b c : Int h : a + b = a + c ⊢ -a + (a + b) = -a + (a + c) rw [h] ** Qed
Int.neg_add a b : Int ⊢ -(a + b) = -a + -b apply Int.add_left_cancel (a := a + b) a b : Int ⊢ a + b + -(a + b) = a + b + (-a + -b) rw [Int.add_right_neg, Int.add_comm a, ← Int.add_assoc, Int.add_assoc b, Int.add_right_neg, Int.add_zero, Int.add_right_neg] ** Qed
Int.sub_self a : Int ⊢ a - a = 0 rw [Int.sub_eq_add_neg, Int.add_right_neg] ** Qed
Int.sub_zero a : Int ⊢ a - 0 = a simp [Int.sub_eq_add_neg] ** Qed
Int.zero_sub a : Int ⊢ 0 - a = -a simp [Int.sub_eq_add_neg] ** Qed
Int.sub_eq_zero_of_eq a b : Int h : a = b ⊢ a - b = 0 rw [h, Int.sub_self] ** Qed
Int.eq_of_sub_eq_zero a b : Int h : a - b = 0 ⊢ a = b have : 0 + b = b := by rw [Int.zero_add] a b : Int h : a - b = 0 this : 0 + b = b ⊢ a = b have : a - b + b = b := by rwa [h] a b : Int h : a - b = 0 this✝ : 0 + b = b this : a - b + b = b ⊢ a = b rwa [Int.sub_eq_add_neg, Int.neg_add_cancel_right] at this a b : Int h : a - b = 0 ⊢ 0 + b = b rw [Int.zero_add] a b : Int h : a - b = 0 this : 0 + b = b ⊢ a - b + b = b rwa [h] ** Qed
Int.sub_sub a b c : Int ⊢ a - b - c = a - (b + c) simp [Int.sub_eq_add_neg, Int.add_assoc] ** Qed
Int.neg_sub a b : Int ⊢ -(a - b) = b - a simp [Int.sub_eq_add_neg, Int.add_comm] ** Qed
Int.sub_sub_self a b : Int ⊢ a - (a - b) = b simp [Int.sub_eq_add_neg, ← Int.add_assoc] ** Qed
Int.sub_neg a b : Int ⊢ a - -b = a + b simp [Int.sub_eq_add_neg] ** Qed
Int.mul_comm ** a b : Int ⊢ a * b = b * a cases a <;> cases b <;> simp [Nat.mul_comm] Qed
Int.ofNat_mul_negOfNat ** m n : Nat ⊢ ↑m * negOfNat n = negOfNat (m * n) cases n <;> rfl Qed
Int.negSucc_mul_negOfNat ** m n : Nat ⊢ -[m+1] * negOfNat n = ofNat (succ m * n) cases n <;> rfl Qed
Int.mul_assoc ** a b c : Int ⊢ a * b * c = a * (b * c) cases a <;> cases b <;> cases c <;> simp [Nat.mul_assoc] Qed
Int.mul_left_comm ** a b c : Int ⊢ a * (b * c) = b * (a * c) rw [← Int.mul_assoc, ← Int.mul_assoc, Int.mul_comm a] Qed
Int.mul_right_comm ** a b c : Int ⊢ a * b * c = a * c * b rw [Int.mul_assoc, Int.mul_assoc, Int.mul_comm b] Qed
Int.mul_zero ** a : Int ⊢ a * 0 = 0 cases a <;> rfl Qed
Int.negOfNat_eq_subNatNat_zero n : Nat ⊢ negOfNat n = subNatNat 0 n cases n <;> rfl ** Qed
Int.ofNat_mul_subNatNat ** m n k : Nat ⊢ ↑m * subNatNat n k = subNatNat (m * n) (m * k) ** cases m with \| zero => simp [ofNat_zero, Int.zero_mul, Nat.zero_mul] \| succ m => cases n.lt_or_ge k with \| inl h => have h' : succ m * n < succ m * k := Nat.mul_lt_mul_of_pos_left h (Nat.succ_pos m) simp [subNatNat_of_lt h, subNatNat_of_lt h'] rw [succ_pred_eq_of_pos (Nat.sub_pos_of_lt h), ← neg_ofNat_succ, Nat.mul_sub_left_distrib, ← succ_pred_eq_of_pos (Nat.sub_pos_of_lt h')]; rfl \| inr h => have h' : succ m * k ≤ succ m * n := Nat.mul_le_mul_left _ h simp [subNatNat_of_le h, subNatNat_of_le h', Nat.mul_sub_left_distrib] ** case zero n k : Nat ⊢ ↑zero * subNatNat n k = subNatNat (zero * n) (zero * k) simp [ofNat_zero, Int.zero_mul, Nat.zero_mul] case succ n k m : Nat ⊢ ↑(succ m) * subNatNat n k = subNatNat (succ m * n) (succ m * k) ** cases n.lt_or_ge k with \| inl h => have h' : succ m * n < succ m * k := Nat.mul_lt_mul_of_pos_left h (Nat.succ_pos m) simp [subNatNat_of_lt h, subNatNat_of_lt h'] rw [succ_pred_eq_of_pos (Nat.sub_pos_of_lt h), ← neg_ofNat_succ, Nat.mul_sub_left_distrib, ← succ_pred_eq_of_pos (Nat.sub_pos_of_lt h')]; rfl \| inr h => have h' : succ m * k ≤ succ m * n := Nat.mul_le_mul_left _ h simp [subNatNat_of_le h, subNatNat_of_le h', Nat.mul_sub_left_distrib] ** case succ.inl n k m : Nat h : n < k ⊢ ↑(succ m) * subNatNat n k = subNatNat (succ m * n) (succ m * k) ** have h' : succ m * n < succ m * k := Nat.mul_lt_mul_of_pos_left h (Nat.succ_pos m) ** case succ.inl n k m : Nat h : n < k h' : succ m * n < succ m * k ⊢ ↑(succ m) * subNatNat n k = subNatNat (succ m * n) (succ m * k) simp [subNatNat_of_lt h, subNatNat_of_lt h'] case succ.inl n k m : Nat h : n < k h' : succ m * n < succ m * k ⊢ negOfNat (succ m * succ (pred (k - n))) = -[pred (succ m * k - succ m * n)+1] rw [succ_pred_eq_of_pos (Nat.sub_pos_of_lt h), ← neg_ofNat_succ, Nat.mul_sub_left_distrib, ← succ_pred_eq_of_pos (Nat.sub_pos_of_lt h')] case succ.inl n k m : Nat h : n < k h' : succ m * n < succ m * k ⊢ negOfNat (succ (pred (succ m * k - succ m * n))) = -↑(succ (pred (succ (pred (succ m * k - succ m * n))))) rfl case succ.inr n k m : Nat h : n ≥ k ⊢ ↑(succ m) * subNatNat n k = subNatNat (succ m * n) (succ m * k) ** have h' : succ m * k ≤ succ m * n := Nat.mul_le_mul_left _ h ** case succ.inr n k m : Nat h : n ≥ k h' : succ m * k ≤ succ m * n ⊢ ↑(succ m) * subNatNat n k = subNatNat (succ m * n) (succ m * k) simp [subNatNat_of_le h, subNatNat_of_le h', Nat.mul_sub_left_distrib] Qed
Int.negOfNat_add m n : Nat ⊢ negOfNat m + negOfNat n = negOfNat (m + n) cases m <;> cases n <;> simp [Nat.succ_add] <;> rfl ** Qed
Int.negSucc_mul_subNatNat ** m n k : Nat ⊢ -[m+1] * subNatNat n k = subNatNat (succ m * k) (succ m * n) ** cases n.lt_or_ge k with \| inl h => have h' : succ m * n < succ m * k := Nat.mul_lt_mul_of_pos_left h (Nat.succ_pos m) rw [subNatNat_of_lt h, subNatNat_of_le (Nat.le_of_lt h')] simp [succ_pred_eq_of_pos (Nat.sub_pos_of_lt h), Nat.mul_sub_left_distrib] \| inr h => cases Nat.lt_or_ge k n with \| inl h' => have h₁ : succ m * n > succ m * k := Nat.mul_lt_mul_of_pos_left h' (Nat.succ_pos m) rw [subNatNat_of_le h, subNatNat_of_lt h₁, negSucc_mul_ofNat, Nat.mul_sub_left_distrib, ← succ_pred_eq_of_pos (Nat.sub_pos_of_lt h₁)]; rfl \| inr h' => rw [Nat.le_antisymm h h', subNatNat_self, subNatNat_self, Int.mul_zero] ** case inl m n k : Nat h : n < k ⊢ -[m+1] * subNatNat n k = subNatNat (succ m * k) (succ m * n) ** have h' : succ m * n < succ m * k := Nat.mul_lt_mul_of_pos_left h (Nat.succ_pos m) ** case inl m n k : Nat h : n < k h' : succ m * n < succ m * k ⊢ -[m+1] * subNatNat n k = subNatNat (succ m * k) (succ m * n) rw [subNatNat_of_lt h, subNatNat_of_le (Nat.le_of_lt h')] case inl m n k : Nat h : n < k h' : succ m * n < succ m * k ⊢ -[m+1] * -[pred (k - n)+1] = ↑(succ m * k - succ m * n) simp [succ_pred_eq_of_pos (Nat.sub_pos_of_lt h), Nat.mul_sub_left_distrib] case inr m n k : Nat h : n ≥ k ⊢ -[m+1] * subNatNat n k = subNatNat (succ m * k) (succ m * n) ** cases Nat.lt_or_ge k n with \| inl h' => have h₁ : succ m * n > succ m * k := Nat.mul_lt_mul_of_pos_left h' (Nat.succ_pos m) rw [subNatNat_of_le h, subNatNat_of_lt h₁, negSucc_mul_ofNat, Nat.mul_sub_left_distrib, ← succ_pred_eq_of_pos (Nat.sub_pos_of_lt h₁)]; rfl \| inr h' => rw [Nat.le_antisymm h h', subNatNat_self, subNatNat_self, Int.mul_zero] ** case inr.inl m n k : Nat h : n ≥ k h' : k < n ⊢ -[m+1] * subNatNat n k = subNatNat (succ m * k) (succ m * n) ** have h₁ : succ m * n > succ m * k := Nat.mul_lt_mul_of_pos_left h' (Nat.succ_pos m) ** case inr.inl m n k : Nat h : n ≥ k h' : k < n h₁ : succ m * n > succ m * k ⊢ -[m+1] * subNatNat n k = subNatNat (succ m * k) (succ m * n) rw [subNatNat_of_le h, subNatNat_of_lt h₁, negSucc_mul_ofNat, Nat.mul_sub_left_distrib, ← succ_pred_eq_of_pos (Nat.sub_pos_of_lt h₁)] case inr.inl m n k : Nat h : n ≥ k h' : k < n h₁ : succ m * n > succ m * k ⊢ -↑(succ (pred (succ m * n - succ m * k))) = -[pred (succ (pred (succ m * n - succ m * k)))+1] rfl case inr.inr m n k : Nat h : n ≥ k h' : k ≥ n ⊢ -[m+1] * subNatNat n k = subNatNat (succ m * k) (succ m * n) rw [Nat.le_antisymm h h', subNatNat_self, subNatNat_self, Int.mul_zero] Qed
Int.mul_add ** m n k : Nat ⊢ ↑m * (↑n + ↑k) = ↑m * ↑n + ↑m * ↑k simp [Nat.left_distrib] m n k : Nat ⊢ ↑m * (↑n + -[k+1]) = ↑m * ↑n + ↑m * -[k+1] simp [negOfNat_eq_subNatNat_zero] m n k : Nat ⊢ subNatNat (m * n) (m * succ k) = ↑(m * n) + subNatNat 0 (m * succ k) rw [← subNatNat_add] m n k : Nat ⊢ subNatNat (m * n) (m * succ k) = subNatNat (m * n + 0) (m * succ k) rfl m n k : Nat ⊢ ↑m * (-[n+1] + ↑k) = ↑m * -[n+1] + ↑m * ↑k simp [negOfNat_eq_subNatNat_zero] m n k : Nat ⊢ subNatNat (m * k) (m * succ n) = subNatNat 0 (m * succ n) + ↑(m * k) rw [Int.add_comm, ← subNatNat_add] m n k : Nat ⊢ subNatNat (m * k) (m * succ n) = subNatNat (m * k + 0) (m * succ n) rfl m n k : Nat ⊢ ↑m * (-[n+1] + -[k+1]) = ↑m * -[n+1] + ↑m * -[k+1] simp m n k : Nat ⊢ negOfNat (m * succ (succ (n + k))) = negOfNat (m * succ n + m * succ k) rw [← Nat.left_distrib, succ_add] m n k : Nat ⊢ negOfNat (m * succ (succ (n + k))) = negOfNat (m * succ (n + succ k)) rfl m n k : Nat ⊢ -[m+1] * (↑n + ↑k) = -[m+1] * ↑n + -[m+1] * ↑k simp [Nat.mul_comm] m n k : Nat ⊢ negOfNat ((n + k) * succ m) = negOfNat (n * succ m + k * succ m) rw [← Nat.right_distrib, Nat.mul_comm] m n k : Nat ⊢ -[m+1] * (↑n + -[k+1]) = -[m+1] * ↑n + -[m+1] * -[k+1] simp [negOfNat_eq_subNatNat_zero] m n k : Nat ⊢ subNatNat (succ m * succ k) (succ m * n) = subNatNat 0 (succ m * n) + ↑(succ m * succ k) rw [Int.add_comm, ← subNatNat_add] m n k : Nat ⊢ subNatNat (succ m * succ k) (succ m * n) = subNatNat (succ m * succ k + 0) (succ m * n) rfl m n k : Nat ⊢ -[m+1] * (-[n+1] + ↑k) = -[m+1] * -[n+1] + -[m+1] * ↑k simp [negOfNat_eq_subNatNat_zero] m n k : Nat ⊢ subNatNat (succ m * succ n) (succ m * k) = ↑(succ m * succ n) + subNatNat 0 (succ m * k) rw [← subNatNat_add] m n k : Nat ⊢ subNatNat (succ m * succ n) (succ m * k) = subNatNat (succ m * succ n + 0) (succ m * k) rfl m n k : Nat ⊢ -[m+1] * (-[n+1] + -[k+1]) = -[m+1] * -[n+1] + -[m+1] * -[k+1] simp m n k : Nat ⊢ ↑(succ m * succ (succ (n + k))) = ↑(succ m * succ n + succ m * succ k) rw [← Nat.left_distrib, succ_add] m n k : Nat ⊢ ↑(succ m * succ (succ (n + k))) = ↑(succ m * succ (n + succ k)) rfl Qed
Int.add_mul ** a b c : Int ⊢ (a + b) * c = a * c + b * c simp [Int.mul_comm, Int.mul_add] Qed
Int.neg_mul_eq_neg_mul ** a b : Int ⊢ a * b + -a * b = 0 rw [← Int.add_mul, Int.add_right_neg, Int.zero_mul] Qed
Int.neg_mul_eq_mul_neg ** a b : Int ⊢ a * b + a * -b = 0 rw [← Int.mul_add, Int.add_right_neg, Int.mul_zero] Qed
Int.neg_mul_neg ** a b : Int ⊢ -a * -b = a * b simp Qed
Int.neg_mul_comm ** a b : Int ⊢ -a * b = a * -b simp Qed
Int.mul_sub ** a b c : Int ⊢ a * (b - c) = a * b - a * c simp [Int.sub_eq_add_neg, Int.mul_add] Qed
Int.sub_mul ** a b c : Int ⊢ (a - b) * c = a * c - b * c simp [Int.sub_eq_add_neg, Int.add_mul] Qed
Int.add_sub_assoc a b c : Int ⊢ a + b - c = a + (b - c) rw [Int.sub_eq_add_neg, Int.add_assoc, ← Int.sub_eq_add_neg] ** Qed
Int.ofNat_sub m n : Nat h : m ≤ n ⊢ ↑(n - m) = ↑n - ↑m match m with \| 0 => rfl \| succ m => show ofNat (n - succ m) = subNatNat n (succ m) rw [subNatNat, Nat.sub_eq_zero_of_le h] m n : Nat h : 0 ≤ n ⊢ ↑(n - 0) = ↑n - ↑0 rfl m✝ n m : Nat h : succ m ≤ n ⊢ ↑(n - succ m) = ↑n - ↑(succ m) show ofNat (n - succ m) = subNatNat n (succ m) m✝ n m : Nat h : succ m ≤ n ⊢ ofNat (n - succ m) = subNatNat n (succ m) rw [subNatNat, Nat.sub_eq_zero_of_le h] ** Qed
Int.negSucc_coe' n : Nat ⊢ -[n+1] = -↑n - 1 rw [Int.sub_eq_add_neg, ← Int.neg_add] n : Nat ⊢ -[n+1] = -(↑n + 1) rfl ** Qed
Int.subNatNat_eq_coe m n : Nat ⊢ subNatNat m n = ↑m - ↑n apply subNatNat_elim m n fun m n i => i = m - n case hp m n : Nat ⊢ ∀ (i n : Nat), ↑i = ↑(n + i) - ↑n intros i n case hp m n✝ i n : Nat ⊢ ↑i = ↑(n + i) - ↑n rw [Int.ofNat_add, Int.sub_eq_add_neg, Int.add_assoc, Int.add_left_comm, Int.add_right_neg, Int.add_zero] case hn m n : Nat ⊢ ∀ (i m : Nat), -[i+1] = ↑m - ↑(m + i + 1) intros i n case hn m n✝ i n : Nat ⊢ -[i+1] = ↑n - ↑(n + i + 1) simp only [negSucc_coe, ofNat_add, Int.sub_eq_add_neg, Int.neg_add, ← Int.add_assoc] case hn m n✝ i n : Nat ⊢ -↑i + -↑1 = ↑n + -↑n + -↑i + -↑1 rw [← @Int.sub_eq_add_neg n, ← ofNat_sub, Nat.sub_self, ofNat_zero, Int.zero_add] case hn m n✝ i n : Nat ⊢ n ≤ n apply Nat.le_refl ** Qed
Int.toNat_sub m n : Nat ⊢ toNat (↑m - ↑n) = m - n rw [← Int.subNatNat_eq_coe] m n : Nat ⊢ toNat (subNatNat m n) = m - n refine subNatNat_elim m n (fun m n i => toNat i = m - n) (fun i n => ?_) (fun i n => ?_) case refine_1 m n✝ i n : Nat ⊢ (fun m n i => toNat i = m - n) (n + i) n ↑i exact (Nat.add_sub_cancel_left ..).symm case refine_2 m n✝ i n : Nat ⊢ (fun m n i => toNat i = m - n) n (n + i + 1) -[i+1] dsimp case refine_2 m n✝ i n : Nat ⊢ toNat -[i+1] = n - (n + i + 1) rw [Nat.add_assoc, Nat.sub_eq_zero_of_le (Nat.le_add_right ..)] case refine_2 m n✝ i n : Nat ⊢ toNat -[i+1] = 0 rfl ** Qed
Int.one_mul ** n : Nat ⊢ ofNat (1 * n) = ofNat n rw [Nat.one_mul] n : Nat ⊢ -[1 * n+1] = -[n+1] rw [Nat.one_mul] Qed
Int.mul_one ** a : Int ⊢ a * 1 = a rw [Int.mul_comm, Int.one_mul] Qed
Int.mul_neg_one ** a : Int ⊢ a * -1 = -a rw [Int.mul_neg, Int.mul_one] Qed
Int.neg_eq_neg_one_mul ** n : Nat ⊢ -↑(succ n) = -[1 * n+1] rw [Nat.one_mul] n : Nat ⊢ -↑(succ n) = -[n+1] rfl n : Nat ⊢ - -[n+1] = ofNat (succ 0 * succ n) rw [Nat.one_mul] n : Nat ⊢ - -[n+1] = ofNat (succ n) rfl Qed
Int.sign_mul ** b : Int ⊢ sign (0 * b) = sign 0 * sign b simp [Int.mul_zero, Int.zero_mul] Qed
Int.le.intro a b : Int n : Nat h : a + ↑n = b ⊢ b - a = ↑n rw [← h, Int.add_comm] a b : Int n : Nat h : a + ↑n = b ⊢ ↑n + a - a = ↑n simp [Int.sub_eq_add_neg, Int.add_assoc] ** Qed

Subsets and Splits

No community queries yet

The top public SQL queries from the community will appear here once available.

formal stringlengths 41 427k	informal stringclasses 1 value
Sum.elim_map α : Type u_1 β : Type u_2 ε : Sort u_3 γ : Type u_4 δ : Type u_5 f₁ : α → β f₂ : β → ε g₁ : γ → δ g₂ : δ → ε x : α ⊕ γ ⊢ Sum.elim f₂ g₂ (Sum.map f₁ g₁ x) = Sum.elim (f₂ ∘ f₁) (g₂ ∘ g₁) x cases x <;> rfl ** Qed
Sum.isLeft_map α : Type u_1 β : Type u_2 γ : Type u_3 δ : Type u_4 f : α → β g : γ → δ x : α ⊕ γ ⊢ isLeft (Sum.map f g x) = isLeft x cases x <;> rfl ** Qed
Sum.isRight_map α : Type u_1 β : Type u_2 γ : Type u_3 δ : Type u_4 f : α → β g : γ → δ x : α ⊕ γ ⊢ isRight (Sum.map f g x) = isRight x cases x <;> rfl ** Qed
Sum.getLeft?_map α : Type u_1 β : Type u_2 γ : Type u_3 δ : Type u_4 f : α → β g : γ → δ x : α ⊕ γ ⊢ getLeft? (Sum.map f g x) = Option.map f (getLeft? x) cases x <;> rfl ** Qed
Sum.getRight?_map α : Type u_1 β : Type u_2 γ : Type u_3 δ : Type u_4 f : α → β g : γ → δ x : α ⊕ γ ⊢ getRight? (Sum.map f g x) = Option.map g (getRight? x) cases x <;> rfl ** Qed
Sum.swap_swap α : Type u_1 β : Type u_2 x : α ⊕ β ⊢ swap (swap x) = x cases x <;> rfl ** Qed
Sum.isLeft_swap α : Type u_1 β : Type u_2 x : α ⊕ β ⊢ isLeft (swap x) = isRight x cases x <;> rfl ** Qed
Sum.isRight_swap α : Type u_1 β : Type u_2 x : α ⊕ β ⊢ isRight (swap x) = isLeft x cases x <;> rfl ** Qed
Sum.getLeft?_swap α : Type u_1 β : Type u_2 x : α ⊕ β ⊢ getLeft? (swap x) = getRight? x cases x <;> rfl ** Qed
Sum.getRight?_swap α : Type u_1 β : Type u_2 x : α ⊕ β ⊢ getRight? (swap x) = getLeft? x cases x <;> rfl ** Qed
Sum.LiftRel.mono α✝¹ : Type u_1 α✝ : Type u_2 r₁ r₂ : α✝¹ → α✝ → Prop β✝¹ : Type u_3 β✝ : Type u_4 s₁ s₂ : β✝¹ → β✝ → Prop x : α✝¹ ⊕ β✝¹ y : α✝ ⊕ β✝ hr : ∀ (a : α✝¹) (b : α✝), r₁ a b → r₂ a b hs : ∀ (a : β✝¹) (b : β✝), s₁ a b → s₂ a b h : LiftRel r₁ s₁ x y ⊢ LiftRel r₂ s₂ x y cases h case inl α✝¹ : Type u_1 α✝ : Type u_2 r₁ r₂ : α✝¹ → α✝ → Prop β✝¹ : Type u_3 β✝ : Type u_4 s₁ s₂ : β✝¹ → β✝ → Prop hr : ∀ (a : α✝¹) (b : α✝), r₁ a b → r₂ a b hs : ∀ (a : β✝¹) (b : β✝), s₁ a b → s₂ a b a✝¹ : α✝¹ c✝ : α✝ a✝ : r₁ a✝¹ c✝ ⊢ LiftRel r₂ s₂ (inl a✝¹) (inl c✝) exact LiftRel.inl (hr _ _ ‹_›) case inr α✝¹ : Type u_1 α✝ : Type u_2 r₁ r₂ : α✝¹ → α✝ → Prop β✝¹ : Type u_3 β✝ : Type u_4 s₁ s₂ : β✝¹ → β✝ → Prop hr : ∀ (a : α✝¹) (b : α✝), r₁ a b → r₂ a b hs : ∀ (a : β✝¹) (b : β✝), s₁ a b → s₂ a b b✝ : β✝¹ d✝ : β✝ a✝ : s₁ b✝ d✝ ⊢ LiftRel r₂ s₂ (inr b✝) (inr d✝) exact LiftRel.inr (hs _ _ ‹_›) ** Qed
Sum.LiftRel.swap α✝¹ : Type u_1 α✝ : Type u_2 r : α✝¹ → α✝ → Prop β✝¹ : Type u_3 β✝ : Type u_4 s : β✝¹ → β✝ → Prop x : α✝¹ ⊕ β✝¹ y : α✝ ⊕ β✝ h : LiftRel r s x y ⊢ LiftRel s r (swap x) (swap y) cases h case inl α✝¹ : Type u_1 α✝ : Type u_2 r : α✝¹ → α✝ → Prop β✝¹ : Type u_3 β✝ : Type u_4 s : β✝¹ → β✝ → Prop a✝¹ : α✝¹ c✝ : α✝ a✝ : r a✝¹ c✝ ⊢ LiftRel s r (swap (inl a✝¹)) (swap (inl c✝)) exact LiftRel.inr ‹_› case inr α✝¹ : Type u_1 α✝ : Type u_2 r : α✝¹ → α✝ → Prop β✝¹ : Type u_3 β✝ : Type u_4 s : β✝¹ → β✝ → Prop b✝ : β✝¹ d✝ : β✝ a✝ : s b✝ d✝ ⊢ LiftRel s r (swap (inr b✝)) (swap (inr d✝)) exact LiftRel.inl ‹_› ** Qed
Sum.LiftRel.lex α : Type u_1 β : Type u_2 r : α → α → Prop s : β → β → Prop a b : α ⊕ β h : LiftRel r s a b ⊢ Lex r s a b cases h case inl α : Type u_1 β : Type u_2 r : α → α → Prop s : β → β → Prop a✝¹ c✝ : α a✝ : r a✝¹ c✝ ⊢ Lex r s (inl a✝¹) (inl c✝) exact Lex.inl ‹_› case inr α : Type u_1 β : Type u_2 r : α → α → Prop s : β → β → Prop b✝ d✝ : β a✝ : s b✝ d✝ ⊢ Lex r s (inr b✝) (inr d✝) exact Lex.inr ‹_› ** Qed
Sum.Lex.mono α✝ : Type u_1 r₁ r₂ : α✝ → α✝ → Prop β✝ : Type u_2 s₁ s₂ : β✝ → β✝ → Prop x y : α✝ ⊕ β✝ hr : ∀ (a b : α✝), r₁ a b → r₂ a b hs : ∀ (a b : β✝), s₁ a b → s₂ a b h : Lex r₁ s₁ x y ⊢ Lex r₂ s₂ x y cases h case inl α✝ : Type u_1 r₁ r₂ : α✝ → α✝ → Prop β✝ : Type u_2 s₁ s₂ : β✝ → β✝ → Prop hr : ∀ (a b : α✝), r₁ a b → r₂ a b hs : ∀ (a b : β✝), s₁ a b → s₂ a b a₁✝ a₂✝ : α✝ h✝ : r₁ a₁✝ a₂✝ ⊢ Lex r₂ s₂ (inl a₁✝) (inl a₂✝) exact Lex.inl (hr _ _ ‹_›) case inr α✝ : Type u_1 r₁ r₂ : α✝ → α✝ → Prop β✝ : Type u_2 s₁ s₂ : β✝ → β✝ → Prop hr : ∀ (a b : α✝), r₁ a b → r₂ a b hs : ∀ (a b : β✝), s₁ a b → s₂ a b b₁✝ b₂✝ : β✝ h✝ : s₁ b₁✝ b₂✝ ⊢ Lex r₂ s₂ (inr b₁✝) (inr b₂✝) exact Lex.inr (hs _ _ ‹_›) case sep α✝ : Type u_1 r₁ r₂ : α✝ → α✝ → Prop β✝ : Type u_2 s₁ s₂ : β✝ → β✝ → Prop hr : ∀ (a b : α✝), r₁ a b → r₂ a b hs : ∀ (a b : β✝), s₁ a b → s₂ a b a✝ : α✝ b✝ : β✝ ⊢ Lex r₂ s₂ (inl a✝) (inr b✝) exact Lex.sep _ _ ** Qed
Sum.lex_acc_inl α✝ : Type u_1 r : α✝ → α✝ → Prop a : α✝ β✝ : Type u_2 s : β✝ → β✝ → Prop aca : Acc r a ⊢ Acc (Lex r s) (inl a) induction aca with \| intro _ _ IH => constructor intro y h cases h with \| inl h' => exact IH _ h' case intro α✝ : Type u_1 r : α✝ → α✝ → Prop a : α✝ β✝ : Type u_2 s : β✝ → β✝ → Prop x✝ : α✝ h✝ : ∀ (y : α✝), r y x✝ → Acc r y IH : ∀ (y : α✝), r y x✝ → Acc (Lex r s) (inl y) ⊢ Acc (Lex r s) (inl x✝) constructor case intro.h α✝ : Type u_1 r : α✝ → α✝ → Prop a : α✝ β✝ : Type u_2 s : β✝ → β✝ → Prop x✝ : α✝ h✝ : ∀ (y : α✝), r y x✝ → Acc r y IH : ∀ (y : α✝), r y x✝ → Acc (Lex r s) (inl y) ⊢ ∀ (y : α✝ ⊕ β✝), Lex r s y (inl x✝) → Acc (Lex r s) y intro y h case intro.h α✝ : Type u_1 r : α✝ → α✝ → Prop a : α✝ β✝ : Type u_2 s : β✝ → β✝ → Prop x✝ : α✝ h✝ : ∀ (y : α✝), r y x✝ → Acc r y IH : ∀ (y : α✝), r y x✝ → Acc (Lex r s) (inl y) y : α✝ ⊕ β✝ h : Lex r s y (inl x✝) ⊢ Acc (Lex r s) y cases h with \| inl h' => exact IH _ h' case intro.h.inl α✝ : Type u_1 r : α✝ → α✝ → Prop a : α✝ β✝ : Type u_2 s : β✝ → β✝ → Prop x✝ : α✝ h✝ : ∀ (y : α✝), r y x✝ → Acc r y IH : ∀ (y : α✝), r y x✝ → Acc (Lex r s) (inl y) a₁✝ : α✝ h' : r a₁✝ x✝ ⊢ Acc (Lex r s) (inl a₁✝) exact IH _ h' ** Qed
Sum.lex_acc_inr α✝ : Type u_1 r : α✝ → α✝ → Prop β✝ : Type u_2 s : β✝ → β✝ → Prop aca : ∀ (a : α✝), Acc (Lex r s) (inl a) b : β✝ acb : Acc s b ⊢ Acc (Lex r s) (inr b) induction acb with \| intro _ _ IH => constructor intro y h cases h with \| inr h' => exact IH _ h' \| sep => exact aca _ case intro α✝ : Type u_1 r : α✝ → α✝ → Prop β✝ : Type u_2 s : β✝ → β✝ → Prop aca : ∀ (a : α✝), Acc (Lex r s) (inl a) b x✝ : β✝ h✝ : ∀ (y : β✝), s y x✝ → Acc s y IH : ∀ (y : β✝), s y x✝ → Acc (Lex r s) (inr y) ⊢ Acc (Lex r s) (inr x✝) constructor case intro.h α✝ : Type u_1 r : α✝ → α✝ → Prop β✝ : Type u_2 s : β✝ → β✝ → Prop aca : ∀ (a : α✝), Acc (Lex r s) (inl a) b x✝ : β✝ h✝ : ∀ (y : β✝), s y x✝ → Acc s y IH : ∀ (y : β✝), s y x✝ → Acc (Lex r s) (inr y) ⊢ ∀ (y : α✝ ⊕ β✝), Lex r s y (inr x✝) → Acc (Lex r s) y intro y h case intro.h α✝ : Type u_1 r : α✝ → α✝ → Prop β✝ : Type u_2 s : β✝ → β✝ → Prop aca : ∀ (a : α✝), Acc (Lex r s) (inl a) b x✝ : β✝ h✝ : ∀ (y : β✝), s y x✝ → Acc s y IH : ∀ (y : β✝), s y x✝ → Acc (Lex r s) (inr y) y : α✝ ⊕ β✝ h : Lex r s y (inr x✝) ⊢ Acc (Lex r s) y cases h with \| inr h' => exact IH _ h' \| sep => exact aca _ case intro.h.inr α✝ : Type u_1 r : α✝ → α✝ → Prop β✝ : Type u_2 s : β✝ → β✝ → Prop aca : ∀ (a : α✝), Acc (Lex r s) (inl a) b x✝ : β✝ h✝ : ∀ (y : β✝), s y x✝ → Acc s y IH : ∀ (y : β✝), s y x✝ → Acc (Lex r s) (inr y) b₁✝ : β✝ h' : s b₁✝ x✝ ⊢ Acc (Lex r s) (inr b₁✝) exact IH _ h' case intro.h.sep α✝ : Type u_1 r : α✝ → α✝ → Prop β✝ : Type u_2 s : β✝ → β✝ → Prop aca : ∀ (a : α✝), Acc (Lex r s) (inl a) b x✝ : β✝ h✝ : ∀ (y : β✝), s y x✝ → Acc s y IH : ∀ (y : β✝), s y x✝ → Acc (Lex r s) (inr y) a✝ : α✝ ⊢ Acc (Lex r s) (inl a✝) exact aca _ ** Qed
Sum.elim_const_const γ : Sort u_1 α : Type u_2 β : Type u_3 c : γ ⊢ Sum.elim (const α c) (const β c) = const (α ⊕ β) c ext x case h γ : Sort u_1 α : Type u_2 β : Type u_3 c : γ x : α ⊕ β ⊢ Sum.elim (const α c) (const β c) x = const (α ⊕ β) c x cases x <;> rfl ** Qed
Std.AssocList.isEmpty_eq α : Type u_1 β : Type u_2 l : AssocList α β ⊢ isEmpty l = List.isEmpty (toList l) cases l <;> simp [, isEmpty, List.isEmpty] * Qed
Std.AssocList.foldlM_eq m : Type u_1 → Type u_2 δ : Type u_1 α : Type u_3 β : Type u_4 inst✝ : Monad m f : δ → α → β → m δ init : δ l : AssocList α β ⊢ foldlM f init l = List.foldlM (fun d x => match x with \| (a, b) => f d a b) init (toList l) induction l generalizing init <;> simp [, foldlM] * Qed
Std.AssocList.toList_eq_toListTR ⊢ @toList = @toListTR funext α β as case h.h.h α : Type u_2 β : Type u_1 as : AssocList α β ⊢ toList as = toListTR as simp [toListTR] case h.h.h α : Type u_2 β : Type u_1 as : AssocList α β ⊢ toList as = (List.foldl (fun d x => Array.push d (x.fst, x.snd)) #[] (toList as)).data exact .symm <\| (Array.foldl_data_eq_map (toList as) _ id).trans (List.map_id _) ** Qed
Std.AssocList.forM_eq m : Type u_1 → Type u_2 α : Type u_3 β : Type u_4 inst✝ : Monad m f : α → β → m PUnit l : AssocList α β ⊢ forM f l = List.forM (toList l) fun x => match x with \| (a, b) => f a b induction l <;> simp [, forM] * Qed
Std.AssocList.findEntryP?_eq α : Type u_1 β : Type u_2 p : α → β → Bool l : AssocList α β ⊢ findEntryP? p l = List.find? (fun x => match x with \| (a, b) => p a b) (toList l) induction l <;> simp [findEntryP?, List.find?_cons] case cons α : Type u_1 β : Type u_2 p : α → β → Bool key✝ : α value✝ : β tail✝ : AssocList α β tail_ih✝ : findEntryP? p tail✝ = List.find? (fun x => match x with \| (a, b) => p a b) (toList tail✝) ⊢ (bif p key✝ value✝ then some (key✝, value✝) else findEntryP? p tail✝) = match p key✝ value✝ with \| true => some (key✝, value✝) \| false => List.find? (fun x => p x.fst x.snd) (toList tail✝) split <;> simp [] * Qed
Std.AssocList.find?_eq_findEntry? α : Type u_1 β : Type u_2 inst✝ : BEq α a : α l : AssocList α β ⊢ find? a l = Option.map (fun x => x.snd) (findEntry? a l) induction l <;> simp [find?, List.find?_cons] case cons α : Type u_1 β : Type u_2 inst✝ : BEq α a key✝ : α value✝ : β tail✝ : AssocList α β tail_ih✝ : find? a tail✝ = Option.map (fun x => x.snd) (findEntry? a tail✝) ⊢ (match key✝ == a with \| true => some value✝ \| false => find? a tail✝) = Option.map (fun x => x.snd) (match key✝ == a with \| true => some (key✝, value✝) \| false => List.find? (fun x => x.fst == a) (toList tail✝)) split <;> simp [] * Qed
Std.AssocList.any_eq α : Type u_1 β : Type u_2 p : α → β → Bool l : AssocList α β ⊢ any p l = List.any (toList l) fun x => match x with \| (a, b) => p a b induction l <;> simp [any, ] * Qed
Std.AssocList.all_eq α : Type u_1 β : Type u_2 p : α → β → Bool l : AssocList α β ⊢ all p l = List.all (toList l) fun x => match x with \| (a, b) => p a b induction l <;> simp [all, ] * Qed
Std.AssocList.contains_eq α : Type u_1 β : Type u_2 inst✝ : BEq α a : α l : AssocList α β ⊢ contains a l = List.any (toList l) fun x => x.fst == a induction l <;> simp [, contains] * Qed
Std.AssocList.replace_toList α : Type u_1 β : Type u_2 inst✝ : BEq α a : α b : β l : AssocList α β ⊢ toList (replace a b l) = List.replaceF (fun x => bif x.fst == a then some (a, b) else none) (toList l) induction l <;> simp [replace] case cons α : Type u_1 β : Type u_2 inst✝ : BEq α a : α b : β key✝ : α value✝ : β tail✝ : AssocList α β tail_ih✝ : toList (replace a b tail✝) = List.replaceF (fun x => bif x.fst == a then some (a, b) else none) (toList tail✝) ⊢ toList (match key✝ == a with \| true => cons a b tail✝ \| false => cons key✝ value✝ (replace a b tail✝)) = match bif key✝ == a then some (a, b) else none with \| none => (key✝, value✝) :: List.replaceF (fun x => bif x.fst == a then some (a, b) else none) (toList tail✝) \| some a => a :: toList tail✝ split <;> simp [] * Qed
List.toAssocList_toList α : Type u_1 β : Type u_2 l : List (α × β) ⊢ toList (List.toAssocList l) = l induction l <;> simp [] * Qed
Std.AssocList.toList_toAssocList α : Type u_1 β : Type u_2 l : AssocList α β ⊢ List.toAssocList (toList l) = l induction l <;> simp [] * Qed
Int.subNatNat_of_sub_eq_zero m n : Nat h : n - m = 0 ⊢ subNatNat m n = ↑(m - n) rw [subNatNat, h, ofNat_eq_coe] ** Qed
Int.subNatNat_of_sub_eq_succ m n k : Nat h : n - m = succ k ⊢ subNatNat m n = -[k+1] rw [subNatNat, h] ** Qed
Int.negSucc_inj m n : Nat H : m = n ⊢ -[m+1] = -[n+1] simp [H] ** Qed
Int.neg_inj a b : Int h : -a = -b ⊢ a = b rw [← Int.neg_neg a, ← Int.neg_neg b, h] ** Qed
Int.subNatNat_elim m n : Nat motive : Nat → Nat → Int → Prop hp : ∀ (i n : Nat), motive (n + i) n ↑i hn : ∀ (i m : Nat), motive m (m + i + 1) -[i+1] ⊢ motive m n (subNatNat m n) unfold subNatNat m n : Nat motive : Nat → Nat → Int → Prop hp : ∀ (i n : Nat), motive (n + i) n ↑i hn : ∀ (i m : Nat), motive m (m + i + 1) -[i+1] ⊢ motive m n (match n - m with \| 0 => ofNat (m - n) \| succ k => -[k+1]) match h : n - m with \| 0 => have ⟨k, h⟩ := Nat.le.dest (Nat.le_of_sub_eq_zero h) rw [h.symm, Nat.add_sub_cancel_left]; apply hp \| succ k => rw [Nat.sub_eq_iff_eq_add (Nat.le_of_lt (Nat.lt_of_sub_eq_succ h))] at h rw [h, Nat.add_comm]; apply hn m n : Nat motive : Nat → Nat → Int → Prop hp : ∀ (i n : Nat), motive (n + i) n ↑i hn : ∀ (i m : Nat), motive m (m + i + 1) -[i+1] h : n - m = 0 ⊢ motive m n (match 0 with \| 0 => ofNat (m - n) \| succ k => -[k+1]) have ⟨k, h⟩ := Nat.le.dest (Nat.le_of_sub_eq_zero h) m n : Nat motive : Nat → Nat → Int → Prop hp : ∀ (i n : Nat), motive (n + i) n ↑i hn : ∀ (i m : Nat), motive m (m + i + 1) -[i+1] h✝ : n - m = 0 k : Nat h : n + k = m ⊢ motive m n (match 0 with \| 0 => ofNat (m - n) \| succ k => -[k+1]) rw [h.symm, Nat.add_sub_cancel_left] m n : Nat motive : Nat → Nat → Int → Prop hp : ∀ (i n : Nat), motive (n + i) n ↑i hn : ∀ (i m : Nat), motive m (m + i + 1) -[i+1] h✝ : n - m = 0 k : Nat h : n + k = m ⊢ motive (n + k) n (match 0 with \| 0 => ofNat k \| succ k => -[k+1]) apply hp m n : Nat motive : Nat → Nat → Int → Prop hp : ∀ (i n : Nat), motive (n + i) n ↑i hn : ∀ (i m : Nat), motive m (m + i + 1) -[i+1] k : Nat h : n - m = succ k ⊢ motive m n (match succ k with \| 0 => ofNat (m - n) \| succ k => -[k+1]) rw [Nat.sub_eq_iff_eq_add (Nat.le_of_lt (Nat.lt_of_sub_eq_succ h))] at h m n : Nat motive : Nat → Nat → Int → Prop hp : ∀ (i n : Nat), motive (n + i) n ↑i hn : ∀ (i m : Nat), motive m (m + i + 1) -[i+1] k : Nat h : n = succ k + m ⊢ motive m n (match succ k with \| 0 => ofNat (m - n) \| succ k => -[k+1]) rw [h, Nat.add_comm] m n : Nat motive : Nat → Nat → Int → Prop hp : ∀ (i n : Nat), motive (n + i) n ↑i hn : ∀ (i m : Nat), motive m (m + i + 1) -[i+1] k : Nat h : n = succ k + m ⊢ motive m (m + succ k) (match succ k with \| 0 => ofNat (m - (m + succ k)) \| succ k => -[k+1]) apply hn ** Qed
Int.subNatNat_add_left m n : Nat ⊢ subNatNat (m + n) m = ↑n unfold subNatNat m n : Nat ⊢ (match m - (m + n) with \| 0 => ofNat (m + n - m) \| succ k => -[k+1]) = ↑n rw [Nat.sub_eq_zero_of_le (Nat.le_add_right ..), Nat.add_sub_cancel_left, ofNat_eq_coe] ** Qed
Int.subNatNat_add_right m n : Nat ⊢ subNatNat m (m + n + 1) = -[n+1] simp [subNatNat, Nat.add_assoc, Nat.add_sub_cancel_left] ** Qed
Int.natAbs_pos a : Int ⊢ 0 < natAbs a ↔ a ≠ 0 rw [Nat.pos_iff_ne_zero, Ne, natAbs_eq_zero] ** Qed
Int.natAbs_negOfNat n : Nat ⊢ natAbs (negOfNat n) = n cases n <;> rfl ** Qed
Int.natAbs_mul_natAbs_eq ** a b : Int c : Nat h : a * b = ↑c ⊢ natAbs a * natAbs b = c rw [← natAbs_mul, h, natAbs] Qed
Int.natAbs_mul_self' ** a : Int ⊢ ↑(natAbs a) * ↑(natAbs a) = a * a rw [← Int.ofNat_mul, natAbs_mul_self] Qed
Int.natAbs_eq_natAbs_iff a b : Int ⊢ natAbs a = natAbs b ↔ a = b ∨ a = -b constructor <;> intro h case mp a b : Int h : natAbs a = natAbs b ⊢ a = b ∨ a = -b cases Int.natAbs_eq a with \| inl h₁ \| inr h₁ => cases Int.natAbs_eq b with \| inl h₂ \| inr h₂ => rw [h₁, h₂]; simp [h] case mp.inr a b : Int h : natAbs a = natAbs b h₁ : a = -↑(natAbs a) ⊢ a = b ∨ a = -b cases Int.natAbs_eq b with \| inl h₂ \| inr h₂ => rw [h₁, h₂]; simp [h] case mp.inr.inr a b : Int h : natAbs a = natAbs b h₁ : a = -↑(natAbs a) h₂ : b = -↑(natAbs b) ⊢ a = b ∨ a = -b rw [h₁, h₂] case mp.inr.inr a b : Int h : natAbs a = natAbs b h₁ : a = -↑(natAbs a) h₂ : b = -↑(natAbs b) ⊢ -↑(natAbs a) = -↑(natAbs b) ∨ -↑(natAbs a) = - -↑(natAbs b) simp [h] case mpr a b : Int h : a = b ∨ a = -b ⊢ natAbs a = natAbs b cases h with (subst a; try rfl) \| inr h => rw [Int.natAbs_neg] case mpr.inl a b : Int h✝ : a = b ⊢ natAbs a = natAbs b subst a case mpr.inl b : Int ⊢ natAbs b = natAbs b try rfl case mpr.inl b : Int ⊢ natAbs b = natAbs b rfl case mpr.inr b : Int ⊢ natAbs (-b) = natAbs b rw [Int.natAbs_neg] ** Qed
Int.natAbs_eq_iff a : Int n : Nat ⊢ natAbs a = n ↔ a = ↑n ∨ a = -↑n rw [← Int.natAbs_eq_natAbs_iff, Int.natAbs_ofNat] ** Qed
Int.sign_neg z : Int ⊢ sign (-z) = -sign z match z with \| 0 \| succ _ \| -[_+1] => rfl z : Int a✝ : Nat ⊢ sign (- -[a✝+1]) = -sign -[a✝+1] rfl ** Qed
Int.add_comm n m : Nat ⊢ ofNat n + ofNat m = ofNat m + ofNat n simp [Nat.add_comm] a✝¹ a✝ : Nat ⊢ -[a✝¹+1] + -[a✝+1] = -[a✝+1] + -[a✝¹+1] simp [Nat.add_comm] ** Qed
Int.ofNat_add_negSucc_of_lt m n : Nat h : m < succ n ⊢ subNatNat m (succ n) = -[n - m+1] simp [succ_sub (le_of_lt_succ h), subNatNat] ** Qed
Int.subNatNat_sub n m : Nat h : n ≤ m k : Nat ⊢ subNatNat (m - n) k = subNatNat m (k + n) rwa [← subNatNat_add_add _ _ n, Nat.sub_add_cancel] ** Qed
Int.subNatNat_add m n k : Nat ⊢ subNatNat (m + n) k = ↑m + subNatNat n k cases n.lt_or_ge k with \| inl h' => simp [subNatNat_of_lt h', succ_pred_eq_of_pos (Nat.sub_pos_of_lt h')] conv => lhs; rw [← Nat.sub_add_cancel (Nat.le_of_lt h')] apply subNatNat_add_add \| inr h' => simp [subNatNat_of_le h', subNatNat_of_le (Nat.le_trans h' (le_add_left ..)), Nat.add_sub_assoc h'] case inl m n k : Nat h' : n < k ⊢ subNatNat (m + n) k = ↑m + subNatNat n k simp [subNatNat_of_lt h', succ_pred_eq_of_pos (Nat.sub_pos_of_lt h')] case inl m n k : Nat h' : n < k ⊢ subNatNat (m + n) k = subNatNat m (k - n) conv => lhs; rw [← Nat.sub_add_cancel (Nat.le_of_lt h')] case inl m n k : Nat h' : n < k ⊢ subNatNat (m + n) (k - n + n) = subNatNat m (k - n) apply subNatNat_add_add case inr m n k : Nat h' : n ≥ k ⊢ subNatNat (m + n) k = ↑m + subNatNat n k simp [subNatNat_of_le h', subNatNat_of_le (Nat.le_trans h' (le_add_left ..)), Nat.add_sub_assoc h'] ** Qed
Int.add_left_comm a b c : Int ⊢ a + (b + c) = b + (a + c) rw [← Int.add_assoc, Int.add_comm a, Int.add_assoc] ** Qed
Int.add_right_comm a b c : Int ⊢ a + b + c = a + c + b rw [Int.add_assoc, Int.add_comm b, ← Int.add_assoc] ** Qed
Int.subNatNat_self m : Nat ⊢ subNatNat (succ m) (succ m) = 0 rw [subNatNat_of_sub_eq_zero (Nat.sub_self ..), Nat.sub_self, ofNat_zero] ** Qed
Int.add_left_neg m : Nat ⊢ -↑(succ m) + ↑(succ m) = 0 simp m : Nat ⊢ - -[m+1] + -[m+1] = 0 simp ** Qed
Int.add_right_neg a : Int ⊢ a + -a = 0 rw [Int.add_comm, Int.add_left_neg] ** Qed
Int.neg_eq_of_add_eq_zero a b : Int h : a + b = 0 ⊢ -a = b rw [← Int.add_zero (-a), ← h, ← Int.add_assoc, Int.add_left_neg, Int.zero_add] ** Qed
Int.eq_neg_of_eq_neg a b : Int h : a = -b ⊢ b = -a rw [h, Int.neg_neg] ** Qed
Int.neg_eq_comm a b : Int ⊢ -a = b ↔ -b = a rw [eq_comm, Int.eq_neg_comm, eq_comm] ** Qed
Int.neg_add_cancel_left a b : Int ⊢ -a + (a + b) = b rw [← Int.add_assoc, Int.add_left_neg, Int.zero_add] ** Qed
Int.add_neg_cancel_left a b : Int ⊢ a + (-a + b) = b rw [← Int.add_assoc, Int.add_right_neg, Int.zero_add] ** Qed
Int.add_neg_cancel_right a b : Int ⊢ a + b + -b = a rw [Int.add_assoc, Int.add_right_neg, Int.add_zero] ** Qed
Int.neg_add_cancel_right a b : Int ⊢ a + -b + b = a rw [Int.add_assoc, Int.add_left_neg, Int.add_zero] ** Qed
Int.add_left_cancel a b c : Int h : a + b = a + c ⊢ b = c have h₁ : -a + (a + b) = -a + (a + c) := by rw [h] a b c : Int h : a + b = a + c h₁ : -a + (a + b) = -a + (a + c) ⊢ b = c simp [← Int.add_assoc, Int.add_left_neg, Int.zero_add] at h₁ a b c : Int h : a + b = a + c h₁ : b = c ⊢ b = c exact h₁ a b c : Int h : a + b = a + c ⊢ -a + (a + b) = -a + (a + c) rw [h] ** Qed
Int.neg_add a b : Int ⊢ -(a + b) = -a + -b apply Int.add_left_cancel (a := a + b) a b : Int ⊢ a + b + -(a + b) = a + b + (-a + -b) rw [Int.add_right_neg, Int.add_comm a, ← Int.add_assoc, Int.add_assoc b, Int.add_right_neg, Int.add_zero, Int.add_right_neg] ** Qed
Int.sub_self a : Int ⊢ a - a = 0 rw [Int.sub_eq_add_neg, Int.add_right_neg] ** Qed
Int.sub_zero a : Int ⊢ a - 0 = a simp [Int.sub_eq_add_neg] ** Qed
Int.zero_sub a : Int ⊢ 0 - a = -a simp [Int.sub_eq_add_neg] ** Qed
Int.sub_eq_zero_of_eq a b : Int h : a = b ⊢ a - b = 0 rw [h, Int.sub_self] ** Qed
Int.eq_of_sub_eq_zero a b : Int h : a - b = 0 ⊢ a = b have : 0 + b = b := by rw [Int.zero_add] a b : Int h : a - b = 0 this : 0 + b = b ⊢ a = b have : a - b + b = b := by rwa [h] a b : Int h : a - b = 0 this✝ : 0 + b = b this : a - b + b = b ⊢ a = b rwa [Int.sub_eq_add_neg, Int.neg_add_cancel_right] at this a b : Int h : a - b = 0 ⊢ 0 + b = b rw [Int.zero_add] a b : Int h : a - b = 0 this : 0 + b = b ⊢ a - b + b = b rwa [h] ** Qed
Int.sub_sub a b c : Int ⊢ a - b - c = a - (b + c) simp [Int.sub_eq_add_neg, Int.add_assoc] ** Qed
Int.neg_sub a b : Int ⊢ -(a - b) = b - a simp [Int.sub_eq_add_neg, Int.add_comm] ** Qed
Int.sub_sub_self a b : Int ⊢ a - (a - b) = b simp [Int.sub_eq_add_neg, ← Int.add_assoc] ** Qed
Int.sub_neg a b : Int ⊢ a - -b = a + b simp [Int.sub_eq_add_neg] ** Qed
Int.mul_comm ** a b : Int ⊢ a * b = b * a cases a <;> cases b <;> simp [Nat.mul_comm] Qed
Int.ofNat_mul_negOfNat ** m n : Nat ⊢ ↑m * negOfNat n = negOfNat (m * n) cases n <;> rfl Qed
Int.negSucc_mul_negOfNat ** m n : Nat ⊢ -[m+1] * negOfNat n = ofNat (succ m * n) cases n <;> rfl Qed
Int.mul_assoc ** a b c : Int ⊢ a * b * c = a * (b * c) cases a <;> cases b <;> cases c <;> simp [Nat.mul_assoc] Qed
Int.mul_left_comm ** a b c : Int ⊢ a * (b * c) = b * (a * c) rw [← Int.mul_assoc, ← Int.mul_assoc, Int.mul_comm a] Qed
Int.mul_right_comm ** a b c : Int ⊢ a * b * c = a * c * b rw [Int.mul_assoc, Int.mul_assoc, Int.mul_comm b] Qed
Int.mul_zero ** a : Int ⊢ a * 0 = 0 cases a <;> rfl Qed
Int.negOfNat_eq_subNatNat_zero n : Nat ⊢ negOfNat n = subNatNat 0 n cases n <;> rfl ** Qed
Int.ofNat_mul_subNatNat ** m n k : Nat ⊢ ↑m * subNatNat n k = subNatNat (m * n) (m * k) ** cases m with \| zero => simp [ofNat_zero, Int.zero_mul, Nat.zero_mul] \| succ m => cases n.lt_or_ge k with \| inl h => have h' : succ m * n < succ m * k := Nat.mul_lt_mul_of_pos_left h (Nat.succ_pos m) simp [subNatNat_of_lt h, subNatNat_of_lt h'] rw [succ_pred_eq_of_pos (Nat.sub_pos_of_lt h), ← neg_ofNat_succ, Nat.mul_sub_left_distrib, ← succ_pred_eq_of_pos (Nat.sub_pos_of_lt h')]; rfl \| inr h => have h' : succ m * k ≤ succ m * n := Nat.mul_le_mul_left _ h simp [subNatNat_of_le h, subNatNat_of_le h', Nat.mul_sub_left_distrib] ** case zero n k : Nat ⊢ ↑zero * subNatNat n k = subNatNat (zero * n) (zero * k) simp [ofNat_zero, Int.zero_mul, Nat.zero_mul] case succ n k m : Nat ⊢ ↑(succ m) * subNatNat n k = subNatNat (succ m * n) (succ m * k) ** cases n.lt_or_ge k with \| inl h => have h' : succ m * n < succ m * k := Nat.mul_lt_mul_of_pos_left h (Nat.succ_pos m) simp [subNatNat_of_lt h, subNatNat_of_lt h'] rw [succ_pred_eq_of_pos (Nat.sub_pos_of_lt h), ← neg_ofNat_succ, Nat.mul_sub_left_distrib, ← succ_pred_eq_of_pos (Nat.sub_pos_of_lt h')]; rfl \| inr h => have h' : succ m * k ≤ succ m * n := Nat.mul_le_mul_left _ h simp [subNatNat_of_le h, subNatNat_of_le h', Nat.mul_sub_left_distrib] ** case succ.inl n k m : Nat h : n < k ⊢ ↑(succ m) * subNatNat n k = subNatNat (succ m * n) (succ m * k) ** have h' : succ m * n < succ m * k := Nat.mul_lt_mul_of_pos_left h (Nat.succ_pos m) ** case succ.inl n k m : Nat h : n < k h' : succ m * n < succ m * k ⊢ ↑(succ m) * subNatNat n k = subNatNat (succ m * n) (succ m * k) simp [subNatNat_of_lt h, subNatNat_of_lt h'] case succ.inl n k m : Nat h : n < k h' : succ m * n < succ m * k ⊢ negOfNat (succ m * succ (pred (k - n))) = -[pred (succ m * k - succ m * n)+1] rw [succ_pred_eq_of_pos (Nat.sub_pos_of_lt h), ← neg_ofNat_succ, Nat.mul_sub_left_distrib, ← succ_pred_eq_of_pos (Nat.sub_pos_of_lt h')] case succ.inl n k m : Nat h : n < k h' : succ m * n < succ m * k ⊢ negOfNat (succ (pred (succ m * k - succ m * n))) = -↑(succ (pred (succ (pred (succ m * k - succ m * n))))) rfl case succ.inr n k m : Nat h : n ≥ k ⊢ ↑(succ m) * subNatNat n k = subNatNat (succ m * n) (succ m * k) ** have h' : succ m * k ≤ succ m * n := Nat.mul_le_mul_left _ h ** case succ.inr n k m : Nat h : n ≥ k h' : succ m * k ≤ succ m * n ⊢ ↑(succ m) * subNatNat n k = subNatNat (succ m * n) (succ m * k) simp [subNatNat_of_le h, subNatNat_of_le h', Nat.mul_sub_left_distrib] Qed
Int.negOfNat_add m n : Nat ⊢ negOfNat m + negOfNat n = negOfNat (m + n) cases m <;> cases n <;> simp [Nat.succ_add] <;> rfl ** Qed
Int.negSucc_mul_subNatNat ** m n k : Nat ⊢ -[m+1] * subNatNat n k = subNatNat (succ m * k) (succ m * n) ** cases n.lt_or_ge k with \| inl h => have h' : succ m * n < succ m * k := Nat.mul_lt_mul_of_pos_left h (Nat.succ_pos m) rw [subNatNat_of_lt h, subNatNat_of_le (Nat.le_of_lt h')] simp [succ_pred_eq_of_pos (Nat.sub_pos_of_lt h), Nat.mul_sub_left_distrib] \| inr h => cases Nat.lt_or_ge k n with \| inl h' => have h₁ : succ m * n > succ m * k := Nat.mul_lt_mul_of_pos_left h' (Nat.succ_pos m) rw [subNatNat_of_le h, subNatNat_of_lt h₁, negSucc_mul_ofNat, Nat.mul_sub_left_distrib, ← succ_pred_eq_of_pos (Nat.sub_pos_of_lt h₁)]; rfl \| inr h' => rw [Nat.le_antisymm h h', subNatNat_self, subNatNat_self, Int.mul_zero] ** case inl m n k : Nat h : n < k ⊢ -[m+1] * subNatNat n k = subNatNat (succ m * k) (succ m * n) ** have h' : succ m * n < succ m * k := Nat.mul_lt_mul_of_pos_left h (Nat.succ_pos m) ** case inl m n k : Nat h : n < k h' : succ m * n < succ m * k ⊢ -[m+1] * subNatNat n k = subNatNat (succ m * k) (succ m * n) rw [subNatNat_of_lt h, subNatNat_of_le (Nat.le_of_lt h')] case inl m n k : Nat h : n < k h' : succ m * n < succ m * k ⊢ -[m+1] * -[pred (k - n)+1] = ↑(succ m * k - succ m * n) simp [succ_pred_eq_of_pos (Nat.sub_pos_of_lt h), Nat.mul_sub_left_distrib] case inr m n k : Nat h : n ≥ k ⊢ -[m+1] * subNatNat n k = subNatNat (succ m * k) (succ m * n) ** cases Nat.lt_or_ge k n with \| inl h' => have h₁ : succ m * n > succ m * k := Nat.mul_lt_mul_of_pos_left h' (Nat.succ_pos m) rw [subNatNat_of_le h, subNatNat_of_lt h₁, negSucc_mul_ofNat, Nat.mul_sub_left_distrib, ← succ_pred_eq_of_pos (Nat.sub_pos_of_lt h₁)]; rfl \| inr h' => rw [Nat.le_antisymm h h', subNatNat_self, subNatNat_self, Int.mul_zero] ** case inr.inl m n k : Nat h : n ≥ k h' : k < n ⊢ -[m+1] * subNatNat n k = subNatNat (succ m * k) (succ m * n) ** have h₁ : succ m * n > succ m * k := Nat.mul_lt_mul_of_pos_left h' (Nat.succ_pos m) ** case inr.inl m n k : Nat h : n ≥ k h' : k < n h₁ : succ m * n > succ m * k ⊢ -[m+1] * subNatNat n k = subNatNat (succ m * k) (succ m * n) rw [subNatNat_of_le h, subNatNat_of_lt h₁, negSucc_mul_ofNat, Nat.mul_sub_left_distrib, ← succ_pred_eq_of_pos (Nat.sub_pos_of_lt h₁)] case inr.inl m n k : Nat h : n ≥ k h' : k < n h₁ : succ m * n > succ m * k ⊢ -↑(succ (pred (succ m * n - succ m * k))) = -[pred (succ (pred (succ m * n - succ m * k)))+1] rfl case inr.inr m n k : Nat h : n ≥ k h' : k ≥ n ⊢ -[m+1] * subNatNat n k = subNatNat (succ m * k) (succ m * n) rw [Nat.le_antisymm h h', subNatNat_self, subNatNat_self, Int.mul_zero] Qed
Int.mul_add ** m n k : Nat ⊢ ↑m * (↑n + ↑k) = ↑m * ↑n + ↑m * ↑k simp [Nat.left_distrib] m n k : Nat ⊢ ↑m * (↑n + -[k+1]) = ↑m * ↑n + ↑m * -[k+1] simp [negOfNat_eq_subNatNat_zero] m n k : Nat ⊢ subNatNat (m * n) (m * succ k) = ↑(m * n) + subNatNat 0 (m * succ k) rw [← subNatNat_add] m n k : Nat ⊢ subNatNat (m * n) (m * succ k) = subNatNat (m * n + 0) (m * succ k) rfl m n k : Nat ⊢ ↑m * (-[n+1] + ↑k) = ↑m * -[n+1] + ↑m * ↑k simp [negOfNat_eq_subNatNat_zero] m n k : Nat ⊢ subNatNat (m * k) (m * succ n) = subNatNat 0 (m * succ n) + ↑(m * k) rw [Int.add_comm, ← subNatNat_add] m n k : Nat ⊢ subNatNat (m * k) (m * succ n) = subNatNat (m * k + 0) (m * succ n) rfl m n k : Nat ⊢ ↑m * (-[n+1] + -[k+1]) = ↑m * -[n+1] + ↑m * -[k+1] simp m n k : Nat ⊢ negOfNat (m * succ (succ (n + k))) = negOfNat (m * succ n + m * succ k) rw [← Nat.left_distrib, succ_add] m n k : Nat ⊢ negOfNat (m * succ (succ (n + k))) = negOfNat (m * succ (n + succ k)) rfl m n k : Nat ⊢ -[m+1] * (↑n + ↑k) = -[m+1] * ↑n + -[m+1] * ↑k simp [Nat.mul_comm] m n k : Nat ⊢ negOfNat ((n + k) * succ m) = negOfNat (n * succ m + k * succ m) rw [← Nat.right_distrib, Nat.mul_comm] m n k : Nat ⊢ -[m+1] * (↑n + -[k+1]) = -[m+1] * ↑n + -[m+1] * -[k+1] simp [negOfNat_eq_subNatNat_zero] m n k : Nat ⊢ subNatNat (succ m * succ k) (succ m * n) = subNatNat 0 (succ m * n) + ↑(succ m * succ k) rw [Int.add_comm, ← subNatNat_add] m n k : Nat ⊢ subNatNat (succ m * succ k) (succ m * n) = subNatNat (succ m * succ k + 0) (succ m * n) rfl m n k : Nat ⊢ -[m+1] * (-[n+1] + ↑k) = -[m+1] * -[n+1] + -[m+1] * ↑k simp [negOfNat_eq_subNatNat_zero] m n k : Nat ⊢ subNatNat (succ m * succ n) (succ m * k) = ↑(succ m * succ n) + subNatNat 0 (succ m * k) rw [← subNatNat_add] m n k : Nat ⊢ subNatNat (succ m * succ n) (succ m * k) = subNatNat (succ m * succ n + 0) (succ m * k) rfl m n k : Nat ⊢ -[m+1] * (-[n+1] + -[k+1]) = -[m+1] * -[n+1] + -[m+1] * -[k+1] simp m n k : Nat ⊢ ↑(succ m * succ (succ (n + k))) = ↑(succ m * succ n + succ m * succ k) rw [← Nat.left_distrib, succ_add] m n k : Nat ⊢ ↑(succ m * succ (succ (n + k))) = ↑(succ m * succ (n + succ k)) rfl Qed
Int.add_mul ** a b c : Int ⊢ (a + b) * c = a * c + b * c simp [Int.mul_comm, Int.mul_add] Qed
Int.neg_mul_eq_neg_mul ** a b : Int ⊢ a * b + -a * b = 0 rw [← Int.add_mul, Int.add_right_neg, Int.zero_mul] Qed
Int.neg_mul_eq_mul_neg ** a b : Int ⊢ a * b + a * -b = 0 rw [← Int.mul_add, Int.add_right_neg, Int.mul_zero] Qed
Int.neg_mul_neg ** a b : Int ⊢ -a * -b = a * b simp Qed
Int.neg_mul_comm ** a b : Int ⊢ -a * b = a * -b simp Qed
Int.mul_sub ** a b c : Int ⊢ a * (b - c) = a * b - a * c simp [Int.sub_eq_add_neg, Int.mul_add] Qed
Int.sub_mul ** a b c : Int ⊢ (a - b) * c = a * c - b * c simp [Int.sub_eq_add_neg, Int.add_mul] Qed
Int.add_sub_assoc a b c : Int ⊢ a + b - c = a + (b - c) rw [Int.sub_eq_add_neg, Int.add_assoc, ← Int.sub_eq_add_neg] ** Qed
Int.ofNat_sub m n : Nat h : m ≤ n ⊢ ↑(n - m) = ↑n - ↑m match m with \| 0 => rfl \| succ m => show ofNat (n - succ m) = subNatNat n (succ m) rw [subNatNat, Nat.sub_eq_zero_of_le h] m n : Nat h : 0 ≤ n ⊢ ↑(n - 0) = ↑n - ↑0 rfl m✝ n m : Nat h : succ m ≤ n ⊢ ↑(n - succ m) = ↑n - ↑(succ m) show ofNat (n - succ m) = subNatNat n (succ m) m✝ n m : Nat h : succ m ≤ n ⊢ ofNat (n - succ m) = subNatNat n (succ m) rw [subNatNat, Nat.sub_eq_zero_of_le h] ** Qed
Int.negSucc_coe' n : Nat ⊢ -[n+1] = -↑n - 1 rw [Int.sub_eq_add_neg, ← Int.neg_add] n : Nat ⊢ -[n+1] = -(↑n + 1) rfl ** Qed
Int.subNatNat_eq_coe m n : Nat ⊢ subNatNat m n = ↑m - ↑n apply subNatNat_elim m n fun m n i => i = m - n case hp m n : Nat ⊢ ∀ (i n : Nat), ↑i = ↑(n + i) - ↑n intros i n case hp m n✝ i n : Nat ⊢ ↑i = ↑(n + i) - ↑n rw [Int.ofNat_add, Int.sub_eq_add_neg, Int.add_assoc, Int.add_left_comm, Int.add_right_neg, Int.add_zero] case hn m n : Nat ⊢ ∀ (i m : Nat), -[i+1] = ↑m - ↑(m + i + 1) intros i n case hn m n✝ i n : Nat ⊢ -[i+1] = ↑n - ↑(n + i + 1) simp only [negSucc_coe, ofNat_add, Int.sub_eq_add_neg, Int.neg_add, ← Int.add_assoc] case hn m n✝ i n : Nat ⊢ -↑i + -↑1 = ↑n + -↑n + -↑i + -↑1 rw [← @Int.sub_eq_add_neg n, ← ofNat_sub, Nat.sub_self, ofNat_zero, Int.zero_add] case hn m n✝ i n : Nat ⊢ n ≤ n apply Nat.le_refl ** Qed
Int.toNat_sub m n : Nat ⊢ toNat (↑m - ↑n) = m - n rw [← Int.subNatNat_eq_coe] m n : Nat ⊢ toNat (subNatNat m n) = m - n refine subNatNat_elim m n (fun m n i => toNat i = m - n) (fun i n => ?_) (fun i n => ?_) case refine_1 m n✝ i n : Nat ⊢ (fun m n i => toNat i = m - n) (n + i) n ↑i exact (Nat.add_sub_cancel_left ..).symm case refine_2 m n✝ i n : Nat ⊢ (fun m n i => toNat i = m - n) n (n + i + 1) -[i+1] dsimp case refine_2 m n✝ i n : Nat ⊢ toNat -[i+1] = n - (n + i + 1) rw [Nat.add_assoc, Nat.sub_eq_zero_of_le (Nat.le_add_right ..)] case refine_2 m n✝ i n : Nat ⊢ toNat -[i+1] = 0 rfl ** Qed
Int.one_mul ** n : Nat ⊢ ofNat (1 * n) = ofNat n rw [Nat.one_mul] n : Nat ⊢ -[1 * n+1] = -[n+1] rw [Nat.one_mul] Qed
Int.mul_one ** a : Int ⊢ a * 1 = a rw [Int.mul_comm, Int.one_mul] Qed
Int.mul_neg_one ** a : Int ⊢ a * -1 = -a rw [Int.mul_neg, Int.mul_one] Qed
Int.neg_eq_neg_one_mul ** n : Nat ⊢ -↑(succ n) = -[1 * n+1] rw [Nat.one_mul] n : Nat ⊢ -↑(succ n) = -[n+1] rfl n : Nat ⊢ - -[n+1] = ofNat (succ 0 * succ n) rw [Nat.one_mul] n : Nat ⊢ - -[n+1] = ofNat (succ n) rfl Qed
Int.sign_mul ** b : Int ⊢ sign (0 * b) = sign 0 * sign b simp [Int.mul_zero, Int.zero_mul] Qed
Int.le.intro a b : Int n : Nat h : a + ↑n = b ⊢ b - a = ↑n rw [← h, Int.add_comm] a b : Int n : Nat h : a + ↑n = b ⊢ ↑n + a - a = ↑n simp [Int.sub_eq_add_neg, Int.add_assoc] ** Qed