module stringlengths 16 90 | startPos dict | endPos dict | goals listlengths 0 96 | ppTac stringlengths 1 14.5k | elaborator stringclasses 366
values | kind stringclasses 370
values |
|---|---|---|---|---|---|---|
Mathlib.Order.BooleanAlgebra.Basic | {
"line": 237,
"column": 40
} | {
"line": 237,
"column": 48
} | [
{
"pp": "α : Type u\nx y : α\ninst✝ : GeneralizedBooleanAlgebra α\n⊢ x \\ y = ⊥ ∧ y = ⊥ ↔ x = ⊥ ∧ y = ⊥",
"usedConstants": [
"congrArg",
"OrderBot.toBot",
"PartialOrder.toPreorder",
"Preorder.toLE",
"SemilatticeInf.toPartialOrder",
"Bot.bot",
"LE.le",
"General... | simp_all | Lean.Elab.Tactic.evalSimpAll | Lean.Parser.Tactic.simpAll |
Mathlib.Order.BooleanAlgebra.Basic | {
"line": 325,
"column": 6
} | {
"line": 325,
"column": 22
} | [
{
"pp": "α : Type u\nx y z : α\ninst✝ : GeneralizedBooleanAlgebra α\nhcb : z ≤ y\n⊢ (x \\ z) \\ (y \\ z) = x \\ y",
"usedConstants": [
"Eq.mpr",
"congrArg",
"PartialOrder.toPreorder",
"Preorder.toLE",
"SemilatticeInf.toPartialOrder",
"id",
"LE.le",
"Generalize... | le_antisymm_iff, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Logic.Equiv.Basic | {
"line": 382,
"column": 10
} | {
"line": 383,
"column": 28
} | [
{
"pp": "case F.e\nα✝ : Sort u_1\nα₁ : Sort u_2\nα₂ : Sort u_3\nβ✝ : Sort u_4\nβ₁ : Sort u_5\nβ₂ : Sort u_6\nγ : Sort u_7\nδ : Sort u_8\nα : Type u_9\nβ : Type u_10\nf : α → β\np : α → Prop\nq : β → Prop\nh : ∀ (x : α), p x ↔ q (f x)\ny : Subtype q\nx : α\n⊢ (∃ h_1, ⟨f ↑⟨x, h_1⟩, ⋯⟩ = y) ↔ f x = ↑y",
"usedC... | exact ⟨fun ⟨hp, h'⟩ => congr_arg Subtype.val h', fun h' => ⟨(h x).2 (h'.symm ▸ y.2),
Subtype.ext h'⟩⟩ | Lean.Elab.Tactic.evalExact | Lean.Parser.Tactic.exact |
Mathlib.Order.SymmDiff | {
"line": 376,
"column": 2
} | {
"line": 376,
"column": 43
} | [
{
"pp": "α : Type u_2\ninst✝ : GeneralizedBooleanAlgebra α\na b : α\nh : Disjoint (a ⊓ b) (a ⊔ b)\n⊢ Disjoint a b",
"usedConstants": [
"Lattice.toSemilatticeSup",
"le_sup_left",
"Disjoint.of_disjoint_inf_of_le",
"SemilatticeSup.toMax",
"GeneralizedBooleanAlgebra.toGeneralizedCo... | exact h.of_disjoint_inf_of_le le_sup_left | Lean.Elab.Tactic.evalExact | Lean.Parser.Tactic.exact |
Mathlib.Order.SymmDiff | {
"line": 426,
"column": 21
} | {
"line": 426,
"column": 50
} | [
{
"pp": "α : Type u_2\ninst✝ : GeneralizedBooleanAlgebra α\na b : α\n⊢ a ∆ (a ∆ b) = b",
"usedConstants": [
"Eq.mpr",
"Lattice.toSemilatticeSup",
"congrArg",
"SemilatticeSup.toMax",
"id",
"GeneralizedBooleanAlgebra.toGeneralizedCoheytingAlgebra",
"symmDiff_symmDiff_... | symmDiff_symmDiff_cancel_left | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Logic.Equiv.Basic | {
"line": 1066,
"column": 42
} | {
"line": 1066,
"column": 50
} | [
{
"pp": "case h.inl\nα : Sort u_1\nβ : Sort u_4\ninst✝¹ : DecidableEq α\ninst✝ : DecidableEq β\nP : α → Sort u_10\ne : α ≃ β\nf : (a : α) → P a\nb' : β\nx : P (e.symm b')\n⊢ (Equiv.piCongrLeft' P e) (update f (e.symm b') x) b' = update ((Equiv.piCongrLeft' P e) f) b' x b'",
"usedConstants": [
"Functio... | simp_all | Lean.Elab.Tactic.evalSimpAll | Lean.Parser.Tactic.simpAll |
Mathlib.Logic.Equiv.Basic | {
"line": 1066,
"column": 42
} | {
"line": 1066,
"column": 50
} | [
{
"pp": "case h.inr\nα : Sort u_1\nβ : Sort u_4\ninst✝¹ : DecidableEq α\ninst✝ : DecidableEq β\nP : α → Sort u_10\ne : α ≃ β\nf : (a : α) → P a\nb : β\nx : P (e.symm b)\nb' : β\nh : b' ≠ b\n⊢ (Equiv.piCongrLeft' P e) (update f (e.symm b) x) b' = update ((Equiv.piCongrLeft' P e) f) b x b'",
"usedConstants": ... | simp_all | Lean.Elab.Tactic.evalSimpAll | Lean.Parser.Tactic.simpAll |
Mathlib.Data.Set.Prod | {
"line": 130,
"column": 2
} | {
"line": 130,
"column": 53
} | [
{
"pp": "case h\nα : Type u_1\nβ : Type u_2\ns : Set α\nt₁ t₂ : Set β\nx : α\ny : β\n⊢ (x, y) ∈ s ×ˢ (t₁ ∩ t₂) ↔ (x, y) ∈ s ×ˢ t₁ ∩ s ×ˢ t₂",
"usedConstants": [
"_private.Mathlib.Data.Set.Prod.0.Set.prod_inter._simp_1_3",
"Set.instSProd",
"SProd.sprod",
"congrArg",
"Membership.... | simp only [← and_and_left, mem_inter_iff, mem_prod] | Lean.Elab.Tactic.evalSimp | Lean.Parser.Tactic.simp |
Mathlib.Data.Set.Prod | {
"line": 334,
"column": 28
} | {
"line": 334,
"column": 53
} | [
{
"pp": "case mp\nα : Type u_1\nβ : Type u_2\ns s₁ : Set α\nt t₁ : Set β\nh : s.Nonempty ∧ t.Nonempty\nheq : s ×ˢ t = s₁ ×ˢ t₁\nh₁ : s₁.Nonempty ∧ t₁.Nonempty\n⊢ Prod.snd '' s ×ˢ t = t₁",
"usedConstants": [
"Set.instSProd",
"Eq.mpr",
"SProd.sprod",
"congrArg",
"id",
"Set.... | ← snd_image_prod h₁.1 t₁, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Data.Set.Prod | {
"line": 342,
"column": 16
} | {
"line": 342,
"column": 29
} | [
{
"pp": "case inl\nα : Type u_1\nβ : Type u_2\ns s₁ : Set α\nt t₁ : Set β\nh : s ×ˢ t = ∅\n⊢ s = s₁ ∧ t = t₁ ∨ (s = ∅ ∨ t = ∅) ∧ (s₁ = ∅ ∨ t₁ = ∅) ↔ ∅ = s₁ ×ˢ t₁",
"usedConstants": [
"Set.instSProd",
"Eq.mpr",
"SProd.sprod",
"congrArg",
"id",
"eq_comm",
"And",
... | @eq_comm _ ∅, | Mathlib.Tactic._aux_Mathlib_Tactic_SimpRw___elabRules_Mathlib_Tactic_tacticSimp_rw____1 | null |
Mathlib.Data.Set.Image | {
"line": 328,
"column": 2
} | {
"line": 328,
"column": 31
} | [
{
"pp": "α : Type u_1\nβ : Type u_2\nf : α → β\ns s' : Set β\n⊢ (range f ∩ s ⊆ range f ∩ s' ∧ ∃ x, x ∈ range f ∩ s' ∧ ¬x ∈ range f ∩ s) ↔\n f ⁻¹' s ⊆ f ⁻¹' s' ∧ ∃ x, x ∈ f ⁻¹' s' ∧ ¬x ∈ f ⁻¹' s",
"usedConstants": [
"Eq.mpr",
"False",
"eq_false",
"congrArg",
"Membership.mem",... | apply and_congr ?_ (by aesop) | Lean.Elab.Tactic.evalApply | Lean.Parser.Tactic.apply |
Mathlib.Data.Set.Image | {
"line": 454,
"column": 2
} | {
"line": 454,
"column": 94
} | [
{
"pp": "α : Type u_1\nβ : Type u_2\nf : α → β\ns : Set α\nt : Set β\n⊢ Disjoint (f '' s) t ↔ Disjoint s (f ⁻¹' t)",
"usedConstants": [
"Eq.mpr",
"congrArg",
"Disjoint",
"SemilatticeInf.toPartialOrder",
"id",
"BiheytingAlgebra.toHeytingAlgebra",
"BiheytingAlgebra.to... | simp_rw [disjoint_iff_inter_eq_empty, ← not_nonempty_iff_eq_empty, image_inter_nonempty_iff] | Mathlib.Tactic._aux_Mathlib_Tactic_SimpRw___elabRules_Mathlib_Tactic_tacticSimp_rw____1 | Mathlib.Tactic.tacticSimp_rw___ |
Mathlib.Data.Set.Image | {
"line": 454,
"column": 2
} | {
"line": 454,
"column": 94
} | [
{
"pp": "α : Type u_1\nβ : Type u_2\nf : α → β\ns : Set α\nt : Set β\n⊢ Disjoint (f '' s) t ↔ Disjoint s (f ⁻¹' t)",
"usedConstants": [
"Eq.mpr",
"congrArg",
"Disjoint",
"SemilatticeInf.toPartialOrder",
"id",
"BiheytingAlgebra.toHeytingAlgebra",
"BiheytingAlgebra.to... | simp_rw [disjoint_iff_inter_eq_empty, ← not_nonempty_iff_eq_empty, image_inter_nonempty_iff] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Data.Set.Image | {
"line": 454,
"column": 2
} | {
"line": 454,
"column": 94
} | [
{
"pp": "α : Type u_1\nβ : Type u_2\nf : α → β\ns : Set α\nt : Set β\n⊢ Disjoint (f '' s) t ↔ Disjoint s (f ⁻¹' t)",
"usedConstants": [
"Eq.mpr",
"congrArg",
"Disjoint",
"SemilatticeInf.toPartialOrder",
"id",
"BiheytingAlgebra.toHeytingAlgebra",
"BiheytingAlgebra.to... | simp_rw [disjoint_iff_inter_eq_empty, ← not_nonempty_iff_eq_empty, image_inter_nonempty_iff] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Data.Set.Prod | {
"line": 721,
"column": 21
} | {
"line": 721,
"column": 29
} | [
{
"pp": "case pos\nι : Type u_1\nα : ι → Type u_2\np : ι → Prop\nh : DecidablePred p\ns : Set ι\nt₁ t₂ : (i : ι) → Set (α i)\nf : (i : ι) → α i\nht₁ : f ∈ {i | i ∈ s ∧ p i}.pi t₁\nht₂ : f ∈ {i | i ∈ s ∧ ¬p i}.pi t₂\ni : ι\nhis : i ∈ s\nh✝ : p i\n⊢ f i ∈ (fun i ↦ if p i then t₁ i else t₂ i) i",
"usedConstant... | simp_all | Lean.Elab.Tactic.evalSimpAll | Lean.Parser.Tactic.simpAll |
Mathlib.Data.Set.Prod | {
"line": 721,
"column": 21
} | {
"line": 721,
"column": 29
} | [
{
"pp": "case neg\nι : Type u_1\nα : ι → Type u_2\np : ι → Prop\nh : DecidablePred p\ns : Set ι\nt₁ t₂ : (i : ι) → Set (α i)\nf : (i : ι) → α i\nht₁ : f ∈ {i | i ∈ s ∧ p i}.pi t₁\nht₂ : f ∈ {i | i ∈ s ∧ ¬p i}.pi t₂\ni : ι\nhis : i ∈ s\nh✝ : ¬p i\n⊢ f i ∈ (fun i ↦ if p i then t₁ i else t₂ i) i",
"usedConstan... | simp_all | Lean.Elab.Tactic.evalSimpAll | Lean.Parser.Tactic.simpAll |
Mathlib.Data.Set.Image | {
"line": 548,
"column": 4
} | {
"line": 552,
"column": 11
} | [
{
"pp": "case h.mp\nα : Type u_1\ns : Set α\na : α\nt : Set α\n⊢ t ∈ 𝒫 insert a s → t ∈ 𝒫 s ∪ insert a '' 𝒫 s",
"usedConstants": [
"_private.Mathlib.Data.Set.Image.0.Set.powerset_insert._proof_1_2",
"Set.powerset",
"Classical.propDecidable",
"Membership.mem",
"Set.instUnion"... | intro h
by_cases hs : a ∈ t
· right
refine ⟨t \ {a}, by grind⟩
· grind | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Data.Set.Image | {
"line": 548,
"column": 4
} | {
"line": 552,
"column": 11
} | [
{
"pp": "case h.mp\nα : Type u_1\ns : Set α\na : α\nt : Set α\n⊢ t ∈ 𝒫 insert a s → t ∈ 𝒫 s ∪ insert a '' 𝒫 s",
"usedConstants": [
"_private.Mathlib.Data.Set.Image.0.Set.powerset_insert._proof_1_2",
"Set.powerset",
"Classical.propDecidable",
"Membership.mem",
"Set.instUnion"... | intro h
by_cases hs : a ∈ t
· right
refine ⟨t \ {a}, by grind⟩
· grind | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Data.Set.Function | {
"line": 427,
"column": 4
} | {
"line": 429,
"column": 43
} | [
{
"pp": "case refine_1\nα : Type u_1\nβ : Type u_2\ninst✝ : Nonempty β\ns : Set (α × β)\n⊢ (∃ f, s = graphOn f (Prod.fst '' s)) → InjOn Prod.fst s",
"usedConstants": [
"Eq.mpr",
"Set.injOn_id",
"Set.InjOn.image_of_comp",
"congrArg",
"Exists",
"id",
"Prod.mk",
... | rintro ⟨f, hf⟩
rw [hf]
exact InjOn.image_of_comp <| injOn_id _ | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Data.Set.Function | {
"line": 427,
"column": 4
} | {
"line": 429,
"column": 43
} | [
{
"pp": "case refine_1\nα : Type u_1\nβ : Type u_2\ninst✝ : Nonempty β\ns : Set (α × β)\n⊢ (∃ f, s = graphOn f (Prod.fst '' s)) → InjOn Prod.fst s",
"usedConstants": [
"Eq.mpr",
"Set.injOn_id",
"Set.InjOn.image_of_comp",
"congrArg",
"Exists",
"id",
"Prod.mk",
... | rintro ⟨f, hf⟩
rw [hf]
exact InjOn.image_of_comp <| injOn_id _ | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Data.Set.Image | {
"line": 654,
"column": 11
} | {
"line": 654,
"column": 23
} | [
{
"pp": "α : Type u_1\nι : Sort u_4\nf : ι → α\ninst✝ : Nonempty ι\ny : α\n⊢ range f = {y} ↔ ∀ (x : ι), f x = y",
"usedConstants": [
"Eq.mpr",
"_private.Mathlib.Data.Set.Image.0.Set.range_eq_singleton_iff._simp_1_1",
"congrArg",
"Membership.mem",
"Set.instSingletonSet",
"... | Set.ext_iff, | Mathlib.Tactic._aux_Mathlib_Tactic_SimpRw___elabRules_Mathlib_Tactic_tacticSimp_rw____1 | null |
Mathlib.Data.Set.Function | {
"line": 1044,
"column": 4
} | {
"line": 1046,
"column": 63
} | [
{
"pp": "case mp.inr\nα : Type u_1\nβ : Type u_2\ns : Set α\nt : Set β\nf : α → β\nht : t.Nonempty\n⊢ SurjOn f s t → ∃ s', s' ⊆ s ∧ BijOn f s' t",
"usedConstants": [
"Set.SurjOn.mapsTo_invFunOn",
"Function.invFunOn",
"Set.SurjOn",
"Membership.mem",
"HasSubset.Subset",
"No... | · intro h
haveI : Nonempty α := ⟨Classical.choose (h.comap_nonempty ht)⟩
exact ⟨_, h.mapsTo_invFunOn.image_subset, h.bijOn_subset⟩ | Lean.Elab.Tactic.evalTacticCDot | Lean.cdot |
Mathlib.Data.Set.Piecewise | {
"line": 114,
"column": 75
} | {
"line": 116,
"column": 63
} | [
{
"pp": "α : Type u_1\nβ : Type u_2\ns : Set α\ninst✝ : (j : α) → Decidable (j ∈ s)\nf f' g : α → β\nt : Set α\n⊢ EqOn (s.piecewise f f') g t ↔ EqOn f g (t ∩ s) ∧ EqOn f' g (t ∩ sᶜ)",
"usedConstants": [
"Eq.mpr",
"False",
"Set.piecewise_eq_of_notMem",
"eq_false",
"and_true",
... | by
simp only [EqOn, ← forall_and]
refine forall_congr' fun a => ?_; by_cases a ∈ s <;> simp [*] | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Data.Set.Piecewise | {
"line": 157,
"column": 55
} | {
"line": 157,
"column": 63
} | [
{
"pp": "case h\nα : Type u_1\nβ : Type u_2\ns : Set α\ninst✝ : (j : α) → Decidable (j ∈ s)\nf g : α → β\nx : α\nhx : x ∈ s\n⊢ s.piecewise f g x = f x",
"usedConstants": [
"congrArg",
"Set.piecewise_eq_of_mem",
"True",
"eq_self",
"of_eq_true",
"congrFun'",
"Set.piec... | simp_all | Lean.Elab.Tactic.evalSimpAll | Lean.Parser.Tactic.simpAll |
Mathlib.Data.Set.Piecewise | {
"line": 157,
"column": 55
} | {
"line": 157,
"column": 63
} | [
{
"pp": "case h\nα : Type u_1\nβ : Type u_2\ns : Set α\ninst✝ : (j : α) → Decidable (j ∈ s)\nf g : α → β\nx : α\nhx : x ∈ sᶜ\n⊢ s.piecewise f g x = g x",
"usedConstants": [
"False",
"Set.piecewise_eq_of_notMem",
"eq_false",
"congrArg",
"Compl.compl",
"Membership.mem",
... | simp_all | Lean.Elab.Tactic.evalSimpAll | Lean.Parser.Tactic.simpAll |
Mathlib.Algebra.Group.Units.Defs | {
"line": 148,
"column": 9
} | {
"line": 148,
"column": 70
} | [
{
"pp": "α : Type u\ninst✝ : Monoid α\nu₁ u₂ : αˣ\n⊢ ↑u₁ * ↑u₂ * (u₂.inv * u₁.inv) = 1",
"usedConstants": [
"Units.val",
"Eq.mpr",
"MulOne.toOne",
"Semigroup.toMul",
"HMul.hMul",
"Monoid.toMulOneClass",
"congrArg",
"mul_assoc",
"id",
"MulOne.toMul"... | rw [mul_assoc, ← mul_assoc u₂.val, val_inv, one_mul, val_inv] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.Algebra.Group.Units.Defs | {
"line": 148,
"column": 9
} | {
"line": 148,
"column": 70
} | [
{
"pp": "α : Type u\ninst✝ : Monoid α\nu₁ u₂ : αˣ\n⊢ ↑u₁ * ↑u₂ * (u₂.inv * u₁.inv) = 1",
"usedConstants": [
"Units.val",
"Eq.mpr",
"MulOne.toOne",
"Semigroup.toMul",
"HMul.hMul",
"Monoid.toMulOneClass",
"congrArg",
"mul_assoc",
"id",
"MulOne.toMul"... | rw [mul_assoc, ← mul_assoc u₂.val, val_inv, one_mul, val_inv] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Algebra.Group.Units.Defs | {
"line": 148,
"column": 9
} | {
"line": 148,
"column": 70
} | [
{
"pp": "α : Type u\ninst✝ : Monoid α\nu₁ u₂ : αˣ\n⊢ ↑u₁ * ↑u₂ * (u₂.inv * u₁.inv) = 1",
"usedConstants": [
"Units.val",
"Eq.mpr",
"MulOne.toOne",
"Semigroup.toMul",
"HMul.hMul",
"Monoid.toMulOneClass",
"congrArg",
"mul_assoc",
"id",
"MulOne.toMul"... | rw [mul_assoc, ← mul_assoc u₂.val, val_inv, one_mul, val_inv] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Algebra.Group.Basic | {
"line": 821,
"column": 67
} | {
"line": 821,
"column": 90
} | [
{
"pp": "G : Type u_3\ninst✝ : Group G\na : G\nn : ℤ\n⊢ a ^ (1 + n) = a * a ^ n",
"usedConstants": [
"Eq.mpr",
"zpow_add",
"HMul.hMul",
"Monoid.toMulOneClass",
"congrArg",
"DivInvMonoid.toZPow",
"zpow_one",
"id",
"MulOne.toMul",
"DivInvMonoid.toMon... | rw [zpow_add, zpow_one] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.Algebra.Group.Basic | {
"line": 821,
"column": 67
} | {
"line": 821,
"column": 90
} | [
{
"pp": "G : Type u_3\ninst✝ : Group G\na : G\nn : ℤ\n⊢ a ^ (1 + n) = a * a ^ n",
"usedConstants": [
"Eq.mpr",
"zpow_add",
"HMul.hMul",
"Monoid.toMulOneClass",
"congrArg",
"DivInvMonoid.toZPow",
"zpow_one",
"id",
"MulOne.toMul",
"DivInvMonoid.toMon... | rw [zpow_add, zpow_one] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Algebra.Group.Basic | {
"line": 821,
"column": 67
} | {
"line": 821,
"column": 90
} | [
{
"pp": "G : Type u_3\ninst✝ : Group G\na : G\nn : ℤ\n⊢ a ^ (1 + n) = a * a ^ n",
"usedConstants": [
"Eq.mpr",
"zpow_add",
"HMul.hMul",
"Monoid.toMulOneClass",
"congrArg",
"DivInvMonoid.toZPow",
"zpow_one",
"id",
"MulOne.toMul",
"DivInvMonoid.toMon... | rw [zpow_add, zpow_one] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Algebra.GroupWithZero.Basic | {
"line": 417,
"column": 2
} | {
"line": 417,
"column": 35
} | [
{
"pp": "case neg\nG₀ : Type u_2\ninst✝ : GroupWithZero G₀\na : G₀\nh : ¬a = 0\n⊢ a⁻¹ * a * a = a",
"usedConstants": [
"Eq.mpr",
"GroupWithZero.toMonoidWithZero",
"MulOne.toOne",
"DivInvMonoid.toInv",
"GroupWithZero.toDivisionMonoid",
"HMul.hMul",
"GroupWithZero.toD... | · rw [inv_mul_cancel₀ h, one_mul] | Lean.Elab.Tactic.evalTacticCDot | Lean.cdot |
Mathlib.Algebra.GroupWithZero.Hom | {
"line": 228,
"column": 39
} | {
"line": 228,
"column": 47
} | [
{
"pp": "case pos\nF : Type u_1\nα : Type u_2\nβ : Type u_3\nγ : Type u_4\nδ : Type u_5\nM₀✝ : Type u_6\ninst✝⁹ : MulZeroOneClass α\ninst✝⁸ : MulZeroOneClass β\ninst✝⁷ : MulZeroOneClass γ\ninst✝⁶ : MulZeroOneClass δ\ninst✝⁵ : FunLike F α β\nM₀ : Type u_7\nN₀ : Type u_8\ninst✝⁴ : MulZeroOneClass M₀\ninst✝³ : Mul... | simp_all | Lean.Elab.Tactic.evalSimpAll | Lean.Parser.Tactic.simpAll |
Mathlib.Algebra.GroupWithZero.Hom | {
"line": 228,
"column": 39
} | {
"line": 228,
"column": 47
} | [
{
"pp": "case neg\nF : Type u_1\nα : Type u_2\nβ : Type u_3\nγ : Type u_4\nδ : Type u_5\nM₀✝ : Type u_6\ninst✝⁹ : MulZeroOneClass α\ninst✝⁸ : MulZeroOneClass β\ninst✝⁷ : MulZeroOneClass γ\ninst✝⁶ : MulZeroOneClass δ\ninst✝⁵ : FunLike F α β\nM₀ : Type u_7\nN₀ : Type u_8\ninst✝⁴ : MulZeroOneClass M₀\ninst✝³ : Mul... | simp_all | Lean.Elab.Tactic.evalSimpAll | Lean.Parser.Tactic.simpAll |
Mathlib.Algebra.GroupWithZero.Hom | {
"line": 228,
"column": 39
} | {
"line": 228,
"column": 47
} | [
{
"pp": "case pos\nF : Type u_1\nα : Type u_2\nβ : Type u_3\nγ : Type u_4\nδ : Type u_5\nM₀✝ : Type u_6\ninst✝⁹ : MulZeroOneClass α\ninst✝⁸ : MulZeroOneClass β\ninst✝⁷ : MulZeroOneClass γ\ninst✝⁶ : MulZeroOneClass δ\ninst✝⁵ : FunLike F α β\nM₀ : Type u_7\nN₀ : Type u_8\ninst✝⁴ : MulZeroOneClass M₀\ninst✝³ : Mul... | simp_all | Lean.Elab.Tactic.evalSimpAll | Lean.Parser.Tactic.simpAll |
Mathlib.Algebra.GroupWithZero.Hom | {
"line": 228,
"column": 39
} | {
"line": 228,
"column": 47
} | [
{
"pp": "case neg\nF : Type u_1\nα : Type u_2\nβ : Type u_3\nγ : Type u_4\nδ : Type u_5\nM₀✝ : Type u_6\ninst✝⁹ : MulZeroOneClass α\ninst✝⁸ : MulZeroOneClass β\ninst✝⁷ : MulZeroOneClass γ\ninst✝⁶ : MulZeroOneClass δ\ninst✝⁵ : FunLike F α β\nM₀ : Type u_7\nN₀ : Type u_8\ninst✝⁴ : MulZeroOneClass M₀\ninst✝³ : Mul... | simp_all | Lean.Elab.Tactic.evalSimpAll | Lean.Parser.Tactic.simpAll |
Mathlib.Algebra.GroupWithZero.Hom | {
"line": 228,
"column": 39
} | {
"line": 228,
"column": 47
} | [
{
"pp": "case pos\nF : Type u_1\nα : Type u_2\nβ : Type u_3\nγ : Type u_4\nδ : Type u_5\nM₀✝ : Type u_6\ninst✝⁹ : MulZeroOneClass α\ninst✝⁸ : MulZeroOneClass β\ninst✝⁷ : MulZeroOneClass γ\ninst✝⁶ : MulZeroOneClass δ\ninst✝⁵ : FunLike F α β\nM₀ : Type u_7\nN₀ : Type u_8\ninst✝⁴ : MulZeroOneClass M₀\ninst✝³ : Mul... | simp_all | Lean.Elab.Tactic.evalSimpAll | Lean.Parser.Tactic.simpAll |
Mathlib.Algebra.GroupWithZero.Hom | {
"line": 228,
"column": 39
} | {
"line": 228,
"column": 47
} | [
{
"pp": "case neg\nF : Type u_1\nα : Type u_2\nβ : Type u_3\nγ : Type u_4\nδ : Type u_5\nM₀✝ : Type u_6\ninst✝⁹ : MulZeroOneClass α\ninst✝⁸ : MulZeroOneClass β\ninst✝⁷ : MulZeroOneClass γ\ninst✝⁶ : MulZeroOneClass δ\ninst✝⁵ : FunLike F α β\nM₀ : Type u_7\nN₀ : Type u_8\ninst✝⁴ : MulZeroOneClass M₀\ninst✝³ : Mul... | simp_all | Lean.Elab.Tactic.evalSimpAll | Lean.Parser.Tactic.simpAll |
Mathlib.Algebra.GroupWithZero.Hom | {
"line": 228,
"column": 39
} | {
"line": 228,
"column": 47
} | [
{
"pp": "case pos\nF : Type u_1\nα : Type u_2\nβ : Type u_3\nγ : Type u_4\nδ : Type u_5\nM₀✝ : Type u_6\ninst✝⁹ : MulZeroOneClass α\ninst✝⁸ : MulZeroOneClass β\ninst✝⁷ : MulZeroOneClass γ\ninst✝⁶ : MulZeroOneClass δ\ninst✝⁵ : FunLike F α β\nM₀ : Type u_7\nN₀ : Type u_8\ninst✝⁴ : MulZeroOneClass M₀\ninst✝³ : Mul... | simp_all | Lean.Elab.Tactic.evalSimpAll | Lean.Parser.Tactic.simpAll |
Mathlib.Algebra.GroupWithZero.Hom | {
"line": 228,
"column": 39
} | {
"line": 228,
"column": 47
} | [
{
"pp": "case neg\nF : Type u_1\nα : Type u_2\nβ : Type u_3\nγ : Type u_4\nδ : Type u_5\nM₀✝ : Type u_6\ninst✝⁹ : MulZeroOneClass α\ninst✝⁸ : MulZeroOneClass β\ninst✝⁷ : MulZeroOneClass γ\ninst✝⁶ : MulZeroOneClass δ\ninst✝⁵ : FunLike F α β\nM₀ : Type u_7\nN₀ : Type u_8\ninst✝⁴ : MulZeroOneClass M₀\ninst✝³ : Mul... | simp_all | Lean.Elab.Tactic.evalSimpAll | Lean.Parser.Tactic.simpAll |
Mathlib.Algebra.GroupWithZero.Action.Defs | {
"line": 218,
"column": 6
} | {
"line": 218,
"column": 15
} | [
{
"pp": "M₀ : Type u_2\nA : Type u_7\ninst✝³ : MonoidWithZero M₀\ninst✝² : Zero A\ninst✝¹ : MulActionWithZero M₀ A\np : Prop\ninst✝ : Decidable p\na : M₀\nb : A\n⊢ (if p then a else 0) • b = if p then a • b else 0",
"usedConstants": [
"Eq.mpr",
"instHSMul",
"congrArg",
"SMulWithZero.... | ite_smul, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Algebra.GroupWithZero.Action.Defs | {
"line": 224,
"column": 20
} | {
"line": 224,
"column": 29
} | [
{
"pp": "M₀ : Type u_2\nA : Type u_7\ninst✝³ : MonoidWithZero M₀\ninst✝² : Zero A\ninst✝¹ : MulActionWithZero M₀ A\nι : Type u_12\ninst✝ : DecidableEq ι\nx : A\ni j : ι\n⊢ (if j = i then 1 else 0) • x = single i x j",
"usedConstants": [
"Eq.mpr",
"MulOne.toOne",
"instHSMul",
"congrAr... | ite_smul, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Data.List.TFAE | {
"line": 44,
"column": 8
} | {
"line": 44,
"column": 37
} | [
{
"pp": "case head.tail\na b : Prop\nl : List Prop\nh : b ∈ l\nab : a ↔ b\nH : l.TFAE\nq : Prop\nhq : Mem q l\n⊢ a ↔ q",
"usedConstants": [
"Iff.trans"
]
},
{
"pp": "case tail.head\na b : Prop\nl : List Prop\nh : b ∈ l\nab : a ↔ b\nH : l.TFAE\np : Prop\nhp : Mem p l\n⊢ p ↔ a",
"usedCon... | · exact ab.trans (H _ h _ hq) | Lean.Elab.Tactic.evalTacticCDot | Lean.cdot |
Mathlib.Algebra.Ring.Basic | {
"line": 186,
"column": 2
} | {
"line": 186,
"column": 100
} | [
{
"pp": "R : Type u_3\ninst✝ : NonUnitalNonAssocRing R\nr : R\n⊢ IsRegular r ↔ (∀ (x : R), r * x = 0 → x = 0) ∧ ∀ (x : R), x * r = 0 → x = 0",
"usedConstants": [
"Eq.mpr",
"HMul.hMul",
"congrArg",
"isRegular_iff",
"Iff.rfl",
"IsRegular",
"NonUnitalNonAssocSemiring.t... | rw [isRegular_iff, isLeftRegular_iff_right_eq_zero_of_mul, isRightRegular_iff_left_eq_zero_of_mul] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.Algebra.Ring.Basic | {
"line": 186,
"column": 2
} | {
"line": 186,
"column": 100
} | [
{
"pp": "R : Type u_3\ninst✝ : NonUnitalNonAssocRing R\nr : R\n⊢ IsRegular r ↔ (∀ (x : R), r * x = 0 → x = 0) ∧ ∀ (x : R), x * r = 0 → x = 0",
"usedConstants": [
"Eq.mpr",
"HMul.hMul",
"congrArg",
"isRegular_iff",
"Iff.rfl",
"IsRegular",
"NonUnitalNonAssocSemiring.t... | rw [isRegular_iff, isLeftRegular_iff_right_eq_zero_of_mul, isRightRegular_iff_left_eq_zero_of_mul] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Algebra.Ring.Basic | {
"line": 186,
"column": 2
} | {
"line": 186,
"column": 100
} | [
{
"pp": "R : Type u_3\ninst✝ : NonUnitalNonAssocRing R\nr : R\n⊢ IsRegular r ↔ (∀ (x : R), r * x = 0 → x = 0) ∧ ∀ (x : R), x * r = 0 → x = 0",
"usedConstants": [
"Eq.mpr",
"HMul.hMul",
"congrArg",
"isRegular_iff",
"Iff.rfl",
"IsRegular",
"NonUnitalNonAssocSemiring.t... | rw [isRegular_iff, isLeftRegular_iff_right_eq_zero_of_mul, isRightRegular_iff_left_eq_zero_of_mul] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Algebra.Ring.Basic | {
"line": 290,
"column": 39
} | {
"line": 290,
"column": 65
} | [
{
"pp": "R : Type u_1\ninst✝¹ : DivisionMonoid R\ninst✝ : HasDistribNeg R\n⊢ (-1)⁻¹ = -1",
"usedConstants": [
"Eq.mpr",
"InvOneClass.toOne",
"DivInvOneMonoid.toInvOneClass",
"inv_one",
"Monoid.toMulOneClass",
"congrArg",
"DivisionMonoid.toDivInvOneMonoid",
"id... | by rw [← neg_inv, inv_one] | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Algebra.GroupWithZero.Units.Basic | {
"line": 502,
"column": 88
} | {
"line": 503,
"column": 39
} | [
{
"pp": "G₀ : Type u_3\ninst✝ : CommGroupWithZero G₀\na : G₀\nha : a ≠ 0\nb c : G₀\n⊢ a / b * (c / a) = c / b",
"usedConstants": [
"CommMonoidWithZero.toCommMonoid",
"Eq.mpr",
"GroupWithZero.toMonoidWithZero",
"instHDiv",
"HMul.hMul",
"GroupWithZero.toDivInvMonoid",
... | by
rw [mul_comm, div_mul_div_cancel₀ ha] | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Algebra.Ring.Commute | {
"line": 49,
"column": 39
} | {
"line": 49,
"column": 57
} | [
{
"pp": "R : Type u\ninst✝ : NonUnitalNonAssocRing R\na b : R\nh : Commute a b\n⊢ a * a - b * b = a * a - b * a + (b * a - b * b)",
"usedConstants": [
"Eq.mpr",
"sub_add_sub_cancel",
"HMul.hMul",
"congrArg",
"AddMonoid.toAddZeroClass",
"NonUnitalNonAssocRing.toAddCommGrou... | sub_add_sub_cancel | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Algebra.Ring.Commute | {
"line": 53,
"column": 39
} | {
"line": 53,
"column": 57
} | [
{
"pp": "R : Type u\ninst✝ : NonUnitalNonAssocRing R\na b : R\nh : Commute a b\n⊢ a * a - b * b = a * a - b * a + (b * a - b * b)",
"usedConstants": [
"Eq.mpr",
"sub_add_sub_cancel",
"HMul.hMul",
"congrArg",
"AddMonoid.toAddZeroClass",
"NonUnitalNonAssocRing.toAddCommGrou... | sub_add_sub_cancel | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Algebra.Ring.Commute | {
"line": 141,
"column": 13
} | {
"line": 141,
"column": 54
} | [
{
"pp": "R : Type u\ninst✝¹ : Monoid R\ninst✝ : HasDistribNeg R\nn : ℕ\nh : (-1) ^ n = -1\n⊢ (-1) ^ (n + 1) = 1",
"usedConstants": [
"Eq.mpr",
"MulOne.toOne",
"HMul.hMul",
"Monoid.toMulOneClass",
"congrArg",
"pow_succ",
"neg_one_mul",
"neg_neg",
"id",
... | by rw [pow_succ, h, neg_one_mul, neg_neg] | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Algebra.Ring.Parity | {
"line": 191,
"column": 2
} | {
"line": 191,
"column": 73
} | [
{
"pp": "α : Type u_2\ninst✝¹ : Monoid α\ninst✝ : HasDistribNeg α\nn : ℕ\n⊢ Odd n → ∀ (a : α), (-a) ^ n = -a ^ n",
"usedConstants": [
"Eq.mpr",
"NonAssocSemiring.toAddCommMonoidWithOne",
"HMul.hMul",
"Monoid.toMulOneClass",
"congrArg",
"Odd",
"pow_add",
"neg_s... | rintro ⟨c, rfl⟩ a; simp_rw [pow_add, pow_mul, neg_sq, pow_one, mul_neg] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Algebra.Ring.Parity | {
"line": 191,
"column": 2
} | {
"line": 191,
"column": 73
} | [
{
"pp": "α : Type u_2\ninst✝¹ : Monoid α\ninst✝ : HasDistribNeg α\nn : ℕ\n⊢ Odd n → ∀ (a : α), (-a) ^ n = -a ^ n",
"usedConstants": [
"Eq.mpr",
"NonAssocSemiring.toAddCommMonoidWithOne",
"HMul.hMul",
"Monoid.toMulOneClass",
"congrArg",
"Odd",
"pow_add",
"neg_s... | rintro ⟨c, rfl⟩ a; simp_rw [pow_add, pow_mul, neg_sq, pow_one, mul_neg] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Algebra.Order.Monoid.Unbundled.Basic | {
"line": 307,
"column": 6
} | {
"line": 307,
"column": 22
} | [
{
"pp": "α : Type u_1\ninst✝³ : Mul α\ninst✝² : PartialOrder α\ninst✝¹ : MulLeftStrictMono α\ninst✝ : MulRightStrictMono α\na b c d : α\nhac : a ≤ c\nhbd : b ≤ d\nthis✝ : MulLeftMono α\nthis : MulRightMono α\n⊢ a * b = c * d ↔ a = c ∧ b = d",
"usedConstants": [
"Eq.mpr",
"HMul.hMul",
"cong... | le_antisymm_iff, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Algebra.Order.Monoid.Unbundled.Basic | {
"line": 307,
"column": 64
} | {
"line": 307,
"column": 92
} | [
{
"pp": "α : Type u_1\ninst✝³ : Mul α\ninst✝² : PartialOrder α\ninst✝¹ : MulLeftStrictMono α\ninst✝ : MulRightStrictMono α\na b c d : α\nhac : a ≤ c\nhbd : b ≤ d\nthis✝ : MulLeftMono α\nthis : MulRightMono α\n⊢ c * d ≤ a * b ↔ a = c ∧ b = d",
"usedConstants": [
"Eq.mpr",
"mul_le_mul_iff_of_ge",
... | mul_le_mul_iff_of_ge hac hbd | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Algebra.Order.Group.Unbundled.Basic | {
"line": 360,
"column": 2
} | {
"line": 360,
"column": 40
} | [
{
"pp": "α : Type u\ninst✝² : CommGroup α\ninst✝¹ : LE α\ninst✝ : MulLeftMono α\na b c : α\n⊢ a * b⁻¹ ≤ c ↔ a ≤ b * c",
"usedConstants": [
"Eq.mpr",
"HMul.hMul",
"DivisionCommMonoid.toDivisionMonoid",
"CommMonoid.toCommSemigroup",
"DivInvOneMonoid.toInvOneClass",
"Monoid.... | rw [← inv_mul_le_iff_le_mul, mul_comm] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.Algebra.Order.Group.Unbundled.Basic | {
"line": 360,
"column": 2
} | {
"line": 360,
"column": 40
} | [
{
"pp": "α : Type u\ninst✝² : CommGroup α\ninst✝¹ : LE α\ninst✝ : MulLeftMono α\na b c : α\n⊢ a * b⁻¹ ≤ c ↔ a ≤ b * c",
"usedConstants": [
"Eq.mpr",
"HMul.hMul",
"DivisionCommMonoid.toDivisionMonoid",
"CommMonoid.toCommSemigroup",
"DivInvOneMonoid.toInvOneClass",
"Monoid.... | rw [← inv_mul_le_iff_le_mul, mul_comm] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Algebra.Order.Group.Unbundled.Basic | {
"line": 360,
"column": 2
} | {
"line": 360,
"column": 40
} | [
{
"pp": "α : Type u\ninst✝² : CommGroup α\ninst✝¹ : LE α\ninst✝ : MulLeftMono α\na b c : α\n⊢ a * b⁻¹ ≤ c ↔ a ≤ b * c",
"usedConstants": [
"Eq.mpr",
"HMul.hMul",
"DivisionCommMonoid.toDivisionMonoid",
"CommMonoid.toCommSemigroup",
"DivInvOneMonoid.toInvOneClass",
"Monoid.... | rw [← inv_mul_le_iff_le_mul, mul_comm] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Algebra.Order.Group.Unbundled.Basic | {
"line": 498,
"column": 53
} | {
"line": 499,
"column": 69
} | [
{
"pp": "α : Type u\ninst✝² : Group α\ninst✝¹ : LE α\ninst✝ : MulRightMono α\na b c : α\n⊢ a / c ≤ b ↔ a ≤ b * c",
"usedConstants": [
"Eq.mpr",
"DivInvMonoid.toInv",
"instHDiv",
"HMul.hMul",
"Monoid.toMulOneClass",
"congrArg",
"mul_le_mul_iff_right",
"Iff.rfl"... | by
rw [← mul_le_mul_iff_right c, div_eq_mul_inv, inv_mul_cancel_right] | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Order.RelIso.Basic | {
"line": 459,
"column": 4
} | {
"line": 461,
"column": 71
} | [
{
"pp": "case refine_1\nα : Type u_1\nβ : Type u_2\nγ : Type u_3\nδ : Type u_4\nr : α → α → Prop\ns : β → β → Prop\nt : γ → γ → Prop\nu : δ → δ → Prop\ninst✝¹ : Std.Trichotomous r\ninst✝ : Std.Asymm s\nf : α → β\nH : ∀ (a b : α), r a b → s (f a) (f b)\nthis : Std.Irrefl s\na b : α\ne : f a = f b\n⊢ a = b",
... | apply Std.Trichotomous.trichotomous (r := r) a b
· exact fun h => irrefl (r := s) (f a) (by simpa [e] using H _ _ h)
· exact fun h => irrefl (r := s) (f b) (by simpa [e] using H _ _ h) | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Order.RelIso.Basic | {
"line": 459,
"column": 4
} | {
"line": 461,
"column": 71
} | [
{
"pp": "case refine_1\nα : Type u_1\nβ : Type u_2\nγ : Type u_3\nδ : Type u_4\nr : α → α → Prop\ns : β → β → Prop\nt : γ → γ → Prop\nu : δ → δ → Prop\ninst✝¹ : Std.Trichotomous r\ninst✝ : Std.Asymm s\nf : α → β\nH : ∀ (a b : α), r a b → s (f a) (f b)\nthis : Std.Irrefl s\na b : α\ne : f a = f b\n⊢ a = b",
... | apply Std.Trichotomous.trichotomous (r := r) a b
· exact fun h => irrefl (r := s) (f a) (by simpa [e] using H _ _ h)
· exact fun h => irrefl (r := s) (f b) (by simpa [e] using H _ _ h) | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Algebra.Order.Ring.Unbundled.Basic | {
"line": 706,
"column": 8
} | {
"line": 706,
"column": 24
} | [
{
"pp": "R : Type u\ninst✝⁵ : Semiring R\ninst✝⁴ : LinearOrder R\ninst✝³ : ExistsAddOfLE R\ninst✝² : PosMulMono R\ninst✝¹ : AddLeftMono R\ninst✝ : NoZeroDivisors R\nr : R\n⊢ r ^ 2 ≤ 0 ↔ r ^ 2 = 0",
"usedConstants": [
"Eq.mpr",
"congrArg",
"PartialOrder.toPreorder",
"Preorder.toLE",
... | le_antisymm_iff, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Algebra.Order.GroupWithZero.Unbundled.Basic | {
"line": 978,
"column": 2
} | {
"line": 978,
"column": 45
} | [
{
"pp": "G₀ : Type u_3\ninst✝³ : GroupWithZero G₀\ninst✝² : PartialOrder G₀\ninst✝¹ : PosMulReflectLT G₀\na : G₀\ninst✝ : ZeroLEOneClass G₀\nha₀ : 0 < a\nha₁ : a < 1\n⊢ StrictAnti fun n ↦ a ^ n",
"usedConstants": [
"GroupWithZero.toDivInvMonoid",
"PartialOrder.toPreorder",
"DivInvMonoid.to... | refine strictAnti_int_of_succ_lt fun n ↦ ?_ | Lean.Elab.Tactic.evalRefine | Lean.Parser.Tactic.refine |
Mathlib.Algebra.Order.GroupWithZero.Unbundled.Basic | {
"line": 1190,
"column": 10
} | {
"line": 1190,
"column": 37
} | [
{
"pp": "case ha\nG₀ : Type u_3\ninst✝² : GroupWithZero G₀\ninst✝¹ : PartialOrder G₀\ninst✝ : MulPosReflectLT G₀\na b c : G₀\nhab : a ≤ b\nhc : 0 ≤ c\n⊢ 0 ≤ c⁻¹",
"usedConstants": [
"Iff.mpr",
"GroupWithZero.toMonoidWithZero",
"GroupWithZero.toDivisionMonoid",
"DivInvOneMonoid.toInvO... | exact Right.inv_nonneg.2 hc | Lean.Elab.Tactic.evalExact | Lean.Parser.Tactic.exact |
Mathlib.Algebra.Order.GroupWithZero.Unbundled.Basic | {
"line": 1194,
"column": 2
} | {
"line": 1195,
"column": 54
} | [
{
"pp": "G₀ : Type u_3\ninst✝² : GroupWithZero G₀\ninst✝¹ : PartialOrder G₀\ninst✝ : MulPosReflectLT G₀\na b c : G₀\nh : a < b\nhc : 0 < c\n⊢ a / c < b / c",
"usedConstants": [
"Iff.mpr",
"Eq.mpr",
"GroupWithZero.toMonoidWithZero",
"DivInvMonoid.toInv",
"Preorder.toLT",
"... | rw [div_eq_mul_inv a c, div_eq_mul_inv b c]
exact mul_lt_mul_of_pos_right h (Right.inv_pos.2 hc) | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Algebra.Order.GroupWithZero.Unbundled.Basic | {
"line": 1194,
"column": 2
} | {
"line": 1195,
"column": 54
} | [
{
"pp": "G₀ : Type u_3\ninst✝² : GroupWithZero G₀\ninst✝¹ : PartialOrder G₀\ninst✝ : MulPosReflectLT G₀\na b c : G₀\nh : a < b\nhc : 0 < c\n⊢ a / c < b / c",
"usedConstants": [
"Iff.mpr",
"Eq.mpr",
"GroupWithZero.toMonoidWithZero",
"DivInvMonoid.toInv",
"Preorder.toLT",
"... | rw [div_eq_mul_inv a c, div_eq_mul_inv b c]
exact mul_lt_mul_of_pos_right h (Right.inv_pos.2 hc) | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Algebra.Order.GroupWithZero.Unbundled.Basic | {
"line": 1304,
"column": 2
} | {
"line": 1304,
"column": 79
} | [
{
"pp": "G₀ : Type u_3\ninst✝² : GroupWithZero G₀\ninst✝¹ : LinearOrder G₀\na : G₀\ninst✝ : PosMulMono G₀\n⊢ a⁻¹ ≤ 0 ↔ a ≤ 0",
"usedConstants": [
"GroupWithZero.toMonoidWithZero",
"Preorder.toLT",
"GroupWithZero.toDivisionMonoid",
"DivInvOneMonoid.toInvOneClass",
"MulZeroClass.... | have := PosMulMono.toPosMulReflectLT (α := G₀); simp only [← not_lt, inv_pos] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Algebra.Order.GroupWithZero.Unbundled.Basic | {
"line": 1304,
"column": 2
} | {
"line": 1304,
"column": 79
} | [
{
"pp": "G₀ : Type u_3\ninst✝² : GroupWithZero G₀\ninst✝¹ : LinearOrder G₀\na : G₀\ninst✝ : PosMulMono G₀\n⊢ a⁻¹ ≤ 0 ↔ a ≤ 0",
"usedConstants": [
"GroupWithZero.toMonoidWithZero",
"Preorder.toLT",
"GroupWithZero.toDivisionMonoid",
"DivInvOneMonoid.toInvOneClass",
"MulZeroClass.... | have := PosMulMono.toPosMulReflectLT (α := G₀); simp only [← not_lt, inv_pos] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Algebra.Order.Group.Unbundled.Abs | {
"line": 171,
"column": 32
} | {
"line": 171,
"column": 51
} | [
{
"pp": "α : Type u_1\ninst✝² : Lattice α\ninst✝¹ : CommGroup α\ninst✝ : MulLeftMono α\na b c : α\nthis : DistribLattice α := CommGroup.toDistribLattice α\n⊢ (b ⊔ (a ⊔ c)) / (b ⊓ a ⊔ c) * (((b ⊔ a) ⊓ c) / (b ⊓ (c ⊓ (a ⊓ c)))) =\n (b ⊔ (a ⊔ c)) / (b ⊓ a ⊔ c) * (((b ⊔ a) ⊓ c) / (b ⊓ a ⊓ c))",
"usedConstant... | inf_comm c (a ⊓ c), | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Data.Int.GCD | {
"line": 296,
"column": 20
} | {
"line": 296,
"column": 28
} | [
{
"pp": "case pos\nα : Type u_1\ninst✝ : GroupWithZero α\na b : α\nm n : ℕ\nhab : Commute a b\nhmn : m.Coprime n\nh : a ^ m = b ^ n\nh✝ : m = 0\n⊢ ∃ c, a = c ^ n ∧ b = c ^ m",
"usedConstants": [
"Nat.Coprime",
"GroupWithZero.toMonoidWithZero",
"MulOne.toOne",
"and_true",
"Monoi... | simp_all | Lean.Elab.Tactic.evalSimpAll | Lean.Parser.Tactic.simpAll |
Mathlib.Data.Int.GCD | {
"line": 296,
"column": 20
} | {
"line": 296,
"column": 28
} | [
{
"pp": "case pos\nα : Type u_1\ninst✝ : GroupWithZero α\na b : α\nm n : ℕ\nhab : Commute a b\nhmn : m.Coprime n\nh : a ^ m = b ^ n\nh✝ : m = 0\n⊢ ∃ c, a = c ^ n ∧ b = c ^ m",
"usedConstants": [
"Nat.Coprime",
"GroupWithZero.toMonoidWithZero",
"MulOne.toOne",
"and_true",
"Monoi... | simp_all | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Data.Int.GCD | {
"line": 296,
"column": 20
} | {
"line": 296,
"column": 28
} | [
{
"pp": "case pos\nα : Type u_1\ninst✝ : GroupWithZero α\na b : α\nm n : ℕ\nhab : Commute a b\nhmn : m.Coprime n\nh : a ^ m = b ^ n\nh✝ : m = 0\n⊢ ∃ c, a = c ^ n ∧ b = c ^ m",
"usedConstants": [
"Nat.Coprime",
"GroupWithZero.toMonoidWithZero",
"MulOne.toOne",
"and_true",
"Monoi... | simp_all | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Data.Int.GCD | {
"line": 297,
"column": 20
} | {
"line": 297,
"column": 28
} | [
{
"pp": "case pos\nα : Type u_1\ninst✝ : GroupWithZero α\na b : α\nm n : ℕ\nhab : Commute a b\nhmn : m.Coprime n\nh : a ^ m = b ^ n\nh✝¹ : ¬m = 0\nh✝ : n = 0\n⊢ ∃ c, a = c ^ n ∧ b = c ^ m",
"usedConstants": [
"Nat.Coprime",
"GroupWithZero.toMonoidWithZero",
"MulOne.toOne",
"Monoid.to... | simp_all | Lean.Elab.Tactic.evalSimpAll | Lean.Parser.Tactic.simpAll |
Mathlib.Data.Int.GCD | {
"line": 297,
"column": 20
} | {
"line": 297,
"column": 28
} | [
{
"pp": "case pos\nα : Type u_1\ninst✝ : GroupWithZero α\na b : α\nm n : ℕ\nhab : Commute a b\nhmn : m.Coprime n\nh : a ^ m = b ^ n\nh✝¹ : ¬m = 0\nh✝ : n = 0\n⊢ ∃ c, a = c ^ n ∧ b = c ^ m",
"usedConstants": [
"Nat.Coprime",
"GroupWithZero.toMonoidWithZero",
"MulOne.toOne",
"Monoid.to... | simp_all | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Data.Int.GCD | {
"line": 297,
"column": 20
} | {
"line": 297,
"column": 28
} | [
{
"pp": "case pos\nα : Type u_1\ninst✝ : GroupWithZero α\na b : α\nm n : ℕ\nhab : Commute a b\nhmn : m.Coprime n\nh : a ^ m = b ^ n\nh✝¹ : ¬m = 0\nh✝ : n = 0\n⊢ ∃ c, a = c ^ n ∧ b = c ^ m",
"usedConstants": [
"Nat.Coprime",
"GroupWithZero.toMonoidWithZero",
"MulOne.toOne",
"Monoid.to... | simp_all | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Data.Int.GCD | {
"line": 298,
"column": 38
} | {
"line": 298,
"column": 46
} | [
{
"pp": "α : Type u_1\ninst✝ : GroupWithZero α\na b : α\nm n : ℕ\nhab : Commute a b\nhmn : m.Coprime n\nh : a ^ m = b ^ n\nh✝¹ : ¬m = 0\nh✝ : ¬n = 0\nhb : b = 0\n⊢ a = 0 ^ n ∧ b = 0 ^ m",
"usedConstants": [
"GroupWithZero.toMonoidWithZero",
"False",
"eq_false",
"congrArg",
"and... | simp_all | Lean.Elab.Tactic.evalSimpAll | Lean.Parser.Tactic.simpAll |
Mathlib.Data.Int.GCD | {
"line": 298,
"column": 38
} | {
"line": 298,
"column": 46
} | [
{
"pp": "α : Type u_1\ninst✝ : GroupWithZero α\na b : α\nm n : ℕ\nhab : Commute a b\nhmn : m.Coprime n\nh : a ^ m = b ^ n\nh✝¹ : ¬m = 0\nh✝ : ¬n = 0\nhb : b = 0\n⊢ a = 0 ^ n ∧ b = 0 ^ m",
"usedConstants": [
"GroupWithZero.toMonoidWithZero",
"False",
"eq_false",
"congrArg",
"and... | simp_all | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Data.Int.GCD | {
"line": 298,
"column": 38
} | {
"line": 298,
"column": 46
} | [
{
"pp": "α : Type u_1\ninst✝ : GroupWithZero α\na b : α\nm n : ℕ\nhab : Commute a b\nhmn : m.Coprime n\nh : a ^ m = b ^ n\nh✝¹ : ¬m = 0\nh✝ : ¬n = 0\nhb : b = 0\n⊢ a = 0 ^ n ∧ b = 0 ^ m",
"usedConstants": [
"GroupWithZero.toMonoidWithZero",
"False",
"eq_false",
"congrArg",
"and... | simp_all | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Data.Int.GCD | {
"line": 299,
"column": 54
} | {
"line": 299,
"column": 62
} | [
{
"pp": "α : Type u_1\ninst✝ : GroupWithZero α\na b : α\nm n : ℕ\nhab : Commute a b\nhmn : m.Coprime n\nh : a ^ m = b ^ n\nh✝¹ : ¬m = 0\nh✝ : ¬n = 0\nhb : ¬b = 0\nha : a = 0\nthis : b ^ n = a ^ m\n⊢ a = 0 ^ n ∧ b = 0 ^ m",
"usedConstants": [
"GroupWithZero.toMonoidWithZero",
"False",
"eq_f... | simp_all | Lean.Elab.Tactic.evalSimpAll | Lean.Parser.Tactic.simpAll |
Mathlib.Algebra.Order.Ring.Int | {
"line": 74,
"column": 2
} | {
"line": 75,
"column": 55
} | [
{
"pp": "case succ.zero\nn p : ℕ\ndvd : (p + 1).gcd 0 ∣ n\nle : (p + 1).pred * pred 0 ≤ n\n⊢ ∃ a b, a * (p + 1) + b * 0 = n",
"usedConstants": [
"Nat.gcd",
"Eq.mpr",
"Nat.instMulZeroClass",
"Dvd.dvd",
"HMul.hMul",
"Nat.gcd_zero_right",
"CommSemiring.toNonUnitalCommS... | · have ⟨a, eq⟩ := p.gcd_zero_right ▸ dvd
exact ⟨a, 0, by simpa [mul_comm, eq_comm] using eq⟩ | Lean.Elab.Tactic.evalTacticCDot | Lean.cdot |
Mathlib.Algebra.Order.Monoid.Canonical.Defs | {
"line": 154,
"column": 4
} | {
"line": 157,
"column": 16
} | [
{
"pp": "case h.mp\nα : Type u\ninst✝³ : MulOneClass α\ninst✝² : PartialOrder α\ninst✝¹ : CanonicallyOrderedMul α\na : α\ninst✝ : MulLeftStrictMono α\nc : α\n⊢ a ≠ a * c → 1 < c",
"usedConstants": [
"Eq.mpr",
"MulOne.toOne",
"Preorder.toLT",
"HMul.hMul",
"instIsBotOneClass",
... | rw [one_lt_iff_ne_one]
apply mt
rintro rfl
rw [mul_one] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Algebra.Order.Monoid.Canonical.Defs | {
"line": 154,
"column": 4
} | {
"line": 157,
"column": 16
} | [
{
"pp": "case h.mp\nα : Type u\ninst✝³ : MulOneClass α\ninst✝² : PartialOrder α\ninst✝¹ : CanonicallyOrderedMul α\na : α\ninst✝ : MulLeftStrictMono α\nc : α\n⊢ a ≠ a * c → 1 < c",
"usedConstants": [
"Eq.mpr",
"MulOne.toOne",
"Preorder.toLT",
"HMul.hMul",
"instIsBotOneClass",
... | rw [one_lt_iff_ne_one]
apply mt
rintro rfl
rw [mul_one] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Algebra.Order.Monoid.Canonical.Defs | {
"line": 223,
"column": 2
} | {
"line": 227,
"column": 19
} | [
{
"pp": "α : Type u\ninst✝² : Monoid α\ninst✝¹ : LinearOrder α\ninst✝ : CanonicallyOrderedMul α\na b c : α\n⊢ min a (b * c) = min a (min a b * min a c)",
"usedConstants": [
"HMul.hMul",
"Monoid.toMulOneClass",
"congrArg",
"inf_of_le_left",
"PartialOrder.toPreorder",
"Preo... | rcases le_total a b with hb | hb
· simp [hb, le_mul_right]
· rcases le_total a c with hc | hc
· simp [hc, le_mul_left]
· simp [hb, hc] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Algebra.Order.Monoid.Canonical.Defs | {
"line": 223,
"column": 2
} | {
"line": 227,
"column": 19
} | [
{
"pp": "α : Type u\ninst✝² : Monoid α\ninst✝¹ : LinearOrder α\ninst✝ : CanonicallyOrderedMul α\na b c : α\n⊢ min a (b * c) = min a (min a b * min a c)",
"usedConstants": [
"HMul.hMul",
"Monoid.toMulOneClass",
"congrArg",
"inf_of_le_left",
"PartialOrder.toPreorder",
"Preo... | rcases le_total a b with hb | hb
· simp [hb, le_mul_right]
· rcases le_total a c with hc | hc
· simp [hc, le_mul_left]
· simp [hb, hc] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Algebra.GroupWithZero.WithZero | {
"line": 315,
"column": 41
} | {
"line": 315,
"column": 49
} | [
{
"pp": "case isTrue\nα : Type u_1\nβ : Type u_2\nγ : Type u_3\ninst✝² : Group α\nG : Type u_4\ninst✝¹ : GroupWithZero G\ninst✝ : DecidablePred fun a ↦ a = 0\nx✝ : G\nh✝ : x✝ = 0\n⊢ recZeroCoe 0 Units.val 0 = x✝",
"usedConstants": [
"GroupWithZero.toMonoidWithZero",
"congrArg",
"MonoidWith... | simp_all | Lean.Elab.Tactic.evalSimpAll | Lean.Parser.Tactic.simpAll |
Mathlib.Algebra.GroupWithZero.WithZero | {
"line": 315,
"column": 41
} | {
"line": 315,
"column": 49
} | [
{
"pp": "case isFalse\nα : Type u_1\nβ : Type u_2\nγ : Type u_3\ninst✝² : Group α\nG : Type u_4\ninst✝¹ : GroupWithZero G\ninst✝ : DecidablePred fun a ↦ a = 0\nx✝ : G\nh✝ : ¬x✝ = 0\n⊢ recZeroCoe 0 Units.val ↑(Units.mk0 x✝ h✝) = x✝",
"usedConstants": [
"eq_self",
"of_eq_true",
"Eq"
]
... | simp_all | Lean.Elab.Tactic.evalSimpAll | Lean.Parser.Tactic.simpAll |
Mathlib.Algebra.Order.AddGroupWithTop | {
"line": 116,
"column": 60
} | {
"line": 117,
"column": 46
} | [
{
"pp": "α : Type u_2\ninst✝ : LinearOrderedAddCommGroupWithTop α\na : α\nha : a ≠ ⊤\n⊢ -a + a = 0",
"usedConstants": [
"congrArg",
"AddMonoid.toAddZeroClass",
"AddMonoid.toZero",
"AddZeroClass.toAddZero",
"add_comm",
"LinearOrderedAddCommGroupWithTop.toSubNegMonoid",
... | by
simp [add_comm, add_neg_cancel_of_ne_top ha] | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Algebra.Order.Monoid.Unbundled.WithTop | {
"line": 185,
"column": 2
} | {
"line": 188,
"column": 53
} | [
{
"pp": "α : Type u\ninst✝³ : Add α\nw x y z : WithTop α\ninst✝² : Preorder α\ninst✝¹ : AddLeftStrictMono α\ninst✝ : AddRightStrictMono α\nxz : x < z\nyw : y < w\n⊢ x + y < z + w",
"usedConstants": [
"Preorder.toLT",
"instReflLe",
"WithTop.instPreorder",
"congrArg",
"LT.lt.ne_t... | apply (WithTop.add_lt_add_left xz.ne_top yw).trans_le
cases w
· simp
· exact (WithTop.add_lt_add_right coe_ne_top xz).le | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Algebra.Order.Monoid.Unbundled.WithTop | {
"line": 185,
"column": 2
} | {
"line": 188,
"column": 53
} | [
{
"pp": "α : Type u\ninst✝³ : Add α\nw x y z : WithTop α\ninst✝² : Preorder α\ninst✝¹ : AddLeftStrictMono α\ninst✝ : AddRightStrictMono α\nxz : x < z\nyw : y < w\n⊢ x + y < z + w",
"usedConstants": [
"Preorder.toLT",
"instReflLe",
"WithTop.instPreorder",
"congrArg",
"LT.lt.ne_t... | apply (WithTop.add_lt_add_left xz.ne_top yw).trans_le
cases w
· simp
· exact (WithTop.add_lt_add_right coe_ne_top xz).le | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Algebra.Order.Sub.Unbundled.Basic | {
"line": 47,
"column": 11
} | {
"line": 47,
"column": 27
} | [
{
"pp": "α : Type u_1\ninst✝⁵ : AddCommSemigroup α\ninst✝⁴ : PartialOrder α\ninst✝³ : ExistsAddOfLE α\ninst✝² : AddLeftMono α\ninst✝¹ : Sub α\ninst✝ : OrderedSub α\na b c : α\nh1 : c ≤ a\nh2 : c ≤ b\n⊢ a - c = b - c ↔ a = b",
"usedConstants": [
"Eq.mpr",
"congrArg",
"PartialOrder.toPreorde... | le_antisymm_iff, | Mathlib.Tactic._aux_Mathlib_Tactic_SimpRw___elabRules_Mathlib_Tactic_tacticSimp_rw____1 | null |
Mathlib.Algebra.Order.Sub.Unbundled.Basic | {
"line": 73,
"column": 4
} | {
"line": 74,
"column": 33
} | [
{
"pp": "α : Type u_1\ninst✝⁵ : AddCommSemigroup α\ninst✝⁴ : PartialOrder α\ninst✝³ : ExistsAddOfLE α\ninst✝² : AddLeftMono α\ninst✝¹ : Sub α\ninst✝ : OrderedSub α\na b c : α\nhc : AddLECancellable c\nh : c ≤ b\n⊢ a = b - c → a + c = b",
"usedConstants": [
"HSub.hSub",
"tsub_add_cancel_of_le",
... | rintro rfl
exact tsub_add_cancel_of_le h | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Algebra.Order.Sub.Unbundled.Basic | {
"line": 73,
"column": 4
} | {
"line": 74,
"column": 33
} | [
{
"pp": "α : Type u_1\ninst✝⁵ : AddCommSemigroup α\ninst✝⁴ : PartialOrder α\ninst✝³ : ExistsAddOfLE α\ninst✝² : AddLeftMono α\ninst✝¹ : Sub α\ninst✝ : OrderedSub α\na b c : α\nhc : AddLECancellable c\nh : c ≤ b\n⊢ a = b - c → a + c = b",
"usedConstants": [
"HSub.hSub",
"tsub_add_cancel_of_le",
... | rintro rfl
exact tsub_add_cancel_of_le h | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Algebra.Order.Sub.Unbundled.Basic | {
"line": 139,
"column": 2
} | {
"line": 140,
"column": 60
} | [
{
"pp": "α : Type u_1\ninst✝⁶ : AddCommSemigroup α\ninst✝⁵ : PartialOrder α\ninst✝⁴ : ExistsAddOfLE α\ninst✝³ : AddLeftMono α\ninst✝² : Sub α\ninst✝¹ : OrderedSub α\na b c : α\ninst✝ : AddLeftReflectLT α\nhb : AddLECancellable b\nhca : c ≤ a\nh : a - b < a - c\n⊢ c < b",
"usedConstants": [
"Preorder.t... | conv_lhs at h => rw [← tsub_add_cancel_of_le hca]
exact lt_of_add_lt_add_left (hb.lt_add_of_tsub_lt_right h) | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Algebra.Order.Sub.Unbundled.Basic | {
"line": 139,
"column": 2
} | {
"line": 140,
"column": 60
} | [
{
"pp": "α : Type u_1\ninst✝⁶ : AddCommSemigroup α\ninst✝⁵ : PartialOrder α\ninst✝⁴ : ExistsAddOfLE α\ninst✝³ : AddLeftMono α\ninst✝² : Sub α\ninst✝¹ : OrderedSub α\na b c : α\ninst✝ : AddLeftReflectLT α\nhb : AddLECancellable b\nhca : c ≤ a\nh : a - b < a - c\n⊢ c < b",
"usedConstants": [
"Preorder.t... | conv_lhs at h => rw [← tsub_add_cancel_of_le hca]
exact lt_of_add_lt_add_left (hb.lt_add_of_tsub_lt_right h) | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Algebra.Order.Sub.Basic | {
"line": 74,
"column": 11
} | {
"line": 74,
"column": 27
} | [
{
"pp": "α : Type u_1\ninst✝⁴ : AddCommMonoid α\ninst✝³ : PartialOrder α\ninst✝² : CanonicallyOrderedAdd α\ninst✝¹ : Sub α\ninst✝ : OrderedSub α\na b c : α\nha : AddLECancellable a\nhb : AddLECancellable b\nhc : AddLECancellable c\nhba : b ≤ a\nhca : c ≤ a\n⊢ a - b = a - c ↔ b = c",
"usedConstants": [
... | le_antisymm_iff, | Mathlib.Tactic._aux_Mathlib_Tactic_SimpRw___elabRules_Mathlib_Tactic_tacticSimp_rw____1 | null |
Mathlib.Algebra.Order.Sub.Basic | {
"line": 74,
"column": 61
} | {
"line": 74,
"column": 93
} | [
{
"pp": "α : Type u_1\ninst✝⁴ : AddCommMonoid α\ninst✝³ : PartialOrder α\ninst✝² : CanonicallyOrderedAdd α\ninst✝¹ : Sub α\ninst✝ : OrderedSub α\na b c : α\nha : AddLECancellable a\nhb : AddLECancellable b\nhc : AddLECancellable c\nhba : b ≤ a\nhca : c ≤ a\n⊢ a - b ≤ a - c ∧ b ≤ c ↔ b ≤ c ∧ c ≤ b",
"usedCon... | ha.tsub_le_tsub_iff_left hc hca, | Mathlib.Tactic._aux_Mathlib_Tactic_SimpRw___elabRules_Mathlib_Tactic_tacticSimp_rw____1 | null |
Mathlib.Algebra.Order.Ring.Cast | {
"line": 96,
"column": 4
} | {
"line": 97,
"column": 32
} | [
{
"pp": "R : Type u_1\ninst✝² : Ring R\ninst✝¹ : LinearOrder R\ninst✝ : IsStrictOrderedRing R\nx : R\nn : ℤ\nhx : |x| ≤ 1\nhn : 0 < n\n⊢ 0 ≤ x + ↑n",
"usedConstants": [
"Int.cast",
"NegZeroClass.toNeg",
"Int.cast_one_le_of_pos",
"Ring.toNonAssocRing",
"AddGroupWithOne.toAddGrou... | have := _root_.add_le_add (neg_le_of_abs_le hx) (cast_one_le_of_pos hn)
rwa [neg_add_cancel] at this | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Algebra.Order.Ring.Cast | {
"line": 96,
"column": 4
} | {
"line": 97,
"column": 32
} | [
{
"pp": "R : Type u_1\ninst✝² : Ring R\ninst✝¹ : LinearOrder R\ninst✝ : IsStrictOrderedRing R\nx : R\nn : ℤ\nhx : |x| ≤ 1\nhn : 0 < n\n⊢ 0 ≤ x + ↑n",
"usedConstants": [
"Int.cast",
"NegZeroClass.toNeg",
"Int.cast_one_le_of_pos",
"Ring.toNonAssocRing",
"AddGroupWithOne.toAddGrou... | have := _root_.add_le_add (neg_le_of_abs_le hx) (cast_one_le_of_pos hn)
rwa [neg_add_cancel] at this | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Data.Nat.Find | {
"line": 155,
"column": 8
} | {
"line": 155,
"column": 31
} | [
{
"pp": "case refine_2\nn : ℕ\np : ℕ → Prop\ninst✝ : DecidablePred p\nhₘ : ∃ m, p (m + n)\nhₙ : ∃ n, p n\nhn : n ≤ Nat.find hₙ\n⊢ Nat.find hₙ ≤ Nat.find hₘ + n",
"usedConstants": [
"Eq.mpr",
"congrArg",
"PartialOrder.toPreorder",
"HSub.hSub",
"Preorder.toLE",
"Nat.sub_le_... | ← Nat.sub_le_iff_le_add | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Order.WithBot | {
"line": 454,
"column": 14
} | {
"line": 454,
"column": 22
} | [
{
"pp": "case bot\nα : Type u_1\na : α\ninst✝ : LE α\nx : α\nh : ↑x ≤ ⊥\n⊢ unbotD a ↑x ≤ unbotD a ⊥",
"usedConstants": [
"False",
"WithBot.some",
"WithBot",
"False.elim",
"WithBot.coe_ne_bot._simp_3",
"Eq.mp",
"Bot.bot",
"LE.le",
"WithBot.le_bot_iff._sim... | simp_all | Lean.Elab.Tactic.evalSimpAll | Lean.Parser.Tactic.simpAll |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.