module string | startPos dict | endPos dict | nextStartPos dict | goals list | goalsAfter list | ppTac string | elaborator string | kind string |
|---|---|---|---|---|---|---|---|---|
Mathlib.Order.Basic | {
"line": 1053,
"column": 2
} | {
"line": 1053,
"column": 38
} | {
"line": 1054,
"column": 2
} | [
{
"pp": "case inl.inr\nα : Type u_2\ninst✝ : LinearOrder α\nh : ∀ ⦃x y z : α⦄, x < y → y < z → False\nx y z : α\nhne : x ≠ y ∧ y ≠ z ∧ x ≠ z\nh₁ : x < y\nh₂ : z < y\n⊢ False",
"ppTerm": "?inl.inr",
"assigned": true,
"usedConstants": [
"False",
"Preorder.toLT",
"PartialOrder.toPreor... | [
"case inl.inr.inl\nα : Type u_2\ninst✝ : LinearOrder α\nh : ∀ ⦃x y z : α⦄, x < y → y < z → False\nx y z : α\nhne : x ≠ y ∧ y ≠ z ∧ x ≠ z\nh₁ : x < y\nh₂ : z < y\nh₃ : x < z\n⊢ False",
"case inl.inr.inr\nα : Type u_2\ninst✝ : LinearOrder α\nh : ∀ ⦃x y z : α⦄, x < y → y < z → False\nx y z : α\nhne : x ≠ y ∧ y ≠ z ∧... | rcases hne.2.2.lt_or_gt with h₃ | h₃ | _private.Lean.Elab.Tactic.RCases.0.Lean.Elab.Tactic.RCases.evalRCases | Lean.Parser.Tactic.rcases |
Mathlib.Order.Basic | {
"line": 1053,
"column": 2
} | {
"line": 1053,
"column": 38
} | {
"line": 1054,
"column": 2
} | [
{
"pp": "case inr.inl\nα : Type u_2\ninst✝ : LinearOrder α\nh : ∀ ⦃x y z : α⦄, x < y → y < z → False\nx y z : α\nhne : x ≠ y ∧ y ≠ z ∧ x ≠ z\nh₁ : y < x\nh₂ : y < z\n⊢ False",
"ppTerm": "?inr.inl",
"assigned": true,
"usedConstants": [
"False",
"Preorder.toLT",
"PartialOrder.toPreor... | [
"case inr.inl.inl\nα : Type u_2\ninst✝ : LinearOrder α\nh : ∀ ⦃x y z : α⦄, x < y → y < z → False\nx y z : α\nhne : x ≠ y ∧ y ≠ z ∧ x ≠ z\nh₁ : y < x\nh₂ : y < z\nh₃ : x < z\n⊢ False",
"case inr.inl.inr\nα : Type u_2\ninst✝ : LinearOrder α\nh : ∀ ⦃x y z : α⦄, x < y → y < z → False\nx y z : α\nhne : x ≠ y ∧ y ≠ z ∧... | rcases hne.2.2.lt_or_gt with h₃ | h₃ | _private.Lean.Elab.Tactic.RCases.0.Lean.Elab.Tactic.RCases.evalRCases | Lean.Parser.Tactic.rcases |
Mathlib.Order.Basic | {
"line": 1053,
"column": 2
} | {
"line": 1053,
"column": 38
} | {
"line": 1054,
"column": 2
} | [
{
"pp": "case inr.inr\nα : Type u_2\ninst✝ : LinearOrder α\nh : ∀ ⦃x y z : α⦄, x < y → y < z → False\nx y z : α\nhne : x ≠ y ∧ y ≠ z ∧ x ≠ z\nh₁ : y < x\nh₂ : z < y\n⊢ False",
"ppTerm": "?inr.inr",
"assigned": true,
"usedConstants": [
"False",
"Preorder.toLT",
"PartialOrder.toPreor... | [
"case inr.inr.inl\nα : Type u_2\ninst✝ : LinearOrder α\nh : ∀ ⦃x y z : α⦄, x < y → y < z → False\nx y z : α\nhne : x ≠ y ∧ y ≠ z ∧ x ≠ z\nh₁ : y < x\nh₂ : z < y\nh₃ : x < z\n⊢ False",
"case inr.inr.inr\nα : Type u_2\ninst✝ : LinearOrder α\nh : ∀ ⦃x y z : α⦄, x < y → y < z → False\nx y z : α\nhne : x ≠ y ∧ y ≠ z ∧... | rcases hne.2.2.lt_or_gt with h₃ | h₃ | _private.Lean.Elab.Tactic.RCases.0.Lean.Elab.Tactic.RCases.evalRCases | Lean.Parser.Tactic.rcases |
Mathlib.Order.BoundedOrder.Lattice | {
"line": 50,
"column": 54
} | {
"line": 50,
"column": 90
} | {
"line": 52,
"column": 0
} | [
{
"pp": "α : Type u_1\ninst✝¹ : SemilatticeSup α\ninst✝ : OrderBot α\na b : α\n⊢ a ⊔ b = ⊥ ↔ a = ⊥ ∧ b = ⊥",
"ppTerm": "?m.13",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"congrArg",
"OrderBot.toBot",
"PartialOrder.toPreorder",
"Preorder.toLE",
"SemilatticeSup... | [] | by rw [eq_bot_iff, sup_le_iff]; simp | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Order.Monotone.Basic | {
"line": 545,
"column": 2
} | {
"line": 546,
"column": 59
} | {
"line": 548,
"column": 0
} | [
{
"pp": "case refine_2\nα : Type u\ninst✝ : Preorder α\nf : ℕ → α\nk : ℕ\nh : MonotoneOn f {x | k ≤ x}\nx y : ℕ\nhle : x ≤ y\n⊢ (fun n ↦ f (n + k)) x ≤ (fun n ↦ f (n + k)) y",
"ppTerm": "?refine_2",
"assigned": true,
"usedConstants": [
"Nat.add_le_add_iff_right",
"congrArg",
"Nat.l... | [] | · rw [← Nat.add_le_add_iff_right] at hle
exact h (Nat.le_add_left k x) (Nat.le_add_left k y) hle | Lean.Elab.Tactic.evalTacticCDot | Lean.cdot |
Mathlib.Order.Monotone.Basic | {
"line": 659,
"column": 4
} | {
"line": 659,
"column": 28
} | {
"line": 660,
"column": 2
} | [
{
"pp": "case negSucc.zero\nα : Type u\ninst✝³ : Preorder α\ninst✝² : Nonempty α\ninst✝¹ : NoMinOrder α\ninst✝ : NoMaxOrder α\ninhabited_h : Inhabited α\nf : ℕ → α\nhf : StrictMono f\nhf₀ : f 0 = default\ng : ℕ → α\nhg : StrictAnti g\nhg₀ : g 0 = default\n⊢ g 1 < g 0",
"ppTerm": "?negSucc.zero",
"assign... | [] | exact hg Nat.zero_lt_one | Lean.Elab.Tactic.evalExact | Lean.Parser.Tactic.exact |
Mathlib.Data.Set.Basic | {
"line": 992,
"column": 2
} | {
"line": 993,
"column": 79
} | {
"line": 995,
"column": 0
} | [
{
"pp": "α : Type u\np : Prop\ninst✝ : Decidable p\nt : ¬p → Set α\nx : α\n⊢ (x ∈ if h : p then ∅ else t h) ↔ ∃ h, x ∈ t h",
"ppTerm": "?m.17",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"False",
"Set.mem_empty_iff_false._simp_1",
"congrArg",
"Membership.mem",
... | [] | simp only [mem_dite, mem_empty_iff_false, imp_false]
exact ⟨fun h => ⟨h.1, h.2 h.1⟩, fun ⟨h₁, h₂⟩ => ⟨fun h => h₁ h, fun _ => h₂⟩⟩ | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Data.Set.Basic | {
"line": 992,
"column": 2
} | {
"line": 993,
"column": 79
} | {
"line": 995,
"column": 0
} | [
{
"pp": "α : Type u\np : Prop\ninst✝ : Decidable p\nt : ¬p → Set α\nx : α\n⊢ (x ∈ if h : p then ∅ else t h) ↔ ∃ h, x ∈ t h",
"ppTerm": "?m.17",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"False",
"Set.mem_empty_iff_false._simp_1",
"congrArg",
"Membership.mem",
... | [] | simp only [mem_dite, mem_empty_iff_false, imp_false]
exact ⟨fun h => ⟨h.1, h.2 h.1⟩, fun ⟨h₁, h₂⟩ => ⟨fun h => h₁ h, fun _ => h₂⟩⟩ | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Data.Set.Insert | {
"line": 296,
"column": 86
} | {
"line": 296,
"column": 95
} | {
"line": 297,
"column": 4
} | [
{
"pp": "α : Type u_1\ns : Set α\nx : α\n⊢ s = ∅ ∧ s ≠ {x} ∨ False ↔ s = ∅",
"ppTerm": "?m.25",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"False",
"congrArg",
"Set.instSingletonSet",
"id",
"Ne",
"And",
"Iff",
"Set.instEmptyCollection",
... | [
"α : Type u_1\ns : Set α\nx : α\n⊢ s = ∅ ∧ s ≠ {x} ↔ s = ∅"
] | or_false, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Order.Heyting.Basic | {
"line": 314,
"column": 4
} | {
"line": 315,
"column": 26
} | {
"line": 317,
"column": 0
} | [
{
"pp": "α : Type u_2\ninst✝ : GeneralizedHeytingAlgebra α\na b c d : α\n⊢ d ≤ a ⊔ b ⇨ c ↔ d ≤ (a ⇨ c) ⊓ (b ⇨ c)",
"ppTerm": "?m.17",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"Lattice.toSemilatticeSup",
"le_himp_comm",
"congrArg",
"PartialOrder.toPreorder",
... | [] | rw [le_inf_iff, le_himp_comm, sup_le_iff]
simp_rw [le_himp_comm] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Order.Heyting.Basic | {
"line": 314,
"column": 4
} | {
"line": 315,
"column": 26
} | {
"line": 317,
"column": 0
} | [
{
"pp": "α : Type u_2\ninst✝ : GeneralizedHeytingAlgebra α\na b c d : α\n⊢ d ≤ a ⊔ b ⇨ c ↔ d ≤ (a ⇨ c) ⊓ (b ⇨ c)",
"ppTerm": "?m.17",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"Lattice.toSemilatticeSup",
"le_himp_comm",
"congrArg",
"PartialOrder.toPreorder",
... | [] | rw [le_inf_iff, le_himp_comm, sup_le_iff]
simp_rw [le_himp_comm] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Order.Heyting.Basic | {
"line": 375,
"column": 24
} | {
"line": 375,
"column": 59
} | {
"line": 377,
"column": 0
} | [
{
"pp": "ι : Type u_1\nα : Type u_2\nβ : Type u_3\ninst✝ : GeneralizedHeytingAlgebra α\na✝ b✝ c✝ d : α\na b c : αᵒᵈ\n⊢ toDual (ofDual b ⇨ ofDual a) ≤ c ↔ a ≤ b ⊔ c",
"ppTerm": "?m.17",
"assigned": true,
"usedConstants": [
"OrderDual.toDual",
"Eq.mpr",
"Lattice.toSemilatticeSup",
... | [] | by rw [sup_comm]; exact le_himp_iff | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Order.Heyting.Basic | {
"line": 436,
"column": 73
} | {
"line": 436,
"column": 88
} | {
"line": 436,
"column": 89
} | [
{
"pp": "α : Type u_2\ninst✝ : GeneralizedCoheytingAlgebra α\na b : α\n⊢ a ⊔ b \\ a = b ⊔ a",
"ppTerm": "?m.13",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"Lattice.toSemilatticeSup",
"congrArg",
"SemilatticeSup.toMax",
"id",
"SDiff.sdiff",
"Max.max",
... | [
"α : Type u_2\ninst✝ : GeneralizedCoheytingAlgebra α\na b : α\n⊢ a ⊔ b = b ⊔ a"
] | sup_sdiff_self, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Order.Heyting.Basic | {
"line": 475,
"column": 49
} | {
"line": 475,
"column": 64
} | {
"line": 475,
"column": 65
} | [
{
"pp": "α : Type u_2\ninst✝ : GeneralizedCoheytingAlgebra α\na b c : α\n⊢ a ≤ a \\ c ⊔ (b ⊔ c \\ b)",
"ppTerm": "?m.29",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"Lattice.toSemilatticeSup",
"congrArg",
"PartialOrder.toPreorder",
"Preorder.toLE",
"Semilattic... | [
"α : Type u_2\ninst✝ : GeneralizedCoheytingAlgebra α\na b c : α\n⊢ a ≤ a \\ c ⊔ (b ⊔ c)"
] | sup_sdiff_self, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Order.Heyting.Basic | {
"line": 767,
"column": 24
} | {
"line": 767,
"column": 59
} | {
"line": 768,
"column": 2
} | [
{
"pp": "ι : Type u_1\nα : Type u_2\nβ : Type u_3\ninst✝ : HeytingAlgebra α\na✝ b✝ : α\na b c : αᵒᵈ\n⊢ toDual (ofDual b ⇨ ofDual a) ≤ c ↔ a ≤ b ⊔ c",
"ppTerm": "?m.30",
"assigned": true,
"usedConstants": [
"OrderDual.toDual",
"Eq.mpr",
"Lattice.toSemilatticeSup",
"Equiv.instE... | [] | by rw [sup_comm]; exact le_himp_iff | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Order.Heyting.Basic | {
"line": 860,
"column": 83
} | {
"line": 860,
"column": 93
} | {
"line": 860,
"column": 93
} | [
{
"pp": "α : Type u_2\ninst✝ : CoheytingAlgebra α\na : α\n⊢ a = ⊤ ↔ ⊤ ≤ a",
"ppTerm": "?m.24",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"Lattice.toSemilatticeSup",
"congrArg",
"PartialOrder.toPreorder",
"Preorder.toLE",
"SemilatticeInf.toPartialOrder",
... | [
"α : Type u_2\ninst✝ : CoheytingAlgebra α\na : α\n⊢ a = ⊤ ↔ a = ⊤"
] | top_le_iff | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Logic.Equiv.Option | {
"line": 79,
"column": 8
} | {
"line": 79,
"column": 40
} | {
"line": 80,
"column": 8
} | [
{
"pp": "α : Type u_1\nβ : Type u_2\nγ : Type u_3\ne : Option α ≃ Option β\nx : α\nh : ¬(e (some x)).isSome = true\n⊢ (e none).isSome = true",
"ppTerm": "?m.20",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"Equiv.instEquivLike",
"congrArg",
"id",
"Equiv",
"Ne",... | [
"α : Type u_1\nβ : Type u_2\nγ : Type u_3\ne : Option α ≃ Option β\nx : α\nh : ¬(e (some x)).isSome = true\n⊢ e none ≠ none"
] | rw [← Option.ne_none_iff_isSome] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.Order.Heyting.Basic | {
"line": 1095,
"column": 2
} | {
"line": 1095,
"column": 45
} | {
"line": 1095,
"column": 46
} | [
{
"pp": "ι : Type u_1\nα : Type u_2\nβ : Type u_3\ne : α ≃ β\ninst✝ : HeytingAlgebra β\ngeneralizedHeytingAlgebra : GeneralizedHeytingAlgebra α := e.generalizedHeytingAlgebra\nbot : Bot α := e.bot\ncompl : Compl α := e.compl\n⊢ HeytingAlgebra α",
"ppTerm": "?m.18",
"assigned": true,
"usedConstants":... | [
"case le\nι : Type u_1\nα : Type u_2\nβ : Type u_3\ne : α ≃ β\ninst✝ : HeytingAlgebra β\ngeneralizedHeytingAlgebra : GeneralizedHeytingAlgebra α := e.generalizedHeytingAlgebra\nbot : Bot α := e.bot\ncompl : Compl α := e.compl\nx✝ y✝ : α\n⊢ e x✝ ≤ e y✝ ↔ x✝ ≤ y✝",
"case lt\nι : Type u_1\nα : Type u_2\nβ : Type u_3... | apply e.injective.heytingAlgebra <;> intros | Lean.Parser.Tactic.«_aux_Init_Tactics___macroRules_Lean_Parser_Tactic_tactic_<;>__1» | Lean.Parser.Tactic.«tactic_<;>_» |
Mathlib.Data.Set.Image | {
"line": 903,
"column": 4
} | {
"line": 903,
"column": 23
} | {
"line": 904,
"column": 2
} | [
{
"pp": "case mp\nα : Type u_1\nβ : Type u_2\nf : α → β\ns : Set α\nx✝ : β\nx : α\nh1 : x ∈ s\nh2 : f x = x✝\n⊢ x✝ ∈ range fun x ↦ f ↑x",
"ppTerm": "?mp",
"assigned": true,
"usedConstants": [
"Membership.mem",
"Set.Elem",
"Subtype.mk",
"Exists.intro",
"Subtype.val",
... | [] | exact ⟨⟨x, h1⟩, h2⟩ | Lean.Elab.Tactic.evalExact | Lean.Parser.Tactic.exact |
Mathlib.Algebra.Group.Hom.Defs | {
"line": 728,
"column": 4
} | {
"line": 728,
"column": 65
} | {
"line": 729,
"column": 4
} | [
{
"pp": "ι : Type u_1\nα : Type u_2\nβ : Type u_3\nM✝ : Type u_4\nN✝ : Type u_5\nP : Type u_6\nG : Type u_7\nH : Type u_8\nF : Type u_9\ninst✝⁵ : MulOne M✝\ninst✝⁴ : MulOne N✝\ninst✝³ : FunLike F M✝ N✝\ninst✝² : MonoidHomClass F M✝ N✝\nM : Type u_10\nN : Type u_11\ninst✝¹ : Monoid M\ninst✝ : RightCancelMonoid N... | [
"ι : Type u_1\nα : Type u_2\nβ : Type u_3\nM✝ : Type u_4\nN✝ : Type u_5\nP : Type u_6\nG : Type u_7\nH : Type u_8\nF : Type u_9\ninst✝⁵ : MulOne M✝\ninst✝⁴ : MulOne N✝\ninst✝³ : FunLike F M✝ N✝\ninst✝² : MonoidHomClass F M✝ N✝\nM : Type u_10\nN : Type u_11\ninst✝¹ : Monoid M\ninst✝ : RightCancelMonoid N\nf : M →ₙ* ... | have h : 1 * f 1 = f 1 * f 1 := by simpa using f.map_mul' 1 1 | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_tacticHave___1 | Lean.Parser.Tactic.tacticHave__ |
Mathlib.Data.Int.Init | {
"line": 189,
"column": 2
} | {
"line": 192,
"column": 40
} | {
"line": 194,
"column": 0
} | [
{
"pp": "a b c d m n✝ : ℤ\nmotive : ℤ → Sort u_1\nlt : (n : ℤ) → n < m → motive n\nge : (n : ℤ) → n ≥ m → ((k : ℤ) → k < n → motive k) → motive n\nn : ℤ\n⊢ motive n",
"ppTerm": "?m.10",
"assigned": true,
"usedConstants": [
"Int.strongRec._proof_6",
"HSub.hSub",
"Int",
"LE.le"... | [] | refine if hnm : n < m then lt n hnm else ge n (by lia) (n.inductionOn' m lt ?_ ?_)
· intro _n _ ih l _
exact if hlm : l < m then lt l hlm else ge l (by lia) fun k _ ↦ ih k (by lia)
· exact fun n _ hn l _ ↦ hn l (by lia) | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Data.Int.Init | {
"line": 189,
"column": 2
} | {
"line": 192,
"column": 40
} | {
"line": 194,
"column": 0
} | [
{
"pp": "a b c d m n✝ : ℤ\nmotive : ℤ → Sort u_1\nlt : (n : ℤ) → n < m → motive n\nge : (n : ℤ) → n ≥ m → ((k : ℤ) → k < n → motive k) → motive n\nn : ℤ\n⊢ motive n",
"ppTerm": "?m.10",
"assigned": true,
"usedConstants": [
"Int.strongRec._proof_6",
"HSub.hSub",
"Int",
"LE.le"... | [] | refine if hnm : n < m then lt n hnm else ge n (by lia) (n.inductionOn' m lt ?_ ?_)
· intro _n _ ih l _
exact if hlm : l < m then lt l hlm else ge l (by lia) fun k _ ↦ ih k (by lia)
· exact fun n _ hn l _ ↦ hn l (by lia) | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Algebra.Group.Basic | {
"line": 413,
"column": 41
} | {
"line": 413,
"column": 53
} | {
"line": 413,
"column": 54
} | [
{
"pp": "α : Type u_1\ninst✝ : DivisionMonoid α\na : α\nn : ℕ\n⊢ a⁻¹ * a⁻¹ ^ n = (a ^ n * a)⁻¹",
"ppTerm": "?m.58",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"HMul.hMul",
"DivInvOneMonoid.toInvOneClass",
"Monoid.toMulOneClass",
"congrArg",
"DivisionMonoid.toD... | [
"α : Type u_1\ninst✝ : DivisionMonoid α\na : α\nn : ℕ\n⊢ a⁻¹ * (a ^ n)⁻¹ = (a ^ n * a)⁻¹"
] | inv_pow _ n, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Algebra.Group.Basic | {
"line": 628,
"column": 65
} | {
"line": 628,
"column": 92
} | {
"line": 630,
"column": 0
} | [
{
"pp": "G : Type u_3\ninst✝ : Group G\na b c : G\nh : b = a⁻¹ * c\n⊢ a * b = c",
"ppTerm": "?m.13",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"DivInvMonoid.toInv",
"HMul.hMul",
"DivInvOneMonoid.toInvOneClass",
"Monoid.toMulOneClass",
"congrArg",
"Group... | [] | rw [h, mul_inv_cancel_left] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.Algebra.Group.Basic | {
"line": 628,
"column": 65
} | {
"line": 628,
"column": 92
} | {
"line": 630,
"column": 0
} | [
{
"pp": "G : Type u_3\ninst✝ : Group G\na b c : G\nh : b = a⁻¹ * c\n⊢ a * b = c",
"ppTerm": "?m.13",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"DivInvMonoid.toInv",
"HMul.hMul",
"DivInvOneMonoid.toInvOneClass",
"Monoid.toMulOneClass",
"congrArg",
"Group... | [] | rw [h, mul_inv_cancel_left] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Algebra.Group.Basic | {
"line": 628,
"column": 65
} | {
"line": 628,
"column": 92
} | {
"line": 630,
"column": 0
} | [
{
"pp": "G : Type u_3\ninst✝ : Group G\na b c : G\nh : b = a⁻¹ * c\n⊢ a * b = c",
"ppTerm": "?m.13",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"DivInvMonoid.toInv",
"HMul.hMul",
"DivInvOneMonoid.toInvOneClass",
"Monoid.toMulOneClass",
"congrArg",
"Group... | [] | rw [h, mul_inv_cancel_left] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Algebra.Group.Basic | {
"line": 665,
"column": 14
} | {
"line": 665,
"column": 41
} | {
"line": 665,
"column": 41
} | [
{
"pp": "G : Type u_3\ninst✝ : Group G\na b c : G\nh : a = b⁻¹ * c\n⊢ b * a = c",
"ppTerm": "?m.16",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"DivInvMonoid.toInv",
"HMul.hMul",
"DivInvOneMonoid.toInvOneClass",
"Monoid.toMulOneClass",
"congrArg",
"Group... | [] | rw [h, mul_inv_cancel_left] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.Algebra.Group.Basic | {
"line": 665,
"column": 14
} | {
"line": 665,
"column": 41
} | {
"line": 665,
"column": 41
} | [
{
"pp": "G : Type u_3\ninst✝ : Group G\na b c : G\nh : a = b⁻¹ * c\n⊢ b * a = c",
"ppTerm": "?m.16",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"DivInvMonoid.toInv",
"HMul.hMul",
"DivInvOneMonoid.toInvOneClass",
"Monoid.toMulOneClass",
"congrArg",
"Group... | [] | rw [h, mul_inv_cancel_left] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Algebra.Group.Basic | {
"line": 665,
"column": 14
} | {
"line": 665,
"column": 41
} | {
"line": 665,
"column": 41
} | [
{
"pp": "G : Type u_3\ninst✝ : Group G\na b c : G\nh : a = b⁻¹ * c\n⊢ b * a = c",
"ppTerm": "?m.16",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"DivInvMonoid.toInv",
"HMul.hMul",
"DivInvOneMonoid.toInvOneClass",
"Monoid.toMulOneClass",
"congrArg",
"Group... | [] | rw [h, mul_inv_cancel_left] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Algebra.Group.Basic | {
"line": 764,
"column": 23
} | {
"line": 764,
"column": 33
} | {
"line": 764,
"column": 33
} | [
{
"pp": "G : Type u_3\ninst✝ : Group G\na b c d : G\nH : a / b = c / d\n⊢ c / d = 1 ↔ c = d",
"ppTerm": "?m.18",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"instHDiv",
"InvOneClass.toOne",
"DivInvOneMonoid.toInvOneClass",
"congrArg",
"Group.toDivisionMonoid",
... | [
"G : Type u_3\ninst✝ : Group G\na b c d : G\nH : a / b = c / d\n⊢ c = d ↔ c = d"
] | div_eq_one | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Algebra.Group.Units.Defs | {
"line": 330,
"column": 29
} | {
"line": 330,
"column": 59
} | {
"line": 332,
"column": 0
} | [
{
"pp": "α : Type u\ninst✝ : Monoid α\na : α\nu : αˣ\n⊢ a * (↑u⁻¹ * ↑u) = a",
"ppTerm": "?m.18",
"assigned": true,
"usedConstants": [
"Units.val",
"Eq.mpr",
"MulOne.toOne",
"Semigroup.toMul",
"HMul.hMul",
"Monoid.toMulOneClass",
"congrArg",
"Units.inv_... | [] | by rw [Units.inv_mul, mul_one] | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Algebra.Group.Units.Basic | {
"line": 78,
"column": 15
} | {
"line": 78,
"column": 42
} | {
"line": 78,
"column": 42
} | [
{
"pp": "α : Type u\ninst✝ : Monoid α\nb : αˣ\na c : α\nh : a = ↑b⁻¹ * c\n⊢ ↑b * a = c",
"ppTerm": "?m.23",
"assigned": true,
"usedConstants": [
"Units.val",
"Eq.mpr",
"HMul.hMul",
"Monoid.toMulOneClass",
"congrArg",
"Units",
"id",
"MulOne.toMul",
... | [] | rw [h, mul_inv_cancel_left] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.Algebra.Group.Units.Basic | {
"line": 78,
"column": 15
} | {
"line": 78,
"column": 42
} | {
"line": 78,
"column": 42
} | [
{
"pp": "α : Type u\ninst✝ : Monoid α\nb : αˣ\na c : α\nh : a = ↑b⁻¹ * c\n⊢ ↑b * a = c",
"ppTerm": "?m.23",
"assigned": true,
"usedConstants": [
"Units.val",
"Eq.mpr",
"HMul.hMul",
"Monoid.toMulOneClass",
"congrArg",
"Units",
"id",
"MulOne.toMul",
... | [] | rw [h, mul_inv_cancel_left] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Algebra.Group.Units.Basic | {
"line": 78,
"column": 15
} | {
"line": 78,
"column": 42
} | {
"line": 78,
"column": 42
} | [
{
"pp": "α : Type u\ninst✝ : Monoid α\nb : αˣ\na c : α\nh : a = ↑b⁻¹ * c\n⊢ ↑b * a = c",
"ppTerm": "?m.23",
"assigned": true,
"usedConstants": [
"Units.val",
"Eq.mpr",
"HMul.hMul",
"Monoid.toMulOneClass",
"congrArg",
"Units",
"id",
"MulOne.toMul",
... | [] | rw [h, mul_inv_cancel_left] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Algebra.GroupWithZero.Basic | {
"line": 514,
"column": 22
} | {
"line": 514,
"column": 39
} | {
"line": 514,
"column": 40
} | [
{
"pp": "case pred\nG₀ : Type u_2\ninst✝ : GroupWithZero G₀\na : G₀\nha : a ≠ 0\nm : ℤ\nn : ℕ\nihn : a ^ (m + -↑n) = a ^ m * a ^ (-↑n)\n⊢ a ^ (m + (-↑n - 1)) = a ^ m * a ^ (-↑n - 1)",
"ppTerm": "?pred",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"GroupWithZero.toMonoidWithZero",
... | [
"case pred\nG₀ : Type u_2\ninst✝ : GroupWithZero G₀\na : G₀\nha : a ≠ 0\nm : ℤ\nn : ℕ\nihn : a ^ (m + -↑n) = a ^ m * a ^ (-↑n)\n⊢ a ^ (m + (-↑n - 1)) = a ^ m * (a ^ (-↑n) * a⁻¹)"
] | zpow_sub_one₀ ha, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Algebra.Group.Int.Defs | {
"line": 50,
"column": 4
} | {
"line": 50,
"column": 92
} | {
"line": 51,
"column": 2
} | [
{
"pp": "m : ℕ\nn : ℤ\n⊢ ↑m.succ • n = ↑m • n + n",
"ppTerm": "?m.57",
"assigned": true,
"usedConstants": [
"instHSMul",
"HMul.hMul",
"congrArg",
"ZSMul.mk",
"Int.one_mul",
"Int",
"Int.add_comm",
"Nat.cast",
"Int.instMul",
"ZSMul.toSMul",
... | [] | simp only [HSMul.hSMul, SMul.smul, natCast_succ, Int.add_mul, Int.add_comm, Int.one_mul] | Lean.Elab.Tactic.evalSimp | Lean.Parser.Tactic.simp |
Mathlib.Algebra.Group.Int.Defs | {
"line": 50,
"column": 4
} | {
"line": 50,
"column": 92
} | {
"line": 51,
"column": 2
} | [
{
"pp": "m : ℕ\nn : ℤ\n⊢ ↑m.succ • n = ↑m • n + n",
"ppTerm": "?m.57",
"assigned": true,
"usedConstants": [
"instHSMul",
"HMul.hMul",
"congrArg",
"ZSMul.mk",
"Int.one_mul",
"Int",
"Int.add_comm",
"Nat.cast",
"Int.instMul",
"ZSMul.toSMul",
... | [] | simp only [HSMul.hSMul, SMul.smul, natCast_succ, Int.add_mul, Int.add_comm, Int.one_mul] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Algebra.Group.Int.Defs | {
"line": 50,
"column": 4
} | {
"line": 50,
"column": 92
} | {
"line": 51,
"column": 2
} | [
{
"pp": "m : ℕ\nn : ℤ\n⊢ ↑m.succ • n = ↑m • n + n",
"ppTerm": "?m.57",
"assigned": true,
"usedConstants": [
"instHSMul",
"HMul.hMul",
"congrArg",
"ZSMul.mk",
"Int.one_mul",
"Int",
"Int.add_comm",
"Nat.cast",
"Int.instMul",
"ZSMul.toSMul",
... | [] | simp only [HSMul.hSMul, SMul.smul, natCast_succ, Int.add_mul, Int.add_comm, Int.one_mul] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Data.Int.Basic | {
"line": 44,
"column": 9
} | {
"line": 44,
"column": 18
} | {
"line": 45,
"column": 2
} | [
{
"pp": "m n✝ : ℤ\nP : ℤ → Sort u_1\nlt : (n : ℤ) → n < m → P n\nge : (n : ℤ) → n ≥ m → ((k : ℤ) → k < n → P k) → P n\nn : ℤ\nx✝ : n ≥ m\nih : ∀ (k : ℤ), k < n → ∀ (hn : m ≤ k), Int.strongRec lt ge k = ge k hn fun k_1 x ↦ Int.strongRec lt ge k_1\nhn : m ≤ n\n⊢ (Int.inductionOn' (motive := fun x ↦ (k : ℤ) → k < ... | [
"m n✝ : ℤ\nP : ℤ → Sort u_1\nlt : (n : ℤ) → n < m → P n\nge : (n : ℤ) → n ≥ m → ((k : ℤ) → k < n → P k) → P n\nn : ℤ\nx✝ : n ≥ m\nhn : m ≤ n\n⊢ (∀ (k : ℤ), k < n → ∀ (hn : m ≤ k), Int.strongRec lt ge k = ge k hn fun k_1 x ↦ Int.strongRec lt ge k_1) →\n (Int.inductionOn' (motive := fun x ↦ (k : ℤ) → k < x → P k) ... | revert ih | Lean.Elab.Tactic.evalRevert | Lean.Parser.Tactic.revert |
Mathlib.Data.Int.Basic | {
"line": 75,
"column": 58
} | {
"line": 76,
"column": 89
} | {
"line": 78,
"column": 0
} | [
{
"pp": "m : ℤ\nn : ℕ\n⊢ m ∣ ↑n ↔ m.natAbs ∣ n",
"ppTerm": "?m.5",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"Dvd.dvd",
"congrArg",
"id",
"Int.instNegInt",
"Int",
"Nat.cast",
"Or.casesOn",
"Int.instDvd",
"iff_self",
"Iff",
... | [] | by
obtain hn | hn := natAbs_eq m <;> rw [hn] <;> simp [← natCast_dvd_natCast, Int.neg_dvd] | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Algebra.Group.Int.Even | {
"line": 74,
"column": 15
} | {
"line": 74,
"column": 23
} | {
"line": 74,
"column": 23
} | [
{
"pp": "n : ℕ\n⊢ Even ↑n ↔ Even n",
"ppTerm": "?m.5",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"congrArg",
"Int.even_iff",
"id",
"instHMod",
"Int",
"Nat.cast",
"HMod.hMod",
"Iff",
"instOfNat",
"Nat",
"Even",
"propex... | [
"n : ℕ\n⊢ ↑n % 2 = 0 ↔ Even n"
] | even_iff | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Algebra.Ring.Basic | {
"line": 192,
"column": 92
} | {
"line": 199,
"column": 13
} | {
"line": 201,
"column": 0
} | [
{
"pp": "R : Type u_3\ninst✝ : NonUnitalNonAssocRing R\n⊢ [NoZeroDivisors R, IsLeftCancelMulZero R, IsRightCancelMulZero R, IsCancelMulZero R].TFAE",
"ppTerm": "?m.15",
"assigned": true,
"usedConstants": [
"Iff.mpr",
"List.IsChain.cons_cons",
"Eq.mpr",
"HMul.hMul",
"con... | [] | by
simp_rw [isLeftCancelMulZero_iff, isRightCancelMulZero_iff, isCancelMulZero_iff_forall_isRegular,
isLeftRegular_iff_right_eq_zero_of_mul, isRightRegular_iff_left_eq_zero_of_mul,
isRegular_iff_eq_zero_of_mul]
tfae_have 1 ↔ 2 := noZeroDivisors_iff_right_eq_zero_of_mul
tfae_have 1 ↔ 3 := noZeroDivisors_if... | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Algebra.Group.Commute.Units | {
"line": 150,
"column": 37
} | {
"line": 152,
"column": 22
} | {
"line": 154,
"column": 0
} | [
{
"pp": "M : Type u_1\ninst✝ : DivisionMonoid M\na b c d : M\nhbd : Commute b d\nhb : IsUnit b\nhd : IsUnit d\n⊢ a / b = c / d ↔ a * d = c * b",
"ppTerm": "?m.25",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"Semigroup.toMul",
"instHDiv",
"HMul.hMul",
"Monoid.toMulOn... | [] | by
rw [← (hb.mul hd).mul_left_inj, ← mul_assoc, hb.div_mul_cancel, ← mul_assoc, hbd.right_comm,
hd.div_mul_cancel] | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Algebra.Module.NatInt | {
"line": 119,
"column": 17
} | {
"line": 119,
"column": 79
} | {
"line": 121,
"column": 0
} | [
{
"pp": "case succ\nR : Type u_1\nM : Type u_3\ninst✝² : Semiring R\ninst✝¹ : AddCommMonoid M\ninst✝ : Module R M\nb : M\nn : ℕ\nih : ↑n • b = n • b\n⊢ ↑(n + 1) • b = (n + 1) • b",
"ppTerm": "?succ",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"NonAssocSemiring.toAddCommMonoidWithOne"... | [] | rw [Nat.cast_succ, add_smul, add_smul, one_smul, ih, one_smul] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.Algebra.Module.NatInt | {
"line": 119,
"column": 17
} | {
"line": 119,
"column": 79
} | {
"line": 121,
"column": 0
} | [
{
"pp": "case succ\nR : Type u_1\nM : Type u_3\ninst✝² : Semiring R\ninst✝¹ : AddCommMonoid M\ninst✝ : Module R M\nb : M\nn : ℕ\nih : ↑n • b = n • b\n⊢ ↑(n + 1) • b = (n + 1) • b",
"ppTerm": "?succ",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"NonAssocSemiring.toAddCommMonoidWithOne"... | [] | rw [Nat.cast_succ, add_smul, add_smul, one_smul, ih, one_smul] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Algebra.Module.NatInt | {
"line": 119,
"column": 17
} | {
"line": 119,
"column": 79
} | {
"line": 121,
"column": 0
} | [
{
"pp": "case succ\nR : Type u_1\nM : Type u_3\ninst✝² : Semiring R\ninst✝¹ : AddCommMonoid M\ninst✝ : Module R M\nb : M\nn : ℕ\nih : ↑n • b = n • b\n⊢ ↑(n + 1) • b = (n + 1) • b",
"ppTerm": "?succ",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"NonAssocSemiring.toAddCommMonoidWithOne"... | [] | rw [Nat.cast_succ, add_smul, add_smul, one_smul, ih, one_smul] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Algebra.Ring.Parity | {
"line": 282,
"column": 4
} | {
"line": 282,
"column": 9
} | {
"line": 283,
"column": 4
} | [
{
"pp": "case inl\nk : ℕ\n⊢ ∃ k_1, Xor (k + k = 2 * k_1) (k + k = 2 * k_1 + 1)",
"ppTerm": "?inl",
"assigned": true,
"usedConstants": [
"HMul.hMul",
"Xor",
"instMulNat",
"instOfNatNat",
"instHAdd",
"HAdd.hAdd",
"Nat",
"Exists.intro",
"instAddNat"... | [
"case h\nk : ℕ\n⊢ Xor (k + k = 2 * k) (k + k = 2 * k + 1)"
] | use k | Mathlib.Tactic._aux_Mathlib_Tactic_Use___elabRules_Mathlib_Tactic_useSyntax_1 | Mathlib.Tactic.useSyntax |
Mathlib.Algebra.Ring.Parity | {
"line": 282,
"column": 4
} | {
"line": 282,
"column": 9
} | {
"line": 283,
"column": 4
} | [
{
"pp": "case inr\nk : ℕ\n⊢ ∃ k_1, Xor (2 * k + 1 = 2 * k_1) (2 * k + 1 = 2 * k_1 + 1)",
"ppTerm": "?inr",
"assigned": true,
"usedConstants": [
"NonAssocSemiring.toAddCommMonoidWithOne",
"HMul.hMul",
"Xor",
"Distrib.toAdd",
"AddMonoidWithOne.toNatCast",
"Odd._proo... | [
"case h\nk : ℕ\n⊢ Xor (2 * k + 1 = 2 * k) (2 * k + 1 = 2 * k + 1)"
] | use k | Mathlib.Tactic._aux_Mathlib_Tactic_Use___elabRules_Mathlib_Tactic_useSyntax_1 | Mathlib.Tactic.useSyntax |
Mathlib.Algebra.Order.Group.Unbundled.Basic | {
"line": 101,
"column": 2
} | {
"line": 101,
"column": 51
} | {
"line": 103,
"column": 0
} | [
{
"pp": "α : Type u\ninst✝² : Group α\ninst✝¹ : LT α\ninst✝ : MulLeftStrictMono α\na b c : α\n⊢ b⁻¹ * a < c ↔ a < b * c",
"ppTerm": "?m.17",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"DivInvMonoid.toInv",
"HMul.hMul",
"DivInvOneMonoid.toInvOneClass",
"mul_lt_mul_if... | [] | rw [← mul_lt_mul_iff_left b, mul_inv_cancel_left] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.Algebra.Order.Group.Unbundled.Basic | {
"line": 101,
"column": 2
} | {
"line": 101,
"column": 51
} | {
"line": 103,
"column": 0
} | [
{
"pp": "α : Type u\ninst✝² : Group α\ninst✝¹ : LT α\ninst✝ : MulLeftStrictMono α\na b c : α\n⊢ b⁻¹ * a < c ↔ a < b * c",
"ppTerm": "?m.17",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"DivInvMonoid.toInv",
"HMul.hMul",
"DivInvOneMonoid.toInvOneClass",
"mul_lt_mul_if... | [] | rw [← mul_lt_mul_iff_left b, mul_inv_cancel_left] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Algebra.Order.Group.Unbundled.Basic | {
"line": 101,
"column": 2
} | {
"line": 101,
"column": 51
} | {
"line": 103,
"column": 0
} | [
{
"pp": "α : Type u\ninst✝² : Group α\ninst✝¹ : LT α\ninst✝ : MulLeftStrictMono α\na b c : α\n⊢ b⁻¹ * a < c ↔ a < b * c",
"ppTerm": "?m.17",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"DivInvMonoid.toInv",
"HMul.hMul",
"DivInvOneMonoid.toInvOneClass",
"mul_lt_mul_if... | [] | rw [← mul_lt_mul_iff_left b, mul_inv_cancel_left] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Algebra.Order.Ring.Unbundled.Basic | {
"line": 336,
"column": 45
} | {
"line": 336,
"column": 69
} | {
"line": 337,
"column": 2
} | [
{
"pp": "R : Type u\ninst✝³ : Semiring R\ninst✝² : LinearOrder R\na b : R\ninst✝¹ : MulPosStrictMono R\ninst✝ : PosMulStrictMono R\nhab : 0 ≤ a * b\nab : 0 ≤ a → b < 0\nnab : a ≤ 0 → 0 < b\n⊢ False",
"ppTerm": "?m.42",
"assigned": true,
"usedConstants": [
"HMul.hMul",
"PartialOrder.toPre... | [
"R : Type u\ninst✝³ : Semiring R\ninst✝² : LinearOrder R\na b : R\ninst✝¹ : MulPosStrictMono R\ninst✝ : PosMulStrictMono R\nhab : 0 ≤ a * b\nab : 0 ≤ a → b < 0\nnab : a ≤ 0 → 0 < b\n⊢ a * b < 0"
] | apply not_lt_of_ge hab _ | Lean.Elab.Tactic.evalApply | Lean.Parser.Tactic.apply |
Mathlib.Algebra.Order.GroupWithZero.Basic | {
"line": 131,
"column": 49
} | {
"line": 134,
"column": 87
} | {
"line": 134,
"column": 88
} | [
{
"pp": "α : Type u_1\ninst✝¹ : MulZeroClass α\ninst✝ : PartialOrder α\nh : CovariantClass α>0 α (fun x y ↦ y * ↑x) fun x1 x2 ↦ x1 ≤ x2\na : α\nha : 0 ≤ a\nb c : α\nhbc : b ≤ c\n⊢ b * a ≤ c * a",
"ppTerm": "?m.37",
"assigned": true,
"usedConstants": [
"LE.le.eq_or_lt",
"Preorder.toLT",
... | [] | by
obtain ha | ha := ha.eq_or_lt
· simp [← ha]
· exact @CovariantClass.elim α>0 α (fun x y => y * x) (· ≤ ·) _ ⟨_, ha⟩ _ _ hbc | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Algebra.Order.GroupWithZero.Basic | {
"line": 139,
"column": 22
} | {
"line": 142,
"column": 89
} | {
"line": 142,
"column": 90
} | [
{
"pp": "α : Type u_1\ninst✝¹ : MulZeroClass α\ninst✝ : PartialOrder α\nh✝ : ContravariantClass α>0 α (fun x y ↦ ↑x * y) fun x1 x2 ↦ x1 < x2\na : { x // 0 ≤ x }\nb c : α\nh : (fun x1 x2 ↦ x1 < x2) ((fun x y ↦ ↑x * y) a b) ((fun x y ↦ ↑x * y) a c)\n⊢ (fun x1 x2 ↦ x1 < x2) b c",
"ppTerm": "?m.34",
"assign... | [] | by
obtain ha | ha := a.prop.eq_or_lt
· simp [← ha] at h
· exact @ContravariantClass.elim α>0 α (fun x y => x * y) (· < ·) _ ⟨_, ha⟩ _ _ h | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Algebra.Order.Ring.Unbundled.Basic | {
"line": 785,
"column": 2
} | {
"line": 785,
"column": 38
} | {
"line": 787,
"column": 0
} | [
{
"pp": "R : Type u\ninst✝⁴ : Ring R\ninst✝³ : LinearOrder R\na b : R\ninst✝² : MulPosStrictMono R\ninst✝¹ : PosMulStrictMono R\ninst✝ : AddLeftMono R\nx : R\nh : a ≤ b\n⊢ b < x ∧ x < a → a < x ∧ x < b",
"ppTerm": "?m.75",
"assigned": true,
"usedConstants": [
"And.imp",
"Preorder.toLT",
... | [] | exact And.imp h.trans_lt h.trans_lt' | Lean.Elab.Tactic.evalExact | Lean.Parser.Tactic.exact |
Mathlib.Order.RelIso.Basic | {
"line": 692,
"column": 4
} | {
"line": 694,
"column": 7
} | {
"line": 694,
"column": 7
} | [
{
"pp": "α✝ : Type u_1\nβ✝ : Type u_2\nγ : Type u_3\nδ : Type u_4\nr✝ : α✝ → α✝ → Prop\ns✝ : β✝ → β✝ → Prop\nt : γ → γ → Prop\nu : δ → δ → Prop\nα β : Type u\nr : α → α → Prop\ns : β → β → Prop\nh₁ : α = β\nh₂ : r ≍ s\na b : α\n⊢ s ((Equiv.cast h₁) a) ((Equiv.cast h₁) b) ↔ r a b",
"ppTerm": "?m.16",
"as... | [] | subst h₁
rw [eq_of_heq h₂]
rfl | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Order.RelIso.Basic | {
"line": 692,
"column": 4
} | {
"line": 694,
"column": 7
} | {
"line": 694,
"column": 7
} | [
{
"pp": "α✝ : Type u_1\nβ✝ : Type u_2\nγ : Type u_3\nδ : Type u_4\nr✝ : α✝ → α✝ → Prop\ns✝ : β✝ → β✝ → Prop\nt : γ → γ → Prop\nu : δ → δ → Prop\nα β : Type u\nr : α → α → Prop\ns : β → β → Prop\nh₁ : α = β\nh₂ : r ≍ s\na b : α\n⊢ s ((Equiv.cast h₁) a) ((Equiv.cast h₁) b) ↔ r a b",
"ppTerm": "?m.16",
"as... | [] | subst h₁
rw [eq_of_heq h₂]
rfl | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Algebra.Order.GroupWithZero.Basic | {
"line": 1152,
"column": 74
} | {
"line": 1153,
"column": 47
} | {
"line": 1155,
"column": 0
} | [
{
"pp": "G₀ : Type u_3\ninst✝² : GroupWithZero G₀\ninst✝¹ : PartialOrder G₀\ninst✝ : MulPosReflectLT G₀\na b c : G₀\nhc : 0 < c\n⊢ a / c < b / c ↔ a < b",
"ppTerm": "?m.20",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"GroupWithZero.toMonoidWithZero",
"div_mul_cancel₀",
"P... | [] | by
rw [div_lt_iff₀ hc, div_mul_cancel₀ _ hc.ne'] | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Algebra.Order.Group.Lattice | {
"line": 117,
"column": 48
} | {
"line": 117,
"column": 56
} | {
"line": 117,
"column": 57
} | [
{
"pp": "α : Type u_1\ninst✝² : Lattice α\ninst✝¹ : CommGroup α\ninst✝ : MulLeftMono α\na b : α\n⊢ (a ⊓ b) * (a * b * (b⁻¹ ⊔ a⁻¹)) = (a ⊓ b) * (a * b * (a ⊓ b)⁻¹)",
"ppTerm": "?m.67",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"Lattice.toSemilatticeSup",
"HMul.hMul",
"Div... | [
"α : Type u_1\ninst✝² : Lattice α\ninst✝¹ : CommGroup α\ninst✝ : MulLeftMono α\na b : α\n⊢ (a ⊓ b) * (a * b * (b⁻¹ ⊔ a⁻¹)) = (a ⊓ b) * (a * b * (a⁻¹ ⊔ b⁻¹))"
] | inv_inf, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Algebra.Order.Monoid.Unbundled.Pow | {
"line": 40,
"column": 4
} | {
"line": 40,
"column": 47
} | {
"line": 42,
"column": 0
} | [
{
"pp": "M : Type u_3\ninst✝² : Monoid M\ninst✝¹ : Preorder M\ninst✝ : MulLeftMono M\na : M\nha : 1 ≤ a\nk : ℕ\n⊢ 1 ≤ a ^ k * a",
"ppTerm": "?m.43",
"assigned": true,
"usedConstants": [
"Monoid.toMulOneClass",
"NPow.toPow",
"HPow.hPow",
"Nat",
"Left.one_le_mul",
"... | [] | exact one_le_mul (one_le_pow_of_le ha k) ha | Lean.Elab.Tactic.evalExact | Lean.Parser.Tactic.exact |
Mathlib.Algebra.Order.Monoid.Unbundled.Pow | {
"line": 105,
"column": 13
} | {
"line": 107,
"column": 57
} | {
"line": 109,
"column": 0
} | [
{
"pp": "M : Type u_3\ninst✝² : Monoid M\ninst✝¹ : Preorder M\ninst✝ : MulRightMono M\nx : M\nhx : 1 ≤ x\nn : ℕ\n⊢ 1 ≤ x ^ (n + 1)",
"ppTerm": "?m.32",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"MulOne.toOne",
"HMul.hMul",
"Monoid.toMulOneClass",
"congrArg",
... | [] | by
rw [pow_succ]
exact Right.one_le_mul (Right.one_le_pow_of_le hx) hx | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Algebra.Order.Group.Unbundled.Int | {
"line": 97,
"column": 46
} | {
"line": 97,
"column": 97
} | {
"line": 99,
"column": 0
} | [
{
"pp": "a b : ℤ\nH1 : 0 ≤ a\nH2✝ : a < |b|\nn : ℕ\nH2 : a < ↑-[n+1].natAbs\n⊢ -(a / -[n+1]) = -0",
"ppTerm": "?m.38",
"assigned": true,
"usedConstants": [
"Int.instAddCommGroup",
"Eq.mpr",
"SubtractionMonoid.toInvolutiveNeg",
"Int.instDiv",
"instHDiv",
"congrArg"... | [] | rw [← Int.ediv_neg]; exact ediv_eq_zero_of_lt H1 H2 | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Algebra.Order.Group.Unbundled.Int | {
"line": 97,
"column": 46
} | {
"line": 97,
"column": 97
} | {
"line": 99,
"column": 0
} | [
{
"pp": "a b : ℤ\nH1 : 0 ≤ a\nH2✝ : a < |b|\nn : ℕ\nH2 : a < ↑-[n+1].natAbs\n⊢ -(a / -[n+1]) = -0",
"ppTerm": "?m.38",
"assigned": true,
"usedConstants": [
"Int.instAddCommGroup",
"Eq.mpr",
"SubtractionMonoid.toInvolutiveNeg",
"Int.instDiv",
"instHDiv",
"congrArg"... | [] | rw [← Int.ediv_neg]; exact ediv_eq_zero_of_lt H1 H2 | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Algebra.Ring.Int.Parity | {
"line": 52,
"column": 4
} | {
"line": 52,
"column": 9
} | {
"line": 53,
"column": 4
} | [
{
"pp": "case inl\nk : ℤ\n⊢ ∃ k_1, Xor (k + k = 2 * k_1) (k + k = 2 * k_1 + 1)",
"ppTerm": "?inl",
"assigned": true,
"usedConstants": [
"HMul.hMul",
"Xor",
"Int",
"Int.instMul",
"instHAdd",
"instOfNat",
"HAdd.hAdd",
"Exists.intro",
"Int.instAdd",... | [
"case h\nk : ℤ\n⊢ Xor (k + k = 2 * k) (k + k = 2 * k + 1)"
] | use k | Mathlib.Tactic._aux_Mathlib_Tactic_Use___elabRules_Mathlib_Tactic_useSyntax_1 | Mathlib.Tactic.useSyntax |
Mathlib.Algebra.Ring.Int.Parity | {
"line": 52,
"column": 4
} | {
"line": 52,
"column": 9
} | {
"line": 53,
"column": 4
} | [
{
"pp": "case inr\nk : ℤ\n⊢ ∃ k_1, Xor (2 * k + 1 = 2 * k_1) (2 * k + 1 = 2 * k_1 + 1)",
"ppTerm": "?inr",
"assigned": true,
"usedConstants": [
"NonAssocSemiring.toAddCommMonoidWithOne",
"HMul.hMul",
"Xor",
"Distrib.toAdd",
"AddMonoidWithOne.toNatCast",
"Odd._proo... | [
"case h\nk : ℤ\n⊢ Xor (2 * k + 1 = 2 * k) (2 * k + 1 = 2 * k + 1)"
] | use k | Mathlib.Tactic._aux_Mathlib_Tactic_Use___elabRules_Mathlib_Tactic_useSyntax_1 | Mathlib.Tactic.useSyntax |
Mathlib.Algebra.Order.Ring.Int | {
"line": 83,
"column": 20
} | {
"line": 83,
"column": 33
} | {
"line": 83,
"column": 34
} | [
{
"pp": "case succ.succ\nn p q : ℕ\ndvd : ∃ x y, ↑n = ↑(p + 1) * x + ↑(q + 1) * y\nle : (p + 1).pred * (q + 1).pred ≤ n\na_n b_n : ℤ\neq : ↑n = ↑(p + 1) * a_n + ↑(q + 1) * b_n\na : ℤ := a_n % ↑q.succ\nb : ℤ := b_n + a_n / ↑q.succ * ↑p.succ\nthis : a * ↑p.succ + b * ↑q.succ = ↑n\n⊢ ↑(a.toNat * (p + 1)) + ↑(b.toN... | [
"case succ.succ\nn p q : ℕ\ndvd : ∃ x y, ↑n = ↑(p + 1) * x + ↑(q + 1) * y\nle : (p + 1).pred * (q + 1).pred ≤ n\na_n b_n : ℤ\neq : ↑n = ↑(p + 1) * a_n + ↑(q + 1) * b_n\na : ℤ := a_n % ↑q.succ\nb : ℤ := b_n + a_n / ↑q.succ * ↑p.succ\nthis : a * ↑p.succ + b * ↑q.succ = ↑n\n⊢ ↑a.toNat * ↑(p + 1) + ↑(b.toNat * (q + 1))... | Nat.cast_mul, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Algebra.Order.Ring.Int | {
"line": 83,
"column": 34
} | {
"line": 83,
"column": 47
} | {
"line": 83,
"column": 48
} | [
{
"pp": "case succ.succ\nn p q : ℕ\ndvd : ∃ x y, ↑n = ↑(p + 1) * x + ↑(q + 1) * y\nle : (p + 1).pred * (q + 1).pred ≤ n\na_n b_n : ℤ\neq : ↑n = ↑(p + 1) * a_n + ↑(q + 1) * b_n\na : ℤ := a_n % ↑q.succ\nb : ℤ := b_n + a_n / ↑q.succ * ↑p.succ\nthis : a * ↑p.succ + b * ↑q.succ = ↑n\n⊢ ↑a.toNat * ↑(p + 1) + ↑(b.toNa... | [
"case succ.succ\nn p q : ℕ\ndvd : ∃ x y, ↑n = ↑(p + 1) * x + ↑(q + 1) * y\nle : (p + 1).pred * (q + 1).pred ≤ n\na_n b_n : ℤ\neq : ↑n = ↑(p + 1) * a_n + ↑(q + 1) * b_n\na : ℤ := a_n % ↑q.succ\nb : ℤ := b_n + a_n / ↑q.succ * ↑p.succ\nthis : a * ↑p.succ + b * ↑q.succ = ↑n\n⊢ ↑a.toNat * ↑(p + 1) + ↑b.toNat * ↑(q + 1) ... | Nat.cast_mul, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Algebra.Order.Monoid.Canonical.Defs | {
"line": 226,
"column": 6
} | {
"line": 226,
"column": 28
} | {
"line": 227,
"column": 4
} | [
{
"pp": "case inr.inl\nα : Type u\ninst✝² : Monoid α\ninst✝¹ : LinearOrder α\ninst✝ : CanonicallyOrderedMul α\na b c : α\nhb : b ≤ a\nhc : a ≤ c\n⊢ min a (b * c) = min a (min a b * min a c)",
"ppTerm": "?inr.inl",
"assigned": true,
"usedConstants": [
"HMul.hMul",
"Monoid.toMulOneClass",
... | [] | simp [hc, le_mul_left] | Lean.Elab.Tactic.evalSimp | Lean.Parser.Tactic.simp |
Mathlib.Algebra.Order.Monoid.Canonical.Defs | {
"line": 226,
"column": 6
} | {
"line": 226,
"column": 28
} | {
"line": 227,
"column": 4
} | [
{
"pp": "case inr.inl\nα : Type u\ninst✝² : Monoid α\ninst✝¹ : LinearOrder α\ninst✝ : CanonicallyOrderedMul α\na b c : α\nhb : b ≤ a\nhc : a ≤ c\n⊢ min a (b * c) = min a (min a b * min a c)",
"ppTerm": "?inr.inl",
"assigned": true,
"usedConstants": [
"HMul.hMul",
"Monoid.toMulOneClass",
... | [] | simp [hc, le_mul_left] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Algebra.Order.Monoid.Canonical.Defs | {
"line": 226,
"column": 6
} | {
"line": 226,
"column": 28
} | {
"line": 227,
"column": 4
} | [
{
"pp": "case inr.inl\nα : Type u\ninst✝² : Monoid α\ninst✝¹ : LinearOrder α\ninst✝ : CanonicallyOrderedMul α\na b c : α\nhb : b ≤ a\nhc : a ≤ c\n⊢ min a (b * c) = min a (min a b * min a c)",
"ppTerm": "?inr.inl",
"assigned": true,
"usedConstants": [
"HMul.hMul",
"Monoid.toMulOneClass",
... | [] | simp [hc, le_mul_left] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Order.WithBot | {
"line": 628,
"column": 63
} | {
"line": 628,
"column": 86
} | {
"line": 630,
"column": 0
} | [
{
"pp": "case coe.coe\nα : Type u_1\nβ : Type u_2\nγ : Type u_3\nδ : Type u_4\na b : α\ninst✝ : PartialOrder α\na✝¹ a✝ : α\n⊢ a✝¹ ≤ a✝ → a✝ ≤ a✝¹ → a✝¹ = a✝",
"ppTerm": "?coe.coe",
"assigned": true,
"usedConstants": [
"le_antisymm"
],
"usedFVars": [
"α",
"inst✝",
"a✝¹... | [] | simpa using le_antisymm | Lean.Elab.Tactic.Simpa.evalSimpa | Lean.Parser.Tactic.simpa |
Mathlib.Algebra.Order.Floor.Semiring | {
"line": 74,
"column": 39
} | {
"line": 74,
"column": 77
} | {
"line": 76,
"column": 0
} | [
{
"pp": "R : Type u_1\ninst✝³ : Semiring R\ninst✝² : LinearOrder R\ninst✝¹ : FloorSemiring R\ninst✝ : IsStrictOrderedRing R\n⊢ ⌊0⌋₊ = 0",
"ppTerm": "?m.14",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"NonAssocSemiring.toAddCommMonoidWithOne",
"congrArg",
"AddMonoid.toAddZ... | [] | by rw [← Nat.cast_zero, floor_natCast] | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Algebra.Order.Floor.Semiring | {
"line": 246,
"column": 9
} | {
"line": 246,
"column": 31
} | {
"line": 246,
"column": 32
} | [
{
"pp": "case inr\nR : Type u_1\ninst✝³ : Semiring R\ninst✝² : LinearOrder R\ninst✝¹ : FloorSemiring R\ninst✝ : IsStrictOrderedRing R\na b : R\nh : a < b\nh' : 0 < b\nha : a < 0\n⊢ ⌊a⌋₊ < ⌈b⌉₊",
"ppTerm": "?inr",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"congrArg",
"PartialOr... | [
"case inr\nR : Type u_1\ninst✝³ : Semiring R\ninst✝² : LinearOrder R\ninst✝¹ : FloorSemiring R\ninst✝ : IsStrictOrderedRing R\na b : R\nh : a < b\nh' : 0 < b\nha : a < 0\n⊢ 0 < ⌈b⌉₊"
] | floor_of_nonpos ha.le, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Algebra.Order.GroupWithZero.Canonical | {
"line": 594,
"column": 2
} | {
"line": 594,
"column": 27
} | {
"line": 596,
"column": 0
} | [
{
"pp": "x : WithZero (Multiplicative ℤ)\nhx : x ≠ 0\ny : WithZero (Multiplicative ℤ)\nhnz : y ≠ 0\nhyx : y < x\n⊢ -y.log ≤ ↑(-y.log).toNat",
"ppTerm": "?m.56",
"assigned": true,
"usedConstants": [
"Int.self_le_toNat",
"WithZero.log",
"Int.instNegInt",
"Int",
"AddGroup.... | [] | exact Int.self_le_toNat _ | Lean.Elab.Tactic.evalExact | Lean.Parser.Tactic.exact |
Mathlib.Algebra.Order.Floor.Semiring | {
"line": 371,
"column": 8
} | {
"line": 371,
"column": 27
} | {
"line": 371,
"column": 28
} | [
{
"pp": "case inr\nR : Type u_1\ninst✝⁶ : Semiring R\ninst✝⁵ : LinearOrder R\ninst✝⁴ : FloorSemiring R\ninst✝³ : IsStrictOrderedRing R\ninst✝² : Sub R\ninst✝¹ : OrderedSub R\ninst✝ : ExistsAddOfLE R\na : R\nn : ℕ\nhna : ↑n ≤ a\n⊢ ⌈a - ↑n⌉₊ + n = ⌈a⌉₊",
"ppTerm": "?inr",
"assigned": true,
"usedConsta... | [
"case inr\nR : Type u_1\ninst✝⁶ : Semiring R\ninst✝⁵ : LinearOrder R\ninst✝⁴ : FloorSemiring R\ninst✝³ : IsStrictOrderedRing R\ninst✝² : Sub R\ninst✝¹ : OrderedSub R\ninst✝ : ExistsAddOfLE R\na : R\nn : ℕ\nhna : ↑n ≤ a\n⊢ ⌈a - ↑n + ↑n⌉₊ = ⌈a⌉₊",
"case inr.ha\nR : Type u_1\ninst✝⁶ : Semiring R\ninst✝⁵ : LinearOrde... | ← ceil_add_natCast, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Algebra.Order.Floor.Semiring | {
"line": 420,
"column": 8
} | {
"line": 420,
"column": 30
} | {
"line": 420,
"column": 31
} | [
{
"pp": "case inl\nR : Type u_1\ninst✝⁷ : Semiring R\ninst✝⁶ : LinearOrder R\ninst✝⁵ : FloorSemiring R\na : R\nS : Type u_3\ninst✝⁴ : Semiring S\ninst✝³ : LinearOrder S\ninst✝² : FloorSemiring S\nb : S\ninst✝¹ : IsStrictOrderedRing R\ninst✝ : IsStrictOrderedRing S\nh : ∀ (n : ℕ), ↑n ≤ a ↔ ↑n ≤ b\nh₀ : 0 ≤ a ↔ 0... | [
"case inl\nR : Type u_1\ninst✝⁷ : Semiring R\ninst✝⁶ : LinearOrder R\ninst✝⁵ : FloorSemiring R\na : R\nS : Type u_3\ninst✝⁴ : Semiring S\ninst✝³ : LinearOrder S\ninst✝² : FloorSemiring S\nb : S\ninst✝¹ : IsStrictOrderedRing R\ninst✝ : IsStrictOrderedRing S\nh : ∀ (n : ℕ), ↑n ≤ a ↔ ↑n ≤ b\nh₀ : 0 ≤ a ↔ 0 ≤ b\nha : a... | floor_of_nonpos ha.le, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Algebra.Order.Floor.Semiring | {
"line": 444,
"column": 4
} | {
"line": 444,
"column": 34
} | {
"line": 445,
"column": 4
} | [
{
"pp": "R : Type u_3\ninst✝¹ : Semiring R\ninst✝ : LinearOrder R\nH₁ H₂ : FloorSemiring R\nthis : FloorSemiring.ceil = FloorSemiring.ceil\na : R\n⊢ FloorSemiring.floor a = FloorSemiring.floor a",
"ppTerm": "?m.57",
"assigned": true,
"usedConstants": [
"Preorder.toLT",
"PartialOrder.toPr... | [
"case inl\nR : Type u_3\ninst✝¹ : Semiring R\ninst✝ : LinearOrder R\nH₁ H₂ : FloorSemiring R\nthis : FloorSemiring.ceil = FloorSemiring.ceil\na : R\nh : a < 0\n⊢ FloorSemiring.floor a = FloorSemiring.floor a",
"case inr\nR : Type u_3\ninst✝¹ : Semiring R\ninst✝ : LinearOrder R\nH₁ H₂ : FloorSemiring R\nthis : Flo... | rcases lt_or_ge a 0 with h | h | _private.Lean.Elab.Tactic.RCases.0.Lean.Elab.Tactic.RCases.evalRCases | Lean.Parser.Tactic.rcases |
Mathlib.Algebra.Ring.Invertible | {
"line": 111,
"column": 39
} | {
"line": 111,
"column": 94
} | {
"line": 112,
"column": 4
} | [
{
"pp": "R : Type u_1\ninst✝³ : Ring R\na b : R\ninst✝² : Invertible a\ninst✝¹ : Invertible b\ninst✝ : Invertible (a + b)\n⊢ -2 + 1 = -2 + (2 + ⅟b * a + ⅟a * b) ↔ -2 + 1 = ⅟b * a + ⅟a * b",
"ppTerm": "?m.331",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"NegZeroClass.toNeg",
"HM... | [] | rw [← add_assoc, ← add_assoc, neg_add_cancel, zero_add] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.Algebra.Ring.Invertible | {
"line": 111,
"column": 39
} | {
"line": 111,
"column": 94
} | {
"line": 112,
"column": 4
} | [
{
"pp": "R : Type u_1\ninst✝³ : Ring R\na b : R\ninst✝² : Invertible a\ninst✝¹ : Invertible b\ninst✝ : Invertible (a + b)\n⊢ -2 + 1 = -2 + (2 + ⅟b * a + ⅟a * b) ↔ -2 + 1 = ⅟b * a + ⅟a * b",
"ppTerm": "?m.331",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"NegZeroClass.toNeg",
"HM... | [] | rw [← add_assoc, ← add_assoc, neg_add_cancel, zero_add] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Algebra.Ring.Invertible | {
"line": 111,
"column": 39
} | {
"line": 111,
"column": 94
} | {
"line": 112,
"column": 4
} | [
{
"pp": "R : Type u_1\ninst✝³ : Ring R\na b : R\ninst✝² : Invertible a\ninst✝¹ : Invertible b\ninst✝ : Invertible (a + b)\n⊢ -2 + 1 = -2 + (2 + ⅟b * a + ⅟a * b) ↔ -2 + 1 = ⅟b * a + ⅟a * b",
"ppTerm": "?m.331",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"NegZeroClass.toNeg",
"HM... | [] | rw [← add_assoc, ← add_assoc, neg_add_cancel, zero_add] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Algebra.Ring.Invertible | {
"line": 129,
"column": 2
} | {
"line": 132,
"column": 49
} | {
"line": 133,
"column": 2
} | [
{
"pp": "case pos\nR : Type u_1\ninst✝ : Semiring R\na b : R\nh : IsUnit a ↔ IsUnit b\nha : IsUnit a\n⊢ a⁻¹ʳ + b⁻¹ʳ = a⁻¹ʳ * (a + b) * b⁻¹ʳ",
"ppTerm": "?pos✝",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"NonAssocSemiring.toAddCommMonoidWithOne",
"MulOne.toOne",
"HMul.hMu... | [
"case neg\nR : Type u_1\ninst✝ : Semiring R\na b : R\nh : IsUnit a ↔ IsUnit b\nha : ¬IsUnit a\n⊢ a⁻¹ʳ + b⁻¹ʳ = a⁻¹ʳ * (a + b) * b⁻¹ʳ"
] | · have hb := h.mp ha
obtain ⟨ia⟩ := ha.nonempty_invertible
obtain ⟨ib⟩ := hb.nonempty_invertible
simp_rw [inverse_invertible, invOf_add_invOf] | Lean.Elab.Tactic.evalTacticCDot | Lean.cdot |
Mathlib.Algebra.Ring.Divisibility.Basic | {
"line": 144,
"column": 2
} | {
"line": 144,
"column": 47
} | {
"line": 146,
"column": 0
} | [
{
"pp": "α : Type u_1\ninst✝ : NonUnitalRing α\na b c : α\nh : a ∣ b\n⊢ a ∣ b - c ↔ a ∣ c",
"ppTerm": "?m.11",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"Semigroup.toMul",
"Dvd.dvd",
"congrArg",
"Iff.rfl",
"AddMonoid.toAddZeroClass",
"NonUnitalNonAssocR... | [] | rw [sub_eq_add_neg, dvd_add_right h, dvd_neg] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.Algebra.Ring.Divisibility.Basic | {
"line": 144,
"column": 2
} | {
"line": 144,
"column": 47
} | {
"line": 146,
"column": 0
} | [
{
"pp": "α : Type u_1\ninst✝ : NonUnitalRing α\na b c : α\nh : a ∣ b\n⊢ a ∣ b - c ↔ a ∣ c",
"ppTerm": "?m.11",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"Semigroup.toMul",
"Dvd.dvd",
"congrArg",
"Iff.rfl",
"AddMonoid.toAddZeroClass",
"NonUnitalNonAssocR... | [] | rw [sub_eq_add_neg, dvd_add_right h, dvd_neg] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Algebra.Ring.Divisibility.Basic | {
"line": 144,
"column": 2
} | {
"line": 144,
"column": 47
} | {
"line": 146,
"column": 0
} | [
{
"pp": "α : Type u_1\ninst✝ : NonUnitalRing α\na b c : α\nh : a ∣ b\n⊢ a ∣ b - c ↔ a ∣ c",
"ppTerm": "?m.11",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"Semigroup.toMul",
"Dvd.dvd",
"congrArg",
"Iff.rfl",
"AddMonoid.toAddZeroClass",
"NonUnitalNonAssocR... | [] | rw [sub_eq_add_neg, dvd_add_right h, dvd_neg] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Order.Antisymmetrization | {
"line": 286,
"column": 2
} | {
"line": 286,
"column": 65
} | {
"line": 288,
"column": 0
} | [
{
"pp": "α : Type u_1\ninst✝ : Preorder α\n⊢ WellFoundedLT (Antisymmetrization α fun x1 x2 ↦ x1 ≤ x2) ↔ WellFoundedLT α",
"ppTerm": "?m.8",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"Preorder.toLT",
"congrArg",
"_private.Mathlib.Order.Antisymmetrization.0.wellFoundedLT_a... | [] | simp_rw [isWellFounded_iff, wellFounded_antisymmetrization_iff] | Mathlib.Tactic._aux_Mathlib_Tactic_SimpRw___elabRules_Mathlib_Tactic_tacticSimp_rw____1 | Mathlib.Tactic.tacticSimp_rw___ |
Mathlib.Order.Antisymmetrization | {
"line": 286,
"column": 2
} | {
"line": 286,
"column": 65
} | {
"line": 288,
"column": 0
} | [
{
"pp": "α : Type u_1\ninst✝ : Preorder α\n⊢ WellFoundedLT (Antisymmetrization α fun x1 x2 ↦ x1 ≤ x2) ↔ WellFoundedLT α",
"ppTerm": "?m.8",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"Preorder.toLT",
"congrArg",
"_private.Mathlib.Order.Antisymmetrization.0.wellFoundedLT_a... | [] | simp_rw [isWellFounded_iff, wellFounded_antisymmetrization_iff] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Order.Antisymmetrization | {
"line": 286,
"column": 2
} | {
"line": 286,
"column": 65
} | {
"line": 288,
"column": 0
} | [
{
"pp": "α : Type u_1\ninst✝ : Preorder α\n⊢ WellFoundedLT (Antisymmetrization α fun x1 x2 ↦ x1 ≤ x2) ↔ WellFoundedLT α",
"ppTerm": "?m.8",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"Preorder.toLT",
"congrArg",
"_private.Mathlib.Order.Antisymmetrization.0.wellFoundedLT_a... | [] | simp_rw [isWellFounded_iff, wellFounded_antisymmetrization_iff] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Data.Set.NAry | {
"line": 323,
"column": 66
} | {
"line": 327,
"column": 45
} | {
"line": 329,
"column": 0
} | [
{
"pp": "α : Type u_1\nβ : Type u_3\nγ : Type u_5\nf : α → β → γ\ns s' : Set α\nt t' : Set β\n⊢ image2 f (s ∪ s') (t ∩ t') ⊆ image2 f s t ∪ image2 f s' t'",
"ppTerm": "?m.18",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"Set.union_subset_union",
"congrArg",
"Set.instUnion"... | [] | by
rw [image2_union_left]
exact
union_subset_union (image2_subset_left inter_subset_left)
(image2_subset_left inter_subset_right) | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Order.Interval.Set.Basic | {
"line": 678,
"column": 40
} | {
"line": 678,
"column": 62
} | {
"line": 680,
"column": 0
} | [
{
"pp": "α : Type u_1\ninst✝¹ : Preorder α\ninst✝ : OrderTop α\na : α\n⊢ Icc a ⊤ = Ici a",
"ppTerm": "?m.9",
"assigned": true,
"usedConstants": [
"Set.Ici",
"congrArg",
"Set.univ",
"Set.inter_univ",
"Preorder.toLE",
"Set.instInter",
"Set.Iic_top",
"Int... | [] | simp [← Ici_inter_Iic] | Lean.Elab.Tactic.evalSimp | Lean.Parser.Tactic.simp |
Mathlib.Order.Interval.Set.Basic | {
"line": 678,
"column": 40
} | {
"line": 678,
"column": 62
} | {
"line": 680,
"column": 0
} | [
{
"pp": "α : Type u_1\ninst✝¹ : Preorder α\ninst✝ : OrderTop α\na : α\n⊢ Icc a ⊤ = Ici a",
"ppTerm": "?m.9",
"assigned": true,
"usedConstants": [
"Set.Ici",
"congrArg",
"Set.univ",
"Set.inter_univ",
"Preorder.toLE",
"Set.instInter",
"Set.Iic_top",
"Int... | [] | simp [← Ici_inter_Iic] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Order.Interval.Set.Basic | {
"line": 678,
"column": 40
} | {
"line": 678,
"column": 62
} | {
"line": 680,
"column": 0
} | [
{
"pp": "α : Type u_1\ninst✝¹ : Preorder α\ninst✝ : OrderTop α\na : α\n⊢ Icc a ⊤ = Ici a",
"ppTerm": "?m.9",
"assigned": true,
"usedConstants": [
"Set.Ici",
"congrArg",
"Set.univ",
"Set.inter_univ",
"Preorder.toLE",
"Set.instInter",
"Set.Iic_top",
"Int... | [] | simp [← Ici_inter_Iic] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Order.Bounds.Basic | {
"line": 474,
"column": 4
} | {
"line": 474,
"column": 50
} | {
"line": 475,
"column": 2
} | [
{
"pp": "case pos\nγ : Type u_3\ninst✝ : LinearOrder γ\ni j : γ\nhj_ub : j ∈ upperBounds (Iio i)\nhj_lt_i : j < i\n⊢ ∃ j, IsLUB (Iio i) j",
"ppTerm": "?pos✝",
"assigned": true,
"usedConstants": [
"lowerBounds",
"PartialOrder.toPreorder",
"Preorder.toLE",
"Membership.mem",
... | [] | exact ⟨j, hj_ub, fun k hk_ub => hk_ub hj_lt_i⟩ | Lean.Elab.Tactic.evalExact | Lean.Parser.Tactic.exact |
Mathlib.Algebra.Order.Field.Basic | {
"line": 234,
"column": 2
} | {
"line": 240,
"column": 31
} | {
"line": 242,
"column": 0
} | [
{
"pp": "α : Type u_4\ninst✝² : Semifield α\ninst✝¹ : LinearOrder α\ninst✝ : IsStrictOrderedRing α\na b : α\nhb : 0 ≤ b\n⊢ a ≤ b ↔ ∀ (ε : α), 1 < ε → a ≤ b * ε",
"ppTerm": "?m.29",
"assigned": true,
"usedConstants": [
"Iff.mpr",
"Eq.mpr",
"GroupWithZero.toMonoidWithZero",
"No... | [] | refine ⟨fun h _ hε ↦ h.trans <| le_mul_of_one_le_right hb hε.le, fun h ↦ ?_⟩
obtain rfl | hb := hb.eq_or_lt
· simp_rw [zero_mul] at h
exact h 2 one_lt_two
refine le_of_forall_gt_imp_ge_of_dense fun x hbx => ?_
convert h (x / b) ((one_lt_div hb).mpr hbx)
rw [mul_div_cancel₀ _ hb.ne'] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Algebra.Order.Field.Basic | {
"line": 234,
"column": 2
} | {
"line": 240,
"column": 31
} | {
"line": 242,
"column": 0
} | [
{
"pp": "α : Type u_4\ninst✝² : Semifield α\ninst✝¹ : LinearOrder α\ninst✝ : IsStrictOrderedRing α\na b : α\nhb : 0 ≤ b\n⊢ a ≤ b ↔ ∀ (ε : α), 1 < ε → a ≤ b * ε",
"ppTerm": "?m.29",
"assigned": true,
"usedConstants": [
"Iff.mpr",
"Eq.mpr",
"GroupWithZero.toMonoidWithZero",
"No... | [] | refine ⟨fun h _ hε ↦ h.trans <| le_mul_of_one_le_right hb hε.le, fun h ↦ ?_⟩
obtain rfl | hb := hb.eq_or_lt
· simp_rw [zero_mul] at h
exact h 2 one_lt_two
refine le_of_forall_gt_imp_ge_of_dense fun x hbx => ?_
convert h (x / b) ((one_lt_div hb).mpr hbx)
rw [mul_div_cancel₀ _ hb.ne'] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Control.Functor | {
"line": 97,
"column": 56
} | {
"line": 97,
"column": 89
} | {
"line": 99,
"column": 0
} | [
{
"pp": "γ : Type u_1\n⊢ LawfulFunctor (Const γ)",
"ppTerm": "?m.3",
"assigned": true,
"usedConstants": [
"LawfulFunctor.mk",
"Function.comp",
"id",
"Functor.Const",
"Functor.mapConst",
"Eq.refl",
"Functor.map",
"Functor.Const.functor"
],
"used... | [] | by constructor <;> intros <;> rfl | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Data.List.Forall2 | {
"line": 200,
"column": 2
} | {
"line": 200,
"column": 23
} | {
"line": 202,
"column": 0
} | [
{
"pp": "α : Type u_1\nβ : Type u_2\nR : α → β → Prop\nl : List α\nl₁ l₂ : List β\nh : Forall₂ R l (l₁ ++ l₂)\nh' : Forall₂ R (drop l₁.length l) (drop l₁.length (l₁ ++ l₂))\n⊢ Forall₂ R (drop l₁.length l) l₂",
"ppTerm": "?m.28",
"assigned": true,
"usedConstants": [
"congrArg",
"List.drop... | [] | rwa [drop_left] at h' | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_tacticRwa___1 | Lean.Parser.Tactic.tacticRwa__ |
Mathlib.Data.List.Perm.Basic | {
"line": 202,
"column": 2
} | {
"line": 202,
"column": 22
} | {
"line": 202,
"column": 23
} | [
{
"pp": "α : Type u_1\no₁ o₂ : Option α\np : o₁.toList ~ o₂.toList\n⊢ o₁ = o₂",
"ppTerm": "?m.9",
"assigned": true,
"usedConstants": [
"Option.toList",
"Option.casesOn",
"Option.some",
"List.Perm",
"Option.none",
"Eq",
"Option"
],
"usedFVars": [
... | [
"case none\nα : Type u_1\no₂ : Option α\np : none.toList ~ o₂.toList\n⊢ none = o₂",
"case some\nα : Type u_1\no₂ : Option α\na : α\np : (some a).toList ~ o₂.toList\n⊢ some a = o₂"
] | rcases o₁ with - | a | _private.Lean.Elab.Tactic.RCases.0.Lean.Elab.Tactic.RCases.evalRCases | Lean.Parser.Tactic.rcases |
Mathlib.Data.List.Perm.Basic | {
"line": 219,
"column": 82
} | {
"line": 219,
"column": 98
} | {
"line": 219,
"column": 98
} | [
{
"pp": "α : Type u_1\nβ : Type u_2\nl l' : List α\nf : α → β\nhf : Function.Injective f\n⊢ map f l ~ map f l' ↔ Relation.Comp (fun x1 x2 ↦ x1 = map f x2) (fun x1 x2 ↦ x1 ~ x2) (map f l) l'",
"ppTerm": "?m.27",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"congrArg",
"List.map",
... | [
"α : Type u_1\nβ : Type u_2\nl l' : List α\nf : α → β\nhf : Function.Injective f\n⊢ map f l ~ map f l' ↔ (fun x1 x2 ↦ x1 ~ map f x2) (map f l) l'"
] | eq_map_comp_perm | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Data.List.Basic | {
"line": 72,
"column": 6
} | {
"line": 72,
"column": 15
} | {
"line": 72,
"column": 16
} | [
{
"pp": "α : Type u\na b c : α\n⊢ a ∈ [b, c] ↔ a = b ∨ a = c",
"ppTerm": "?m.9",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"congrArg",
"Membership.mem",
"id",
"List.cons",
"List",
"Iff",
"List.instMembership",
"propext",
"Or",
"L... | [
"α : Type u\na b c : α\n⊢ a = b ∨ a ∈ [c] ↔ a = b ∨ a = c"
] | mem_cons, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Algebra.BigOperators.Group.List.Basic | {
"line": 190,
"column": 4
} | {
"line": 190,
"column": 53
} | {
"line": 191,
"column": 4
} | [
{
"pp": "case cons\nα : Type u_2\nM : Type u_4\ninst✝¹ : Monoid M\ninst✝ : DecidableEq α\nf : α → M\na' : α\nas : List α\na : α\nh : (map f as).prod = f a ^ count a as\nhf : ∀ (a'_1 : α), a'_1 ≠ a → a'_1 ∈ a' :: as → f a'_1 = 1\n⊢ (map f (a' :: as)).prod = f a ^ count a (a' :: as)",
"ppTerm": "?cons",
"... | [
"case cons\nα : Type u_2\nM : Type u_4\ninst✝¹ : Monoid M\ninst✝ : DecidableEq α\nf : α → M\na' : α\nas : List α\na : α\nh : (map f as).prod = f a ^ count a as\nhf : ∀ (a'_1 : α), a'_1 ≠ a → a'_1 ∈ a' :: as → f a'_1 = 1\n⊢ f a' * f a ^ count a as = f a ^ (count a as + if (a' == a) = true then 1 else 0)"
] | rw [List.map_cons, List.prod_cons, count_cons, h] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.