module stringlengths 16 90 | startPos dict | endPos dict | goals listlengths 0 96 | ppTac stringlengths 1 14.5k | elaborator stringclasses 365
values | kind stringclasses 368
values |
|---|---|---|---|---|---|---|
Mathlib.Algebra.Order.Interval.Finset.SuccPred | {
"line": 56,
"column": 2
} | {
"line": 56,
"column": 70
} | [
{
"pp": "α : Type u_2\ninst✝⁴ : LinearOrder α\ninst✝³ : One α\ninst✝² : LocallyFiniteOrder α\ninst✝¹ : Add α\ninst✝ : SuccAddOrder α\na : α\nha : ¬IsMax a\nb : α\n⊢ Icc (a + 1) b = Ioc a b",
"usedConstants": [
"Order.succ",
"Order.succ_eq_add_one",
"congrArg",
"Finset.Icc_succ_left_e... | simpa [succ_eq_add_one] using Icc_succ_left_eq_Ioc_of_not_isMax ha b | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Order.SuccPred.LinearLocallyFinite | {
"line": 134,
"column": 2
} | {
"line": 134,
"column": 31
} | [
{
"pp": "ι : Type u_1\ninst✝¹ : LinearOrder ι\ninst✝ : LocallyFiniteOrder ι\ni : ι\nhi : succFn i ≤ i\nj : ι\nx✝ : i ≤ j\nhij_lt : i < j\nh_succFn_eq : succFn i = i\nh_glb : IsGLB (↑(Finset.Ioc i j)) i\nhi_mem : i ∈ Finset.Ioc i j\n⊢ False",
"usedConstants": [
"Preorder.toLT",
"congrArg",
... | rw [Finset.mem_Ioc] at hi_mem | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.Order.SuccPred.LinearLocallyFinite | {
"line": 232,
"column": 2
} | {
"line": 232,
"column": 52
} | [
{
"pp": "ι : Type u_1\ninst✝³ : LinearOrder ι\ninst✝² : SuccOrder ι\ninst✝¹ : IsSuccArchimedean ι\ninst✝ : PredOrder ι\ni0 i : ι\nhi : i0 ≤ i\n⊢ succ^[Nat.find ⋯] i0 = i",
"usedConstants": [
"Order.succ",
"LinearOrder.toDecidableEq",
"PartialOrder.toPreorder",
"SemilatticeInf.toParti... | exact Nat.find_spec (exists_succ_iterate_of_le hi) | Lean.Elab.Tactic.evalExact | Lean.Parser.Tactic.exact |
Mathlib.Algebra.Order.Antidiag.Prod | {
"line": 106,
"column": 6
} | {
"line": 106,
"column": 22
} | [
{
"pp": "A : Type u_1\ninst✝¹ : AddCancelMonoid A\ninst✝ : HasAntidiagonal A\np q : A × A\nn : A\nhp : p ∈ antidiagonal n\nhq : q ∈ antidiagonal n\nh : p.1 = q.1\n⊢ q.1 + p.2 = q.1 + q.2",
"usedConstants": [
"AddMonoid.toAddSemigroup",
"congrArg",
"Finset",
"AddCancelMonoid.toAddRigh... | mem_antidiagonal | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Algebra.Order.Antidiag.Prod | {
"line": 157,
"column": 51
} | {
"line": 160,
"column": 70
} | [
{
"pp": "A : Type u_1\ninst✝⁸ : AddCommMonoid A\ninst✝⁷ : PartialOrder A\ninst✝⁶ : CanonicallyOrderedAdd A\ninst✝⁵ : Sub A\ninst✝⁴ : OrderedSub A\ninst✝³ : AddLeftReflectLE A\ninst✝² : HasAntidiagonal A\nn m : A\ninst✝¹ : DecidablePred fun x ↦ x = m\ninst✝ : Decidable (m ≤ n)\na b : A\nthis : a = m → (a + b = n... | by
rw [mem_filter, mem_antidiagonal, apply_ite (fun n ↦ (a, b) ∈ n), mem_singleton,
Prod.mk_inj, ite_prop_iff_or]
simpa [← and_assoc, @and_right_comm _ (a = _), and_congr_left_iff] | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Order.SuccPred.LinearLocallyFinite | {
"line": 331,
"column": 4
} | {
"line": 331,
"column": 87
} | [
{
"pp": "case neg.inr.inr\nι : Type u_1\ninst✝³ : LinearOrder ι\ninst✝² : SuccOrder ι\ninst✝¹ : IsSuccArchimedean ι\ninst✝ : PredOrder ι\ni0 i j : ι\nh_le : i ≤ j\nhi_max : ¬IsMax i\nhj_min : ¬IsMin j\nhi : i < i0\nhj : j < i0\nm : ℕ := Nat.find ⋯\n⊢ toZ i0 i ≤ toZ i0 j",
"usedConstants": [
"LinearOrd... | have hm : pred^[m] j = i := Nat.find_spec (exists_pred_iterate_of_le (α := ι) h_le) | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_tacticHave___1 | Lean.Parser.Tactic.tacticHave__ |
Mathlib.Algebra.Order.Antidiag.Prod | {
"line": 172,
"column": 6
} | {
"line": 172,
"column": 30
} | [
{
"pp": "A : Type u_1\ninst✝⁸ : AddCommMonoid A\ninst✝⁷ : PartialOrder A\ninst✝⁶ : CanonicallyOrderedAdd A\ninst✝⁵ : Sub A\ninst✝⁴ : OrderedSub A\ninst✝³ : AddLeftReflectLE A\ninst✝² : HasAntidiagonal A\nn m : A\ninst✝¹ : DecidablePred fun x ↦ x = m\ninst✝ : Decidable (m ≤ n)\nthis : (fun x ↦ x.2 = m) ∘ Prod.sw... | ← map_swap_antidiagonal, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Algebra.Order.Antidiag.Prod | {
"line": 186,
"column": 8
} | {
"line": 186,
"column": 24
} | [
{
"pp": "A : Type u_1\ninst✝¹ : AddMonoid A\ninst✝ : HasAntidiagonal A\nn k l : A\nh : (k, l) ∈ antidiagonal n\n⊢ (fun x ↦ ⟨x.1 + x.2, ⟨x, ⋯⟩⟩) ((fun x ↦ ↑x.snd) ⟨n, ⟨(k, l), h⟩⟩) = ⟨n, ⟨(k, l), h⟩⟩",
"usedConstants": [
"AddMonoid.toAddSemigroup",
"congrArg",
"Finset",
"Membership.me... | mem_antidiagonal | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Order.Disjointed | {
"line": 238,
"column": 2
} | {
"line": 245,
"column": 42
} | [
{
"pp": "α : Type u_1\nι : Type u_2\ninst✝³ : GeneralizedBooleanAlgebra α\ninst✝² : LinearOrder ι\ninst✝¹ : LocallyFiniteOrderBot ι\ninst✝ : SuccOrder ι\nf : ι → α\nhf : Monotone f\ni : ι\n⊢ disjointed f (succ i) ⊔ f i = f (succ i)",
"usedConstants": [
"partialSups_apply",
"sdiff_sup_cancel",
... | by_cases h : IsMax i
· simpa only [succ_eq_iff_isMax.mpr h, sup_eq_right] using disjointed_le f i
· rw [disjointed_apply]
have : Iio (succ i) = Iic i := by
ext
simp only [mem_Iio, lt_succ_iff_eq_or_lt_of_not_isMax h, mem_Iic, le_iff_lt_or_eq, Or.comm]
rw [this, ← sup'_eq_sup nonempty_Iic, ← part... | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Order.Disjointed | {
"line": 238,
"column": 2
} | {
"line": 245,
"column": 42
} | [
{
"pp": "α : Type u_1\nι : Type u_2\ninst✝³ : GeneralizedBooleanAlgebra α\ninst✝² : LinearOrder ι\ninst✝¹ : LocallyFiniteOrderBot ι\ninst✝ : SuccOrder ι\nf : ι → α\nhf : Monotone f\ni : ι\n⊢ disjointed f (succ i) ⊔ f i = f (succ i)",
"usedConstants": [
"partialSups_apply",
"sdiff_sup_cancel",
... | by_cases h : IsMax i
· simpa only [succ_eq_iff_isMax.mpr h, sup_eq_right] using disjointed_le f i
· rw [disjointed_apply]
have : Iio (succ i) = Iic i := by
ext
simp only [mem_Iio, lt_succ_iff_eq_or_lt_of_not_isMax h, mem_Iic, le_iff_lt_or_eq, Or.comm]
rw [this, ← sup'_eq_sup nonempty_Iic, ← part... | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Algebra.BigOperators.Intervals | {
"line": 71,
"column": 2
} | {
"line": 71,
"column": 91
} | [
{
"pp": "M : Type u_3\ninst✝ : CommMonoid M\na b : ℕ\nhab : a ≤ b\nf : ℕ → M\n⊢ ∏ k ∈ Ioc a (b + 1), f k = (∏ k ∈ Ioc a b, f k) * f (b + 1)",
"usedConstants": [
"Eq.mpr",
"Nat.Ioc_succ_singleton",
"HMul.hMul",
"Finset.prod_singleton",
"Monoid.toMulOneClass",
"congrArg",
... | rw [← prod_Ioc_consecutive _ hab (Nat.le_succ b), Nat.Ioc_succ_singleton, prod_singleton] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.Algebra.BigOperators.Intervals | {
"line": 71,
"column": 2
} | {
"line": 71,
"column": 91
} | [
{
"pp": "M : Type u_3\ninst✝ : CommMonoid M\na b : ℕ\nhab : a ≤ b\nf : ℕ → M\n⊢ ∏ k ∈ Ioc a (b + 1), f k = (∏ k ∈ Ioc a b, f k) * f (b + 1)",
"usedConstants": [
"Eq.mpr",
"Nat.Ioc_succ_singleton",
"HMul.hMul",
"Finset.prod_singleton",
"Monoid.toMulOneClass",
"congrArg",
... | rw [← prod_Ioc_consecutive _ hab (Nat.le_succ b), Nat.Ioc_succ_singleton, prod_singleton] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Algebra.BigOperators.Intervals | {
"line": 71,
"column": 2
} | {
"line": 71,
"column": 91
} | [
{
"pp": "M : Type u_3\ninst✝ : CommMonoid M\na b : ℕ\nhab : a ≤ b\nf : ℕ → M\n⊢ ∏ k ∈ Ioc a (b + 1), f k = (∏ k ∈ Ioc a b, f k) * f (b + 1)",
"usedConstants": [
"Eq.mpr",
"Nat.Ioc_succ_singleton",
"HMul.hMul",
"Finset.prod_singleton",
"Monoid.toMulOneClass",
"congrArg",
... | rw [← prod_Ioc_consecutive _ hab (Nat.le_succ b), Nat.Ioc_succ_singleton, prod_singleton] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Algebra.BigOperators.NatAntidiagonal | {
"line": 37,
"column": 18
} | {
"line": 37,
"column": 42
} | [
{
"pp": "M : Type u_1\ninst✝ : CommMonoid M\nn : ℕ\nf : ℕ × ℕ → M\n| ∏ p ∈ antidiagonal n, f p.swap",
"usedConstants": [
"congrArg",
"Finset",
"Finset.map",
"Function.Embedding.mk",
"Finset.prod",
"Finset.Nat.instHasAntidiagonal",
"Nat",
"Finset.map_swap_antid... | ← map_swap_antidiagonal, | Lean.Elab.Tactic.Conv.evalRewrite | null |
Mathlib.Data.Finset.NatAntidiagonal | {
"line": 49,
"column": 6
} | {
"line": 49,
"column": 30
} | [
{
"pp": "n : ℕ\n⊢ antidiagonal n = map { toFun := fun i ↦ (n - i, i), inj' := ⋯ } (range (n + 1))",
"usedConstants": [
"Eq.mpr",
"congrArg",
"Finset",
"HSub.hSub",
"Nat.instAddMonoid",
"Finset.map",
"Function.Embedding.mk",
"Prod.ext_iff",
"id",
"P... | ← map_swap_antidiagonal, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.RingTheory.Ideal.Defs | {
"line": 79,
"column": 2
} | {
"line": 79,
"column": 41
} | [
{
"pp": "α : Type u\ninst✝ : Semiring α\nI : Ideal α\nx y : α\nhy : IsUnit y\nh : y * x ∈ I\ny' : α\nhy' : y' * y = 1\nthis : y' * (y * x) ∈ I\n⊢ x ∈ I",
"usedConstants": [
"MulOne.toOne",
"Semigroup.toMul",
"Semiring.toModule",
"HMul.hMul",
"Monoid.toMulOneClass",
"congr... | rwa [← mul_assoc, hy', one_mul] at this | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_tacticRwa___1 | Lean.Parser.Tactic.tacticRwa__ |
Mathlib.Data.Finset.NatAntidiagonal | {
"line": 126,
"column": 11
} | {
"line": 126,
"column": 16
} | [
{
"pp": "n k : ℕ\nh : k ≤ n\naux₁ : (fun a ↦ a.1 ≤ k) = (fun a ↦ a.2 ≤ k) ∘ ⇑(Equiv.prodComm ℕ ℕ).symm\naux₂ : ∀ (i j : ℕ), (∃ a b, a + b = k ∧ b = i ∧ a + (n - k) = j) ↔ ∃ a b, a + b = k ∧ a = i ∧ b + (n - k) = j\n⊢ {a ∈ map (Equiv.prodComm ℕ ℕ).toEmbedding (antidiagonal n) | a.1 ≤ k} =\n map ((Embedding.re... | aux₁, | Mathlib.Tactic._aux_Mathlib_Tactic_SimpRw___elabRules_Mathlib_Tactic_tacticSimp_rw____1 | null |
Mathlib.Data.Finset.NatAntidiagonal | {
"line": 150,
"column": 11
} | {
"line": 150,
"column": 16
} | [
{
"pp": "n k : ℕ\nh : k ≤ n\naux₁ : (fun a ↦ k ≤ a.2) = (fun a ↦ k ≤ a.1) ∘ ⇑(Equiv.prodComm ℕ ℕ).symm\naux₂ : ∀ (i j : ℕ), (∃ a b, a + b = n - k ∧ b = i ∧ a + k = j) ↔ ∃ a b, a + b = n - k ∧ a = i ∧ b + k = j\n⊢ {a ∈ map (Equiv.prodComm ℕ ℕ).toEmbedding (antidiagonal n) | k ≤ a.2} =\n map ((Embedding.refl ℕ... | aux₁, | Mathlib.Tactic._aux_Mathlib_Tactic_SimpRw___elabRules_Mathlib_Tactic_tacticSimp_rw____1 | null |
Mathlib.Data.Nat.Choose.Sum | {
"line": 52,
"column": 47
} | {
"line": 52,
"column": 56
} | [
{
"pp": "case pos\nR : Type u_1\ninst✝ : Semiring R\nx y : R\nh : Commute x y\nn✝ : ℕ\nt : ℕ → ℕ → R := fun n m ↦ x ^ m * y ^ (n - m) * ↑(n.choose m)\nh_first : ∀ (n : ℕ), t n 0 = y ^ n\nh_last : ∀ (n : ℕ), t n n.succ = 0\nn i : ℕ\nh_mem : i ∈ range n.succ\nh_le : i ≤ n\nh_eq : i = n\n⊢ x ^ n.succ * y ^ (n.succ... | mul_zero, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Algebra.Ring.Idempotent | {
"line": 68,
"column": 40
} | {
"line": 68,
"column": 48
} | [
{
"pp": "R : Type u_1\ninst✝ : Semiring R\na b : R\nmul : a * b = 0\nadd : a + b = 1\n| a * (a + b)",
"usedConstants": [
"Distrib.leftDistribClass",
"HMul.hMul",
"congrArg",
"MulOne.toMul",
"Distrib.toAdd",
"NonAssocSemiring.toMulZeroOneClass",
"MulZeroOneClass.toMu... | mul_add, | Lean.Elab.Tactic.Conv.evalRewrite | null |
Mathlib.Algebra.Ring.Idempotent | {
"line": 96,
"column": 29
} | {
"line": 96,
"column": 37
} | [
{
"pp": "R : Type u_1\ninst✝ : NonUnitalNonAssocSemiring R\na b : R\nha : IsIdempotentElem a\nhb : IsIdempotentElem b\nhab : a * b + b * a = 0\n⊢ (a + b) * (a + b) = a + b",
"usedConstants": [
"Distrib.leftDistribClass",
"Eq.mpr",
"HMul.hMul",
"congrArg",
"id",
"Distrib.t... | mul_add, | Mathlib.Tactic._aux_Mathlib_Tactic_SimpRw___elabRules_Mathlib_Tactic_tacticSimp_rw____1 | null |
Mathlib.Algebra.Ring.Idempotent | {
"line": 118,
"column": 54
} | {
"line": 118,
"column": 63
} | [
{
"pp": "R : Type u_1\na b : R\ninst✝¹ : NonUnitalSemiring R\ninst✝ : IsAddTorsionFree R\nha : IsIdempotentElem a\nhab : a * b + b * a = 0\n⊢ a * 0 * a = 0",
"usedConstants": [
"Eq.mpr",
"HMul.hMul",
"MulZeroClass.toMul",
"congrArg",
"NonUnitalNonAssocSemiring.toMulZeroClass",
... | mul_zero, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Algebra.Ring.Idempotent | {
"line": 119,
"column": 13
} | {
"line": 119,
"column": 21
} | [
{
"pp": "R : Type u_1\na b : R\ninst✝¹ : NonUnitalSemiring R\ninst✝ : IsAddTorsionFree R\nha : IsIdempotentElem a\nhab : a * b + b * a = 0\nthis : a * (a * b + b * a) * a = 0\n⊢ (1 + 1) • (a * b * a) = 0",
"usedConstants": [
"Distrib.leftDistribClass",
"HMul.hMul",
"congrArg",
"NonUn... | mul_add, | Mathlib.Tactic._aux_Mathlib_Tactic_SimpRw___elabRules_Mathlib_Tactic_tacticSimp_rw____1 | null |
Mathlib.Data.Nat.Choose.Sum | {
"line": 64,
"column": 58
} | {
"line": 64,
"column": 67
} | [
{
"pp": "case succ.e_a\nR : Type u_1\ninst✝ : Semiring R\nx y : R\nh : Commute x y\nt : ℕ → ℕ → R := fun n m ↦ x ^ m * y ^ (n - m) * ↑(n.choose m)\nh_first : ∀ (n : ℕ), t n 0 = y ^ n\nh_last : ∀ (n : ℕ), t n n.succ = 0\nh_middle : ∀ (n i : ℕ), i ∈ range n.succ → t n.succ i.succ = x * t n i + y * t n i.succ\nn :... | mul_zero, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Algebra.Ring.Idempotent | {
"line": 142,
"column": 22
} | {
"line": 142,
"column": 30
} | [
{
"pp": "R : Type u_1\ninst✝¹ : NonUnitalRing R\ninst✝ : IsAddTorsionFree R\np q : R\nhp : IsIdempotentElem p\nhq : IsIdempotentElem q\nh : p * (q - p) + (q - p) * p = 0\nhqp : p * q + q * p - p = p\nh2 : (fun x ↦ x * q) (p * q + q * p - p) = (fun x ↦ x * q) p\nh1 : q * (p * q + q * p) - q * p = q * p\n⊢ Commut... | mul_add, | Mathlib.Tactic._aux_Mathlib_Tactic_SimpRw___elabRules_Mathlib_Tactic_tacticSimp_rw____1 | null |
Mathlib.Data.Nat.Choose.Sum | {
"line": 85,
"column": 2
} | {
"line": 87,
"column": 53
} | [
{
"pp": "case a\nR : Type u_1\ninst✝ : CommRing R\nx y : R\nn m : ℕ\nhm : m ∈ range (n + 1)\n⊢ x ^ m * (-y) ^ (n - m) * ↑(n.choose m) = (-1) ^ (m + n) * x ^ m * y ^ (n - m) * ↑(n.choose m)",
"usedConstants": [
"one_pow",
"NegZeroClass.toNeg",
"MulOne.toOne",
"NonUnitalCommRing.toNonU... | have : (-1 : R) ^ (n - m) = (-1) ^ (n + m) := by
rw [mem_range] at hm
simp [show n + m = n - m + 2 * m by lia, pow_add] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_tacticHave___1 | Lean.Parser.Tactic.tacticHave__ |
Mathlib.Data.Nat.Choose.Sum | {
"line": 132,
"column": 39
} | {
"line": 132,
"column": 60
} | [
{
"pp": "case inl\nn k : ℕ\nh : n < k\n⊢ ∑ m ∈ Icc k n, m.choose k = 0",
"usedConstants": [
"Eq.mpr",
"Nat.choose",
"congrArg",
"Finset",
"Nat.instLocallyFiniteOrder",
"id",
"Finset.Icc_eq_empty_of_lt",
"instOfNatNat",
"Finset.Icc",
"Finset.instEmp... | Icc_eq_empty_of_lt h, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.RingTheory.Ideal.Span | {
"line": 269,
"column": 39
} | {
"line": 269,
"column": 47
} | [
{
"pp": "α : Type u\ninst✝ : Ring α\nx y x✝¹ : α\nx✝ : ∃ a b, a * x + b * y = x✝¹\na b : α\nh : a * x + b * y = x✝¹\n⊢ a * (x + y) + (b - a) * y = x✝¹",
"usedConstants": [
"Distrib.leftDistribClass",
"Eq.mpr",
"HMul.hMul",
"Ring.toNonAssocRing",
"AddGroupWithOne.toAddGroup",
... | mul_add, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.RingTheory.Ideal.Maximal | {
"line": 157,
"column": 26
} | {
"line": 157,
"column": 34
} | [
{
"pp": "α : Type u\ninst✝ : CommSemiring α\nI : Ideal α\nH : I.IsMaximal\nx y : α\nhxy : x * y ∈ I\nhx : x ∉ I\nJ : Ideal α := Submodule.span α (insert x ↑I)\nIJ : I ≤ J\nxJ : x ∈ J\nleft✝ : 1 ∉ I\noJ : 1 ∈ J\na b : α\nh : b ∈ Submodule.span α ↑I\noe : 1 = a • x + b\nF : y * 1 = y * (a • x + b)\n⊢ y * (a • x +... | mul_add, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.RingTheory.Ideal.Maximal | {
"line": 230,
"column": 4
} | {
"line": 231,
"column": 67
} | [
{
"pp": "α : Type u\ninst✝¹ : CommSemiring α\ninst✝ : IsPrincipalIdealRing α\nP : Ideal α\nhP : P ≠ ⊥\nh : P.IsPrime\n⊢ ∃ p, Prime p ∧ P = span {p}",
"usedConstants": [
"Submodule",
"False",
"Semiring.toModule",
"congrArg",
"CommSemiring.toSemiring",
"False.elim",
"... | obtain ⟨p, rfl⟩ := Submodule.IsPrincipal.principal P
exact ⟨p, (span_singleton_prime (by simp [·] at hP)).mp h, rfl⟩ | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.RingTheory.Ideal.Maximal | {
"line": 230,
"column": 4
} | {
"line": 231,
"column": 67
} | [
{
"pp": "α : Type u\ninst✝¹ : CommSemiring α\ninst✝ : IsPrincipalIdealRing α\nP : Ideal α\nhP : P ≠ ⊥\nh : P.IsPrime\n⊢ ∃ p, Prime p ∧ P = span {p}",
"usedConstants": [
"Submodule",
"False",
"Semiring.toModule",
"congrArg",
"CommSemiring.toSemiring",
"False.elim",
"... | obtain ⟨p, rfl⟩ := Submodule.IsPrincipal.principal P
exact ⟨p, (span_singleton_prime (by simp [·] at hP)).mp h, rfl⟩ | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Order.Filter.Basic | {
"line": 463,
"column": 49
} | {
"line": 463,
"column": 94
} | [
{
"pp": "α : Type u\nι : Sort x\nf : ι → Filter α\np : ι → Prop\nl : Filter α\nh : ∀ {s : Set α}, s ∈ l ↔ ∃ i, p i ∧ s ∈ f i\nx✝ : Set α\n⊢ x✝ ∈ l ↔ ∃ i, x✝ ∈ f ↑i",
"usedConstants": [
"Filter.instMembership",
"Iff.of_eq",
"congrArg",
"Membership.mem",
"Exists",
"_private... | by simp only [Subtype.exists, h, exists_prop] | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Order.Filter.AtTopBot.Disjoint | {
"line": 43,
"column": 2
} | {
"line": 43,
"column": 42
} | [
{
"pp": "α : Type u_3\ninst✝¹ : PartialOrder α\ninst✝ : Nontrivial α\n⊢ Disjoint atBot atTop",
"usedConstants": [
"exists_pair_ne"
]
}
] | rcases exists_pair_ne α with ⟨x, y, hne⟩ | _private.Lean.Elab.Tactic.RCases.0.Lean.Elab.Tactic.RCases.evalRCases | Lean.Parser.Tactic.rcases |
Mathlib.Order.Filter.Map | {
"line": 608,
"column": 76
} | {
"line": 610,
"column": 65
} | [
{
"pp": "α : Type u_1\nβ : Type u_2\nγ : Type u_3\nl : Filter (α ⊕ β)\nm₁ : α → γ\nm₂ : β → γ\n⊢ map (Sum.elim m₁ m₂) l = map m₁ (comap inl l) ⊔ map m₂ (comap inr l)",
"usedConstants": [
"Eq.mpr",
"Lattice.toSemilatticeSup",
"CompleteLattice.toLattice",
"congrArg",
"Filter.map"... | by
rw [← map_comap_inl_sup_map_comap_inr l]
simp [map_sup, map_map, comap_sup, (gc_map_comap _).u_l_u_eq_u] | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Order.Filter.Map | {
"line": 695,
"column": 2
} | {
"line": 696,
"column": 87
} | [
{
"pp": "case h.mp\nα : Type u_1\nβ : Type u_2\nf : α → β\nF : Filter β\nx : α\n⊢ (∀ (A : Set α), ∀ B ∈ F, f ⁻¹' B ⊆ A → x ∈ A) → ∀ B ∈ F, f x ∈ B",
"usedConstants": [
"Filter.instMembership",
"_private.Mathlib.Order.Filter.Map.0.Filter.sInter_comap_sets._simp_1_8",
"Membership.mem",
... | · intro h U U_in
simpa only [Subset.rfl, forall_prop_of_true, mem_preimage] using h (f ⁻¹' U) U U_in | Lean.Elab.Tactic.evalTacticCDot | Lean.cdot |
Mathlib.Order.Filter.Map | {
"line": 697,
"column": 4
} | {
"line": 697,
"column": 26
} | [
{
"pp": "case h.mpr\nα : Type u_1\nβ : Type u_2\nf : α → β\nF : Filter β\nx : α\n⊢ (∀ B ∈ F, f x ∈ B) → ∀ (A : Set α), ∀ B ∈ F, f ⁻¹' B ⊆ A → x ∈ A",
"usedConstants": [
"Filter.instMembership",
"Membership.mem",
"Set.instMembership",
"Filter",
"Set"
]
}
] | intro h V U U_in f_U_V | Lean.Elab.Tactic.evalIntro | Lean.Parser.Tactic.intro |
Mathlib.Order.Filter.Basic | {
"line": 981,
"column": 15
} | {
"line": 983,
"column": 19
} | [
{
"pp": "α : Type u\nβ : Type v\nγ : Type w\nl : Filter α\nf f' : α → β\nhf : f =ᶠ[l] f'\ng g' : α → γ\nhg : g =ᶠ[l] g'\n⊢ ∀ (x : α), g x = g' x → f x = f' x → (fun x ↦ (f x, g x)) x = (fun x ↦ (f' x, g' x)) x",
"usedConstants": [
"congrArg",
"Prod.mk",
"congr",
"True",
"eq_sel... | by
intros
simp only [*] | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Order.Filter.Basic | {
"line": 1214,
"column": 4
} | {
"line": 1214,
"column": 67
} | [
{
"pp": "α : Type u\ns t : Set α\nl : Filter α\n⊢ t ∈ l ⊓ 𝓟 s ↔ l ⊓ 𝓟 s ≤ l ⊓ 𝓟 t",
"usedConstants": [
"Filter.instMembership",
"CompleteLattice.toLattice",
"congrArg",
"Filter.instCompleteLatticeFilter",
"PartialOrder.toPreorder",
"Preorder.toLE",
"Membership.me... | simp only [le_inf_iff, inf_le_left, true_and, le_principal_iff] | Lean.Elab.Tactic.evalSimp | Lean.Parser.Tactic.simp |
Mathlib.Order.Filter.Basic | {
"line": 1214,
"column": 4
} | {
"line": 1214,
"column": 67
} | [
{
"pp": "α : Type u\ns t : Set α\nl : Filter α\n⊢ t ∈ l ⊓ 𝓟 s ↔ l ⊓ 𝓟 s ≤ l ⊓ 𝓟 t",
"usedConstants": [
"Filter.instMembership",
"CompleteLattice.toLattice",
"congrArg",
"Filter.instCompleteLatticeFilter",
"PartialOrder.toPreorder",
"Preorder.toLE",
"Membership.me... | simp only [le_inf_iff, inf_le_left, true_and, le_principal_iff] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Order.Filter.Basic | {
"line": 1214,
"column": 4
} | {
"line": 1214,
"column": 67
} | [
{
"pp": "α : Type u\ns t : Set α\nl : Filter α\n⊢ t ∈ l ⊓ 𝓟 s ↔ l ⊓ 𝓟 s ≤ l ⊓ 𝓟 t",
"usedConstants": [
"Filter.instMembership",
"CompleteLattice.toLattice",
"congrArg",
"Filter.instCompleteLatticeFilter",
"PartialOrder.toPreorder",
"Preorder.toLE",
"Membership.me... | simp only [le_inf_iff, inf_le_left, true_and, le_principal_iff] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Order.Filter.Map | {
"line": 880,
"column": 8
} | {
"line": 880,
"column": 23
} | [
{
"pp": "case refine_1\nα : Type u_1\nβ : Type u_2\nf : Filter (α → β)\na : α\ns : Set (α → β)\nhs : s ∈ f\n⊢ (fun g ↦ g a) '' s ∈ f.seq (pure a)",
"usedConstants": [
"Pure.pure",
"Filter.instMembership",
"Eq.mpr",
"congrArg",
"Filter.seq",
"Membership.mem",
"Set.in... | ← seq_singleton | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Order.Filter.Map | {
"line": 905,
"column": 4
} | {
"line": 905,
"column": 34
} | [
{
"pp": "case refine_1\nα : Type u_1\nβ : Type u_2\nf : Filter α\ng : Filter β\ns : Set (α → α × β)\nhs✝ : s ∈ map (fun b a ↦ (a, b)) g\nt : Set α\nht : t ∈ f\nu : Set β\nhu : u ∈ g\nhs : (fun b a ↦ (a, b)) '' u ⊆ s\n⊢ ((fun b a ↦ (a, b)) '' u).seq t ∈ (map Prod.mk f).seq g",
"usedConstants": [
"Set.p... | rw [← Set.prod_image_seq_comm] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.Algebra.Module.TransferInstance | {
"line": 73,
"column": 2
} | {
"line": 73,
"column": 81
} | [
{
"pp": "R : Type u_1\nα : Type u_2\nβ : Type u_3\ninst✝³ : Semiring R\ne : α ≃ β\ninst✝² : AddCommMonoid β\ninst✝¹ : Module R β\ninst✝ : Module.IsTorsionFree R β\n⊢ let this := e.addCommMonoid;\n let this_1 := Equiv.module R e;\n Module.IsTorsionFree R α",
"usedConstants": [
"instHSMul",
"Sem... | extract_lets; exact (e.linearEquiv R).injective.moduleIsTorsionFree _ (by simp) | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Algebra.Module.TransferInstance | {
"line": 73,
"column": 2
} | {
"line": 73,
"column": 81
} | [
{
"pp": "R : Type u_1\nα : Type u_2\nβ : Type u_3\ninst✝³ : Semiring R\ne : α ≃ β\ninst✝² : AddCommMonoid β\ninst✝¹ : Module R β\ninst✝ : Module.IsTorsionFree R β\n⊢ let this := e.addCommMonoid;\n let this_1 := Equiv.module R e;\n Module.IsTorsionFree R α",
"usedConstants": [
"instHSMul",
"Sem... | extract_lets; exact (e.linearEquiv R).injective.moduleIsTorsionFree _ (by simp) | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Algebra.Order.Module.Defs | {
"line": 749,
"column": 93
} | {
"line": 750,
"column": 60
} | [
{
"pp": "α : Type u_1\nβ : Type u_2\na : α\nb : β\ninst✝⁵ : Monoid α\ninst✝⁴ : Zero β\ninst✝³ : MulAction α β\ninst✝² : Preorder α\ninst✝¹ : Preorder β\ninst✝ : SMulPosStrictMono α β\nhb : 0 < b\nh : a < 1\n⊢ a • b < b",
"usedConstants": [
"MulOne.toOne",
"instHSMul",
"Preorder.toLT",
... | by
simpa only [one_smul] using smul_lt_smul_of_pos_right h hb | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Algebra.Order.Module.Defs | {
"line": 752,
"column": 93
} | {
"line": 753,
"column": 60
} | [
{
"pp": "α : Type u_1\nβ : Type u_2\na : α\nb : β\ninst✝⁵ : Monoid α\ninst✝⁴ : Zero β\ninst✝³ : MulAction α β\ninst✝² : Preorder α\ninst✝¹ : Preorder β\ninst✝ : SMulPosStrictMono α β\nhb : 0 < b\nh : 1 < a\n⊢ b < a • b",
"usedConstants": [
"MulOne.toOne",
"instHSMul",
"Preorder.toLT",
... | by
simpa only [one_smul] using smul_lt_smul_of_pos_right h hb | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.SetTheory.Ordinal.Family | {
"line": 756,
"column": 2
} | {
"line": 756,
"column": 24
} | [
{
"pp": "o : Ordinal.{u}\nf : (a : Ordinal.{u}) → a < o → Ordinal.{max u v}\n⊢ iSup (o.familyOfBFamily f) = lsub (o.familyOfBFamily f) ↔\n ∀ a < lsub (o.familyOfBFamily f), succ a < lsub (o.familyOfBFamily f)",
"usedConstants": [
"Ordinal.familyOfBFamily",
"Ordinal.iSup_eq_lsub_iff",
"O... | apply iSup_eq_lsub_iff | Lean.Elab.Tactic.evalApply | Lean.Parser.Tactic.apply |
Mathlib.SetTheory.Cardinal.Aleph | {
"line": 648,
"column": 4
} | {
"line": 648,
"column": 65
} | [
{
"pp": "case pos\no : Ordinal.{u_1}\nH : IsSuccLimit o\n⊢ (preBeth o).IsStrongLimit ↔ IsSuccLimit o",
"usedConstants": [
"Cardinal.IsStrongLimit.mk",
"Eq.mpr",
"Ordinal.instLinearOrder",
"Order.IsSuccLimit.ne_bot",
"Preorder.toLT",
"Ordinal.partialOrder",
"Cardinal... | refine iff_of_true ⟨by simpa using H.ne_bot, fun a ha ↦ ?_⟩ H | Lean.Elab.Tactic.evalRefine | Lean.Parser.Tactic.refine |
Mathlib.SetTheory.Ordinal.Basic | {
"line": 730,
"column": 2
} | {
"line": 731,
"column": 42
} | [
{
"pp": "α✝ : Type u\nβ✝ : Type v\nγ : Type w\nr✝ : α✝ → α✝ → Prop\ns✝ : β✝ → β✝ → Prop\nt : γ → γ → Prop\na : Ordinal.{v}\nb : Ordinal.{max u v}\nα : Type v\nr : α → α → Prop\nx✝¹ : IsWellOrder α r\nβ : Type (max u v)\ns : β → β → Prop\nx✝ : IsWellOrder β s\nh : type s < (RelEmbedding.ofMonotone lift.{u, v} li... | rw [RelEmbedding.ofMonotone_coe, ← lift_id'.{max u v} (type s),
← lift_umax.{v, u}, lift_type_lt] at h | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.SetTheory.Ordinal.Arithmetic | {
"line": 243,
"column": 12
} | {
"line": 243,
"column": 29
} | [
{
"pp": "α : Type u_1\nr : α → α → Prop\ninst✝ : IsWellOrder α r\nhr : IsSuccLimit (type r)\nx b : α\nhb : b ∈ {x}\n⊢ r x ((enum r) ⟨succ ((typein r).toRelEmbedding x), ⋯⟩)",
"usedConstants": [
"Eq.mpr",
"Preorder.toLT",
"Order.succ",
"Ordinal.partialOrder",
"congrArg",
"... | ← enum_typein r x | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.SetTheory.Ordinal.Arithmetic | {
"line": 643,
"column": 6
} | {
"line": 643,
"column": 31
} | [
{
"pp": "case pos.left\nα β : Type u_4\nr : α → α → Prop\ns : β → β → Prop\ninst✝¹ : IsWellOrder α r\ninst✝ : IsWellOrder β s\nc : Ordinal.{u_4}\nh✝ : IsSuccLimit (type s)\nH : ∀ b' < type s, type r * b' ≤ c\nl : c < type r * type s\na : α\nb : β\nthis : type r * (typein s).toRelEmbedding b + type r ≤ c\na' : α... | · exact (irrefl _ h).elim | Lean.Elab.Tactic.evalTacticCDot | Lean.cdot |
Mathlib.SetTheory.Ordinal.Arithmetic | {
"line": 652,
"column": 29
} | {
"line": 652,
"column": 49
} | [
{
"pp": "case pos\nα β : Type u_4\nr : α → α → Prop\ns : β → β → Prop\ninst✝¹ : IsWellOrder α r\ninst✝ : IsWellOrder β s\nc : Ordinal.{u_4}\nh✝ : IsSuccLimit (type s)\nH : ∀ b' < type s, type r * b' ≤ c\nl : c < type r * type s\na : α\nb : β\nthis✝ : type r * (typein s).toRelEmbedding b + type r ≤ c\nthis : typ... | by_cases e₂ : b = b₂ | «_aux_Init_ByCases___macroRules_tacticBy_cases_:__2» | «tacticBy_cases_:_» |
Mathlib.SetTheory.Ordinal.Arithmetic | {
"line": 652,
"column": 29
} | {
"line": 652,
"column": 49
} | [
{
"pp": "case neg\nα β : Type u_4\nr : α → α → Prop\ns : β → β → Prop\ninst✝¹ : IsWellOrder α r\ninst✝ : IsWellOrder β s\nc : Ordinal.{u_4}\nh✝ : IsSuccLimit (type s)\nH : ∀ b' < type s, type r * b' ≤ c\nl : c < type r * type s\na : α\nb : β\nthis✝ : type r * (typein s).toRelEmbedding b + type r ≤ c\nthis : typ... | by_cases e₂ : b = b₂ | «_aux_Init_ByCases___macroRules_tacticBy_cases_:__2» | «tacticBy_cases_:_» |
Mathlib.SetTheory.Ordinal.Basic | {
"line": 1336,
"column": 2
} | {
"line": 1340,
"column": 21
} | [
{
"pp": "⊢ univ.{u, v}.ord = Ordinal.univ.{u, v}",
"usedConstants": [
"Iff.mpr",
"Eq.mpr",
"Ordinal.instLinearOrder",
"Preorder.toLT",
"Ordinal.partialOrder",
"Cardinal",
"congrArg",
"PrincipalSeg.mem_range_of_rel_top",
"Cardinal.univ",
"PartialOrd... | refine le_antisymm (ord_card_le _) <| le_of_forall_lt fun o h => lt_ord.2 ?_
have := liftPrincipalSeg.mem_range_of_rel_top (by simpa only [liftPrincipalSeg_coe] using h)
rcases this with ⟨o, h'⟩
rw [← h', liftPrincipalSeg_coe, ← lift_card]
apply lift_lt_univ' | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.SetTheory.Ordinal.Basic | {
"line": 1336,
"column": 2
} | {
"line": 1340,
"column": 21
} | [
{
"pp": "⊢ univ.{u, v}.ord = Ordinal.univ.{u, v}",
"usedConstants": [
"Iff.mpr",
"Eq.mpr",
"Ordinal.instLinearOrder",
"Preorder.toLT",
"Ordinal.partialOrder",
"Cardinal",
"congrArg",
"PrincipalSeg.mem_range_of_rel_top",
"Cardinal.univ",
"PartialOrd... | refine le_antisymm (ord_card_le _) <| le_of_forall_lt fun o h => lt_ord.2 ?_
have := liftPrincipalSeg.mem_range_of_rel_top (by simpa only [liftPrincipalSeg_coe] using h)
rcases this with ⟨o, h'⟩
rw [← h', liftPrincipalSeg_coe, ← lift_card]
apply lift_lt_univ' | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.SetTheory.Cardinal.Arithmetic | {
"line": 542,
"column": 30
} | {
"line": 542,
"column": 44
} | [
{
"pp": "κ μ : Cardinal.{u}\nH1✝ : ℵ₀ ≤ κ\nH2 : μ < ℵ₀\nn✝ : ℕ\nH3 : μ = ↑n✝\nα : Type u\nH1 : ℵ₀ ≤ ⟦α⟧\nn : ℕ\nih : ⟦α⟧ ^ ↑n ≤ ⟦α⟧\n⊢ ⟦α⟧ ^ ↑n.succ ≤ ⟦α⟧",
"usedConstants": [
"Eq.mpr",
"NonAssocSemiring.toAddCommMonoidWithOne",
"Nat.cast_succ",
"Cardinal.instPowCardinal",
"Add... | Nat.cast_succ, | Mathlib.Tactic.evalGRewriteSeq | null |
Mathlib.SetTheory.Cardinal.Arithmetic | {
"line": 558,
"column": 8
} | {
"line": 558,
"column": 19
} | [
{
"pp": "case a\nι : Type u\ninst✝ : Infinite ι\nc : ι → Cardinal.{v}\nh₁ : ∀ (i : ι), 2 ≤ c i\nh₂ : ∀ (i : ι), lift.{u, v} (c i) ≤ lift.{v, u} #ι\n⊢ (prod fun i ↦ lift.{v, u} #ι) = lift.{v, u} (2 ^ #ι)",
"usedConstants": [
"Eq.mpr",
"Cardinal.instPowCardinal",
"Cardinal",
"congrArg"... | prod_const, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.SetTheory.Cardinal.Arithmetic | {
"line": 588,
"column": 4
} | {
"line": 589,
"column": 30
} | [
{
"pp": "case a\nc : Cardinal.{u_1}\nh : ℵ₀ ≤ c\n⊢ c ^< ℵ₀ ≤ c",
"usedConstants": [
"Eq.mpr",
"Preorder.toLT",
"Cardinal.instPowCardinal",
"Cardinal",
"congrArg",
"PartialOrder.toPreorder",
"Cardinal.pow_le",
"Preorder.toLE",
"id",
"Cardinal.powerl... | rw [powerlt_le]
exact fun _ a ↦ pow_le h a | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.SetTheory.Cardinal.Arithmetic | {
"line": 588,
"column": 4
} | {
"line": 589,
"column": 30
} | [
{
"pp": "case a\nc : Cardinal.{u_1}\nh : ℵ₀ ≤ c\n⊢ c ^< ℵ₀ ≤ c",
"usedConstants": [
"Eq.mpr",
"Preorder.toLT",
"Cardinal.instPowCardinal",
"Cardinal",
"congrArg",
"PartialOrder.toPreorder",
"Cardinal.pow_le",
"Preorder.toLE",
"id",
"Cardinal.powerl... | rw [powerlt_le]
exact fun _ a ↦ pow_le h a | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.SetTheory.Ordinal.Exponential | {
"line": 101,
"column": 8
} | {
"line": 101,
"column": 17
} | [
{
"pp": "case succ\na : Ordinal.{u_1}\na0 : 0 < a\nh0 : 0 < a ^ 0\nb : Ordinal.{u_1}\nIH : 0 < a ^ b\n⊢ 0 < a ^ succ b",
"usedConstants": [
"Eq.mpr",
"Preorder.toLT",
"HMul.hMul",
"Order.succ",
"Ordinal.partialOrder",
"MulZeroClass.toMul",
"congrArg",
"Partial... | opow_succ | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.SetTheory.Ordinal.Exponential | {
"line": 117,
"column": 21
} | {
"line": 117,
"column": 35
} | [
{
"pp": "case succ\na : Ordinal.{u_1}\nn : ℕ\nIH : a ^ ↑n = a ^ n\n⊢ a ^ ↑(n + 1) = a ^ (n + 1)",
"usedConstants": [
"Eq.mpr",
"Nat.cast_succ",
"Ordinal.monoid",
"AddMonoid.toAddSemigroup",
"congrArg",
"id",
"AddMonoidWithOne.toNatCast",
"instOfNatNat",
... | Nat.cast_succ, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.SetTheory.Ordinal.Exponential | {
"line": 159,
"column": 8
} | {
"line": 159,
"column": 17
} | [
{
"pp": "case inr.inl\na : Ordinal.{u_1}\nl : IsSuccLimit a\nb : Ordinal.{u_1}\nhb : succ b ≠ 0\n⊢ IsSuccLimit (a ^ succ b)",
"usedConstants": [
"Eq.mpr",
"HMul.hMul",
"Order.succ",
"Ordinal.partialOrder",
"MulZeroClass.toMul",
"congrArg",
"PartialOrder.toPreorder",... | opow_succ | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.SetTheory.Ordinal.Exponential | {
"line": 201,
"column": 17
} | {
"line": 201,
"column": 26
} | [
{
"pp": "a b c : Ordinal.{u_1}\nab : a < b\n⊢ a ^ c * a < b ^ succ c",
"usedConstants": [
"Eq.mpr",
"Preorder.toLT",
"HMul.hMul",
"Order.succ",
"Ordinal.partialOrder",
"MulZeroClass.toMul",
"congrArg",
"PartialOrder.toPreorder",
"id",
"Ordinal.inst... | opow_succ | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.SetTheory.Ordinal.Exponential | {
"line": 241,
"column": 45
} | {
"line": 241,
"column": 54
} | [
{
"pp": "case inr.inr.inr.succ\na b : Ordinal.{u_1}\nhb : 0 < b\nha : a ≠ 0\nha' : 1 < a\nc : Ordinal.{u_1}\nIH : a ^ (b * c) = (a ^ b) ^ c\n⊢ (a ^ b) ^ c * a ^ b = (a ^ b) ^ succ c",
"usedConstants": [
"Eq.mpr",
"HMul.hMul",
"Order.succ",
"Ordinal.partialOrder",
"MulZeroClass.... | opow_succ | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.SetTheory.Ordinal.Arithmetic | {
"line": 745,
"column": 28
} | {
"line": 745,
"column": 36
} | [
{
"pp": "o : Ordinal.{u_4}\n⊢ o * (1 + 1) = o + o",
"usedConstants": [
"Eq.mpr",
"HMul.hMul",
"AddMonoid.toAddSemigroup",
"MulZeroClass.toMul",
"congrArg",
"id",
"Ordinal.addMonoidWithOne",
"AddMonoidWithOne.toOne",
"instHAdd",
"AddSemigroup.toAdd"... | mul_add, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.SetTheory.Ordinal.FixedPoint | {
"line": 429,
"column": 31
} | {
"line": 429,
"column": 40
} | [
{
"pp": "case e_s.h.zero\na : Ordinal.{u_1}\n⊢ (fun x ↦ a + x)^[0] 0 = a * 0",
"usedConstants": [
"Eq.mpr",
"HMul.hMul",
"MulZeroClass.toMul",
"congrArg",
"AddMonoid.toAddZeroClass",
"AddZeroClass.toAddZero",
"id",
"instOfNatNat",
"Nat.iterate",
"M... | mul_zero, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.SetTheory.Ordinal.Exponential | {
"line": 284,
"column": 2
} | {
"line": 285,
"column": 22
} | [
{
"pp": "case inr\nx : Ordinal.{u_1}\nh : 1 ≤ 1\n⊢ log 1 x = 0",
"usedConstants": [
"Eq.mpr",
"False",
"Ordinal.instLinearOrder",
"Lattice.toSemilatticeSup",
"Ordinal.partialOrder",
"congrArg",
"Set.preimage_const",
"Ordinal.instOrderBot",
"Set.univ",
... | · simp_rw [log, one_opow, preimage_const]
split_ifs <;> simp | Lean.Elab.Tactic.evalTacticCDot | Lean.cdot |
Mathlib.SetTheory.Ordinal.FixedPoint | {
"line": 502,
"column": 33
} | {
"line": 502,
"column": 41
} | [
{
"pp": "case inr.refine_1\na b : Ordinal.{u_1}\nha : 0 < a\nhab : a * (a ^ ω * (b / a ^ ω) + b % a ^ ω) = a ^ ω * (b / a ^ ω) + b % a ^ ω\n⊢ b % a ^ ω = 0",
"usedConstants": [
"instHDiv",
"HMul.hMul",
"Ordinal.omega0",
"MulZeroClass.toMul",
"congrArg",
"Eq.mp",
"Or... | mul_add, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.SetTheory.Ordinal.Arithmetic | {
"line": 814,
"column": 18
} | {
"line": 814,
"column": 26
} | [
{
"pp": "case a\na b : Ordinal.{u_4}\nb0 : b ≠ 0\nc : Ordinal.{u_4}\n⊢ b * a + c < b * (a + c / b) + b",
"usedConstants": [
"Eq.mpr",
"Preorder.toLT",
"instHDiv",
"HMul.hMul",
"Ordinal.partialOrder",
"MulZeroClass.toMul",
"congrArg",
"PartialOrder.toPreorder",... | mul_add, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.SetTheory.Ordinal.Arithmetic | {
"line": 816,
"column": 32
} | {
"line": 816,
"column": 40
} | [
{
"pp": "case a\na b : Ordinal.{u_4}\nb0 : b ≠ 0\nc : Ordinal.{u_4}\n⊢ b * (a + c / b) ≤ b * a + c",
"usedConstants": [
"Eq.mpr",
"instHDiv",
"HMul.hMul",
"Ordinal.partialOrder",
"MulZeroClass.toMul",
"congrArg",
"PartialOrder.toPreorder",
"Preorder.toLE",
... | mul_add, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.SetTheory.Ordinal.Arithmetic | {
"line": 831,
"column": 8
} | {
"line": 831,
"column": 17
} | [
{
"pp": "case inl\na c : Ordinal.{u_4}\nhc : c < a\nb : Ordinal.{u_4}\nha : a ≠ 0\n⊢ (a * b + c) / (a * 0) = b / 0",
"usedConstants": [
"Eq.mpr",
"instHDiv",
"HMul.hMul",
"MulZeroClass.toMul",
"congrArg",
"id",
"HDiv.hDiv",
"MulZeroClass.mul_zero",
"inst... | mul_zero, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.SetTheory.Cardinal.Arithmetic | {
"line": 795,
"column": 2
} | {
"line": 795,
"column": 67
} | [
{
"pp": "α : Type u\nc : Cardinal.{u}\n⊢ #{ t // #↑t ≤ c } ≤ max #α ℵ₀ ^ c",
"usedConstants": [
"Sum.infinite_of_left",
"Lattice.toSemilatticeSup",
"Cardinal.instPowCardinal",
"Cardinal",
"PartialOrder.toPreorder",
"ULift",
"Cardinal.mk",
"SemilatticeSup.toMax... | apply (mk_bounded_set_le_of_infinite ((ULift.{u} ℕ) ⊕ α) c).trans | Lean.Elab.Tactic.evalApply | Lean.Parser.Tactic.apply |
Mathlib.SetTheory.Ordinal.Exponential | {
"line": 471,
"column": 6
} | {
"line": 471,
"column": 15
} | [
{
"pp": "a b : Ordinal.{u_1}\nh : a < b\nn : ℕ\n⊢ ω ^ a * ↑n < ω ^ succ a",
"usedConstants": [
"Eq.mpr",
"Preorder.toLT",
"HMul.hMul",
"Order.succ",
"Ordinal.omega0",
"Ordinal.partialOrder",
"MulZeroClass.toMul",
"congrArg",
"PartialOrder.toPreorder",
... | opow_succ | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.SetTheory.Cardinal.Pigeonhole | {
"line": 47,
"column": 2
} | {
"line": 50,
"column": 58
} | [
{
"pp": "β α : Type u\nf : β → α\nθ : Cardinal.{u}\nhθ : θ ≤ #β\nh₁ : ℵ₀ ≤ θ\nh₂ : #α < θ.ord.cof\n⊢ ∃ a, θ ≤ #↑(f ⁻¹' {a})",
"usedConstants": [
"Eq.mpr",
"Preorder.toLT",
"Cardinal",
"Cardinal.le_mk_iff_exists_set",
"Cardinal.infinite_pigeonhole",
"congrArg",
"Subt... | rcases le_mk_iff_exists_set.1 hθ with ⟨s, rfl⟩
obtain ⟨a, ha⟩ := infinite_pigeonhole (f ∘ Subtype.val : s → α) h₁ h₂
use a; rw [← ha, @preimage_comp _ _ _ Subtype.val f]
exact mk_preimage_of_injective _ _ Subtype.val_injective | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.SetTheory.Cardinal.Pigeonhole | {
"line": 47,
"column": 2
} | {
"line": 50,
"column": 58
} | [
{
"pp": "β α : Type u\nf : β → α\nθ : Cardinal.{u}\nhθ : θ ≤ #β\nh₁ : ℵ₀ ≤ θ\nh₂ : #α < θ.ord.cof\n⊢ ∃ a, θ ≤ #↑(f ⁻¹' {a})",
"usedConstants": [
"Eq.mpr",
"Preorder.toLT",
"Cardinal",
"Cardinal.le_mk_iff_exists_set",
"Cardinal.infinite_pigeonhole",
"congrArg",
"Subt... | rcases le_mk_iff_exists_set.1 hθ with ⟨s, rfl⟩
obtain ⟨a, ha⟩ := infinite_pigeonhole (f ∘ Subtype.val : s → α) h₁ h₂
use a; rw [← ha, @preimage_comp _ _ _ Subtype.val f]
exact mk_preimage_of_injective _ _ Subtype.val_injective | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.SetTheory.Cardinal.Pigeonhole | {
"line": 55,
"column": 2
} | {
"line": 55,
"column": 57
} | [
{
"pp": "β α : Type u\ns : Set β\nf : ↑s → α\nθ : Cardinal.{u}\nhθ : θ ≤ #↑s\nh₁ : ℵ₀ ≤ θ\nh₂ : #α < θ.ord.cof\n⊢ ∃ a t, ∃ (h : t ⊆ s), θ ≤ #↑t ∧ ∀ ⦃x : β⦄ (hx : x ∈ t), f ⟨x, ⋯⟩ = a",
"usedConstants": [
"Set.Elem",
"Cardinal.infinite_pigeonhole_card"
]
}
] | obtain ⟨a, ha⟩ := infinite_pigeonhole_card f θ hθ h₁ h₂ | _private.Lean.Elab.Tactic.RCases.0.Lean.Elab.Tactic.RCases.evalObtain | Lean.Parser.Tactic.obtain |
Mathlib.SetTheory.Ordinal.Arithmetic | {
"line": 960,
"column": 31
} | {
"line": 960,
"column": 39
} | [
{
"pp": "case inr\nx y z : Ordinal.{u_4}\nhx : x ≠ 0\n⊢ x * y + z - x * (y + z / x) = z % x",
"usedConstants": [
"Eq.mpr",
"instHDiv",
"HMul.hMul",
"MulZeroClass.toMul",
"congrArg",
"HSub.hSub",
"Ordinal.mod",
"id",
"HDiv.hDiv",
"instHMod",
"... | mul_add, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.SetTheory.Cardinal.Pigeonhole | {
"line": 74,
"column": 7
} | {
"line": 74,
"column": 40
} | [
{
"pp": "β α : Type u\nf : β → α\nh : #α < #β\nhβ : ℵ₀ ≤ #β\nhα : #α < ℵ₀\n⊢ #α < ℵ₀.ord.cof",
"usedConstants": [
"Eq.mpr",
"Preorder.toLT",
"Cardinal",
"congrArg",
"PartialOrder.toPreorder",
"Cardinal.mk",
"Cardinal.IsRegular.cof_ord",
"id",
"Cardinal.a... | by rwa [isRegular_aleph0.cof_ord] | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.SetTheory.Cardinal.Pigeonhole | {
"line": 86,
"column": 7
} | {
"line": 86,
"column": 40
} | [
{
"pp": "β α : Type u\nf : β → α\nh : #α < #β\ninst✝ : Infinite β\nhα : #α < ℵ₀\n⊢ #α < ℵ₀.ord.cof",
"usedConstants": [
"Eq.mpr",
"Preorder.toLT",
"Cardinal",
"congrArg",
"PartialOrder.toPreorder",
"Cardinal.mk",
"Cardinal.IsRegular.cof_ord",
"id",
"Card... | by rwa [isRegular_aleph0.cof_ord] | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.SetTheory.Ordinal.Arithmetic | {
"line": 1021,
"column": 65
} | {
"line": 1021,
"column": 79
} | [
{
"pp": "m n : ℕ\n⊢ ↑m * ↑n + ↑m = ↑m * ↑(n + 1)",
"usedConstants": [
"Eq.mpr",
"Nat.cast_succ",
"HMul.hMul",
"AddMonoid.toAddSemigroup",
"MulZeroClass.toMul",
"congrArg",
"id",
"AddMonoidWithOne.toNatCast",
"instOfNatNat",
"Nat.cast",
"Ordin... | Nat.cast_succ, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.LinearAlgebra.Basis.Cardinality | {
"line": 103,
"column": 4
} | {
"line": 106,
"column": 65
} | [
{
"pp": "case i.h.some\nR : Type u\nM : Type v\ninst✝³ : Semiring R\ninst✝² : AddCommMonoid M\ninst✝¹ : Nontrivial R\ninst✝ : Module R M\nι : Type w\nb : Basis ι R M\nκ : Type w'\nv : κ → M\nind : LinearIndependent R v\nm : ind.Maximal\ni : ι\nw : ∀ (x : κ), (b.repr (v x)) i = 0\nrepr_eq_zero : ∀ (l : κ →₀ R), ... | have l₁ : l.some = l'.some := ind <| b.repr.injective <| ext fun j ↦ by
obtain rfl | ne := eq_or_ne i j
· simp_rw [repr_eq_zero]
classical simpa [single_apply, ne] using congr(b.repr $z j) | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_tacticHave___1 | Lean.Parser.Tactic.tacticHave__ |
Mathlib.SetTheory.Cardinal.Cofinality | {
"line": 533,
"column": 4
} | {
"line": 533,
"column": 26
} | [
{
"pp": "case refine_1\no : Ordinal.{u}\nι : Type u\nf : ι → Ordinal.{u}\nhf : lsub f = o\na : o.ToType\nthis : ∃ i, (typein fun x1 x2 ↦ x1 < x2).toRelEmbedding a ≤ f i\n⊢ ∃ y ∈ ⇑(typein fun x1 x2 ↦ x1 < x2).toRelEmbedding ⁻¹' range f, a ≤ y",
"usedConstants": []
}
] | obtain ⟨i, hi⟩ := this | _private.Lean.Elab.Tactic.RCases.0.Lean.Elab.Tactic.RCases.evalObtain | Lean.Parser.Tactic.obtain |
Mathlib.Data.DFinsupp.Sigma | {
"line": 93,
"column": 6
} | {
"line": 93,
"column": 46
} | [
{
"pp": "case h.h.inl.inr\nι : Type u\nα : ι → Type u_2\nδ : (i : ι) → α i → Type v\ninst✝² : DecidableEq ι\ninst✝¹ : (i : ι) → DecidableEq (α i)\ninst✝ : (i : ι) → (j : α i) → Zero (δ i j)\ni : ι\nj : α i\nx : δ ⟨i, j⟩.fst ⟨i, j⟩.snd\nj' : α i\nhj : j' ≠ j\n⊢ (single ⟨i, j⟩ x) ⟨i, j'⟩ = (single j x) j'",
"... | rw [single_eq_of_ne, single_eq_of_ne hj] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.SetTheory.Cardinal.Cofinality | {
"line": 779,
"column": 6
} | {
"line": 780,
"column": 40
} | [
{
"pp": "case inr.a.refine_1\nα : Type u_1\nh : ∀ x < #α, 2 ^ x < #α\nha : #α ≠ 0\nh' : (#α).IsStrongLimit\nr : α → α → Prop\nwo : IsWellOrder α r\nhr : (#α).ord = type r\nthis : LinearOrder α := linearOrderOfSTO r\nx : α\n⊢ #↑{x} < (#α).ord.cof",
"usedConstants": [
"Eq.mpr",
"Cardinal.isSuccLim... | rw [mk_singleton, one_lt_cof_iff]
exact isSuccLimit_ord h'.aleph0_le | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.SetTheory.Cardinal.Cofinality | {
"line": 779,
"column": 6
} | {
"line": 780,
"column": 40
} | [
{
"pp": "case inr.a.refine_1\nα : Type u_1\nh : ∀ x < #α, 2 ^ x < #α\nha : #α ≠ 0\nh' : (#α).IsStrongLimit\nr : α → α → Prop\nwo : IsWellOrder α r\nhr : (#α).ord = type r\nthis : LinearOrder α := linearOrderOfSTO r\nx : α\n⊢ #↑{x} < (#α).ord.cof",
"usedConstants": [
"Eq.mpr",
"Cardinal.isSuccLim... | rw [mk_singleton, one_lt_cof_iff]
exact isSuccLimit_ord h'.aleph0_le | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Data.DFinsupp.Defs | {
"line": 487,
"column": 4
} | {
"line": 487,
"column": 34
} | [
{
"pp": "case mpr\nι : Type u\nβ : ι → Type v\ninst✝¹ : (i : ι) → Zero (β i)\ninst✝ : DecidableEq ι\ni j : ι\nxi : β i\nxj : β j\n⊢ i = j ∧ xi ≍ xj ∨ xi = 0 ∧ xj = 0 → single i xi = single j xj",
"usedConstants": [
"And",
"Zero.toOfNat0",
"HEq",
"Or",
"OfNat.ofNat",
"Eq"
... | rintro (⟨rfl, hxi⟩ | ⟨hi, hj⟩) | _private.Lean.Elab.Tactic.RCases.0.Lean.Elab.Tactic.RCases.evalRIntro | Lean.Parser.Tactic.rintro |
Mathlib.Data.DFinsupp.Defs | {
"line": 636,
"column": 2
} | {
"line": 636,
"column": 20
} | [
{
"pp": "case h.inr\nι : Type u\ninst✝¹ : DecidableEq ι\nβ : ι → Type u_1\ninst✝ : (i : ι) → AddZeroClass (β i)\nf : Π₀ (i : ι), β i\ni : ι\nb : β i\nj : ι\nh : i ≠ j\n⊢ (f.update i b) j = (single i b + erase i f) j",
"usedConstants": [
"Eq.recOn",
"False",
"eq_false",
"congrArg",
... | · simp [h, h.symm] | Lean.Elab.Tactic.evalTacticCDot | Lean.cdot |
Mathlib.Data.DFinsupp.Defs | {
"line": 643,
"column": 2
} | {
"line": 643,
"column": 20
} | [
{
"pp": "case h.inr\nι : Type u\ninst✝¹ : DecidableEq ι\nβ : ι → Type u_1\ninst✝ : (i : ι) → AddZeroClass (β i)\nf : Π₀ (i : ι), β i\ni : ι\nb : β i\nj : ι\nh : i ≠ j\n⊢ (f.update i b) j = (erase i f + single i b) j",
"usedConstants": [
"Eq.recOn",
"False",
"eq_false",
"congrArg",
... | · simp [h, h.symm] | Lean.Elab.Tactic.evalTacticCDot | Lean.cdot |
Mathlib.Data.DFinsupp.Defs | {
"line": 740,
"column": 2
} | {
"line": 740,
"column": 93
} | [
{
"pp": "case h.cons\nι : Type u\nβ : ι → Type v\ninst✝¹ : DecidableEq ι\ninst✝ : (i : ι) → AddZeroClass (β i)\np : (Π₀ (i : ι), β i) → Prop\nh0 : p 0\nha : ∀ (i : ι) (b : β i) (f : Π₀ (i : ι), β i), f i = 0 → b ≠ 0 → p f → p (single i b + f)\ni : ι\ns : Multiset ι\nih : ∀ (f : (i : ι) → β i) (H : ∀ (i : ι), i ... | have H3 : single i _ + _ = (⟨f, Trunc.mk ⟨i ::ₘ s, H⟩⟩ : Π₀ i, β i) := single_add_erase _ _ | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_tacticHave___1 | Lean.Parser.Tactic.tacticHave__ |
Mathlib.Data.DFinsupp.Defs | {
"line": 767,
"column": 40
} | {
"line": 767,
"column": 57
} | [
{
"pp": "ι : Type u\nβ : ι → Type v\ninst✝¹ : DecidableEq ι\ninst✝ : (i : ι) → Zero (β i)\ns : Finset ι\ni : ι\n⊢ (if H : i ∈ s then 0 ⟨i, H⟩ else 0) = 0 i",
"usedConstants": [
"Eq.mpr",
"congrArg",
"Finset",
"Membership.mem",
"DFinsupp.instDFunLike",
"Set.Elem",
"d... | split_ifs <;> rfl | Lean.Parser.Tactic.«_aux_Init_Tactics___macroRules_Lean_Parser_Tactic_tactic_<;>__1» | Lean.Parser.Tactic.«tactic_<;>_» |
Mathlib.Data.DFinsupp.Defs | {
"line": 793,
"column": 82
} | {
"line": 802,
"column": 86
} | [
{
"pp": "ι : Type u\nγ : Type w\nβ : ι → Type v\nβ₁ : ι → Type v₁\nβ₂ : ι → Type v₂\ninst✝² : DecidableEq ι\ninst✝¹ : (i : ι) → Zero (β i)\ninst✝ : (i : ι) → (x : β i) → Decidable (x ≠ 0)\nf : Π₀ (i : ι), β i\n⊢ ∀ (a b : { s // ∀ (i : ι), i ∈ s ∨ f.toFun i = 0 }),\n (fun xs ↦ {i ∈ (↑xs).toFinset | f i ≠ 0}) ... | by
rintro ⟨sx, hx⟩ ⟨sy, hy⟩
dsimp only [Subtype.coe_mk, toFun_eq_coe] at *
ext i; constructor
· intro H
rcases Finset.mem_filter.1 H with ⟨_, h⟩
exact Finset.mem_filter.2 ⟨Multiset.mem_toFinset.2 <| (hy i).resolve_right h, h⟩
· intro H
rcases Finset.mem_filter.1 H with ⟨_, h⟩
... | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Data.DFinsupp.BigOperators | {
"line": 403,
"column": 55
} | {
"line": 406,
"column": 61
} | [
{
"pp": "ι : Type u\nβ : ι → Type v\ninst✝³ : DecidableEq ι\nγ : Type w\nα : Type x\ninst✝² : (i : ι) → AddCommMonoid (β i)\ninst✝¹ : (i : ι) → (x : β i) → Decidable (x ≠ 0)\ninst✝ : CommMonoid γ\ns : Finset α\ng : α → Π₀ (i : ι), β i\nh : (i : ι) → β i → γ\nh_zero : ∀ (i : ι), h i 0 = 1\nh_add : ∀ (i : ι) (b₁ ... | by
classical
exact Finset.induction_on s (by simp [prod_zero_index])
(by simp +contextual [prod_add_index, h_zero, h_add]) | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Data.DFinsupp.Defs | {
"line": 961,
"column": 90
} | {
"line": 966,
"column": 38
} | [
{
"pp": "ι : Type u\nβ : ι → Type v\ninst✝³ : DecidableEq ι\ninst✝² : (i : ι) → Zero (β i)\ninst✝¹ : (i : ι) → (x : β i) → Decidable (x ≠ 0)\nf : Π₀ (i : ι), β i\ni : ι\nb : β i\ninst✝ : Decidable (b = 0)\n⊢ (f.update i b).support = if b = 0 then (erase i f).support else insert i f.support",
"usedConstants"... | by
ext j
split_ifs with hb
· subst hb
simp [update_eq_erase, support_erase]
· rw [support_update_ne_zero f _ hb] | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Data.DFinsupp.Defs | {
"line": 981,
"column": 35
} | {
"line": 981,
"column": 60
} | [
{
"pp": "case pos\nι : Type u\nβ : ι → Type v\ninst✝³ : DecidableEq ι\ninst✝² : (i : ι) → Zero (β i)\ninst✝¹ : (i : ι) → (x : β i) → Decidable (x ≠ 0)\np : ι → Prop\ninst✝ : DecidablePred p\nf : Π₀ (i : ι), β i\ni : Subtype p\nh2 : f ↑i ≠ 0\n⊢ (subtypeDomain p f) i = (mk (Finset.subtype p f.support) fun i ↦ f ↑... | try simp at h2; simp [h2] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_tacticTry__1 | Lean.Parser.Tactic.tacticTry_ |
Mathlib.Data.DFinsupp.Defs | {
"line": 981,
"column": 35
} | {
"line": 981,
"column": 60
} | [
{
"pp": "case neg\nι : Type u\nβ : ι → Type v\ninst✝³ : DecidableEq ι\ninst✝² : (i : ι) → Zero (β i)\ninst✝¹ : (i : ι) → (x : β i) → Decidable (x ≠ 0)\np : ι → Prop\ninst✝ : DecidablePred p\nf : Π₀ (i : ι), β i\ni : Subtype p\nh2 : ¬f ↑i ≠ 0\n⊢ (subtypeDomain p f) i = (mk (Finset.subtype p f.support) fun i ↦ f ... | try simp at h2; simp [h2] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_tacticTry__1 | Lean.Parser.Tactic.tacticTry_ |
Mathlib.LinearAlgebra.Dual.Defs | {
"line": 498,
"column": 81
} | {
"line": 499,
"column": 52
} | [
{
"pp": "R : Type u_1\nM : Type u_2\nM' : Type u_3\ninst✝⁴ : CommSemiring R\ninst✝³ : AddCommMonoid M\ninst✝² : Module R M\ninst✝¹ : AddCommMonoid M'\ninst✝ : Module R M'\nf : M →ₗ[R] M'\n⊢ f.dualMap.ker = (Dual.eval R M' ∘ₗ f).range.dualCoannihilator",
"usedConstants": [
"Submodule",
"RingHomSu... | by
ext x; simp [LinearMap.ext_iff (f := dualMap f x)] | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.LinearAlgebra.LinearIndependent.Lemmas | {
"line": 302,
"column": 41
} | {
"line": 302,
"column": 52
} | [
{
"pp": "R : Type u_2\nM : Type u_4\ninst✝⁹ : Ring R\ninst✝⁸ : AddCommGroup M\ninst✝⁷ : Module R M\nx y : M\nS : Type u_6\ninst✝⁶ : CommRing S\ninst✝⁵ : IsDomain S\ninst✝⁴ : Module S R\ninst✝³ : Module S M\ninst✝² : SMulCommClass S R M\ninst✝¹ : IsScalarTower S R M\ninst✝ : IsTorsionFree S R\nu : S\nhu : u ≠ 0\... | smul_assoc, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.LinearAlgebra.LinearIndependent.Lemmas | {
"line": 302,
"column": 53
} | {
"line": 302,
"column": 64
} | [
{
"pp": "R : Type u_2\nM : Type u_4\ninst✝⁹ : Ring R\ninst✝⁸ : AddCommGroup M\ninst✝⁷ : Module R M\nx y : M\nS : Type u_6\ninst✝⁶ : CommRing S\ninst✝⁵ : IsDomain S\ninst✝⁴ : Module S R\ninst✝³ : Module S M\ninst✝² : SMulCommClass S R M\ninst✝¹ : IsScalarTower S R M\ninst✝ : IsTorsionFree S R\nu : S\nhu : u ≠ 0\... | smul_assoc, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Tactic.Module | {
"line": 168,
"column": 2
} | {
"line": 168,
"column": 17
} | [
{
"pp": "case e_a.e_f.h\nR : Type u_2\nM : Type u_3\ninst✝² : AddCommMonoid M\ninst✝¹ : Semiring R\ninst✝ : Module R M\nl : NF R M\nx : M\nh :\n x =\n (map\n (fun x ↦\n match x with\n | (r, x) => r • x)\n l).sum\nr : R\np : R × M\n⊢ ((fun x ↦ x.1 • x.2) ∘ fun x ↦ (r * x.1, x.... | simp [mul_smul] | Lean.Elab.Tactic.evalSimp | Lean.Parser.Tactic.simp |
Mathlib.Algebra.Group.Pointwise.Set.ListOfFn | {
"line": 30,
"column": 21
} | {
"line": 30,
"column": 36
} | [
{
"pp": "case zero\nα : Type u_1\ninst✝ : Monoid α\nn : ℕ\na : α\ns : Fin 0 → Set α\n⊢ a ∈ (List.ofFn s).prod ↔ ∃ f, (List.ofFn fun i ↦ ↑(f i)).prod = a",
"usedConstants": [
"Eq.mpr",
"MulOne.toOne",
"Monoid.toMulOneClass",
"congrArg",
"Set.one",
"List.ofFn",
"Membe... | List.ofFn_zero, | Mathlib.Tactic._aux_Mathlib_Tactic_SimpRw___elabRules_Mathlib_Tactic_tacticSimp_rw____1 | null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.