module stringlengths 16 90 | startPos dict | endPos dict | goals listlengths 0 96 | ppTac stringlengths 1 14.5k | elaborator stringclasses 366
values | kind stringclasses 370
values |
|---|---|---|---|---|---|---|
Mathlib.Data.Finset.Lattice.Fold | {
"line": 759,
"column": 4
} | {
"line": 759,
"column": 18
} | [
{
"pp": "case refine_2\nα : Type u_2\nβ : Type u_3\ninst✝ : DecidableEq β\ns : Finset α\nf : α → Multiset β\nb : β\nthis : DecidableEq α := Classical.decEq α\n⊢ ∀ (a : α) (s : Finset α),\n a ∉ s →\n (count b (s.sup f) = s.sup fun a ↦ count b (f a)) →\n count b ((insert a s).sup f) = (insert a s).... | intro i s _ ih | Lean.Elab.Tactic.evalIntro | Lean.Parser.Tactic.intro |
Mathlib.Data.Finset.Powerset | {
"line": 79,
"column": 2
} | {
"line": 79,
"column": 33
} | [
{
"pp": "α : Type u_1\ns : Finset α\nβ : Type u_2\ninst✝ : DecidableEq β\nf : α → β\nH : Set.InjOn f ↑s\nthis : ∀ {z : Finset α} {a : α}, z ⊆ s → a ∈ s → (a ∈ z ↔ f a ∈ image f z)\n⊢ Set.InjOn (fun x ↦ image f x) ↑s.powerset",
"usedConstants": [
"Finset",
"Membership.mem",
"_private.Mathli... | exact fun _ _ _ _ _ => by grind | Lean.Elab.Tactic.evalExact | Lean.Parser.Tactic.exact |
Mathlib.Order.ConditionallyCompleteLattice.Indexed | {
"line": 213,
"column": 81
} | {
"line": 218,
"column": 71
} | [
{
"pp": "α : Type u_1\nι : Sort u_4\ninst✝ : ConditionallyCompleteLattice α\nκ : ι → Sort u_5\nf : (i : ι) → κ i → α\nH : BddBelow (⋃ i, range (f i))\n⊢ BddBelow (range fun i ↦ ⨅ j, f i j)",
"usedConstants": [
"iInf",
"lowerBounds",
"PartialOrder.toPreorder",
"Preorder.toLE",
"... | by
have ⟨a, h⟩ := H
refine ⟨a ⊓ (sInf ∅), fun x ⟨i, hx⟩ ↦ hx ▸ ?_⟩
cases isEmpty_or_nonempty <| κ i
· exact iInf_of_isEmpty (f i) ▸ inf_le_right
exact le_ciInf fun j ↦ inf_le_of_left_le <| h ⟨_, ⟨i, rfl⟩, ⟨j, rfl⟩⟩ | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Order.Cover | {
"line": 199,
"column": 2
} | {
"line": 199,
"column": 64
} | [
{
"pp": "α : Type u_1\ninst✝ : LT α\na b : α\nh : a < b\n⊢ ¬a ⋖ b ↔ ∃ c, a < c ∧ c < b",
"usedConstants": [
"Eq.mpr",
"congrArg",
"CovBy",
"Exists",
"_private.Mathlib.Order.Cover.0.not_covBy_iff._simp_1_4",
"id",
"iff_self",
"funext",
"And",
"Iff",... | simp_rw [CovBy, h, true_and, not_forall, exists_prop, not_not] | Mathlib.Tactic._aux_Mathlib_Tactic_SimpRw___elabRules_Mathlib_Tactic_tacticSimp_rw____1 | Mathlib.Tactic.tacticSimp_rw___ |
Mathlib.Order.Cover | {
"line": 199,
"column": 2
} | {
"line": 199,
"column": 64
} | [
{
"pp": "α : Type u_1\ninst✝ : LT α\na b : α\nh : a < b\n⊢ ¬a ⋖ b ↔ ∃ c, a < c ∧ c < b",
"usedConstants": [
"Eq.mpr",
"congrArg",
"CovBy",
"Exists",
"_private.Mathlib.Order.Cover.0.not_covBy_iff._simp_1_4",
"id",
"iff_self",
"funext",
"And",
"Iff",... | simp_rw [CovBy, h, true_and, not_forall, exists_prop, not_not] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Order.Cover | {
"line": 199,
"column": 2
} | {
"line": 199,
"column": 64
} | [
{
"pp": "α : Type u_1\ninst✝ : LT α\na b : α\nh : a < b\n⊢ ¬a ⋖ b ↔ ∃ c, a < c ∧ c < b",
"usedConstants": [
"Eq.mpr",
"congrArg",
"CovBy",
"Exists",
"_private.Mathlib.Order.Cover.0.not_covBy_iff._simp_1_4",
"id",
"iff_self",
"funext",
"And",
"Iff",... | simp_rw [CovBy, h, true_and, not_forall, exists_prop, not_not] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Order.Cover | {
"line": 463,
"column": 2
} | {
"line": 463,
"column": 72
} | [
{
"pp": "case pos\nα : Type u_1\nx : α\ns t : Set α\nhst : s ≤ t\nh2t : t ≤ insert x s\nh : x ∈ t\n⊢ t = s ∨ t = insert x s",
"usedConstants": [
"Iff.mpr",
"Membership.mem",
"subset_antisymm",
"Insert.insert",
"HasSubset.Subset",
"Set.instAntisymmSubset",
"Set.inser... | · exact Or.inr (subset_antisymm h2t <| insert_subset_iff.mpr ⟨h, hst⟩) | Lean.Elab.Tactic.evalTacticCDot | Lean.cdot |
Mathlib.Order.Cover | {
"line": 621,
"column": 2
} | {
"line": 621,
"column": 67
} | [
{
"pp": "ι : Type u_3\nα : ι → Type u_4\ninst✝ : (i : ι) → Preorder (α i)\na b : (i : ι) → α i\nh : ∀ ⦃c : (i : ι) → α i⦄, a ≤ c → ∀ (x : ι), a x < c x → c ≤ b → ∀ (x : ι), ¬c x < b x\nhab : a ≤ b\ni : ι\nhi : a i < b i\nj : ι\nhj : j ≠ i\nc : (i : ι) → α i := Function.update a i (b i)\nh₁ : c ≤ b\nh₂ : ¬c j < ... | exact ⟨hab j, by simpa [lt_iff_le_not_ge, hab j, c, hj] using h₂⟩ | Lean.Elab.Tactic.evalExact | Lean.Parser.Tactic.exact |
Mathlib.Data.List.MinMax | {
"line": 121,
"column": 14
} | {
"line": 121,
"column": 20
} | [
{
"pp": "α : Type u_1\nβ : Type u_2\ninst✝¹ : Preorder β\ninst✝ : DecidableLT β\nf : α → β\na : α\nl : List α\n⊢ foldl (argAux fun b c ↦ f c < f b) none (l ++ [a]) =\n Option.casesOn (argmax f l) (some a) fun c ↦ if f c < f a then some a else some c",
"usedConstants": [
"Eq.mpr",
"List.argmax... | argmax | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Data.List.MinMax | {
"line": 177,
"column": 4
} | {
"line": 177,
"column": 25
} | [
{
"pp": "α : Type u_1\nβ : Type u_2\ninst✝¹ : LinearOrder β\nf : α → β\ninst✝ : DecidableEq α\nhd : α\ntl : List α\nm a : α\nha : a ∈ hd :: tl\nham : f m ≤ f a\nhm : Option.rec (some hd) (fun val ↦ if f hd < f val then some val else some hd) (argmax f tl) = some m\n⊢ (bif hd == m then 0 else idxOf m tl + 1) ≤ b... | cases h : argmax f tl | _private.Lean.Elab.Tactic.Induction.0.Lean.Elab.Tactic.evalCases | Lean.Parser.Tactic.cases |
Mathlib.Order.Interval.Finset.Basic | {
"line": 186,
"column": 2
} | {
"line": 186,
"column": 37
} | [
{
"pp": "α : Type u_2\na₁ a₂ b : α\ninst✝¹ : Preorder α\ninst✝ : LocallyFiniteOrder α\nh : a₁ < a₂\n⊢ Ico a₂ b ⊆ Ioo a₁ b",
"usedConstants": [
"Eq.mpr",
"Finset.coe_Ico",
"congrArg",
"Finset",
"id",
"Finset.Ico",
"Finset.coe_Ioo",
"HasSubset.Subset",
"Se... | rw [← coe_subset, coe_Ico, coe_Ioo] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.Order.OrderIsoNat | {
"line": 200,
"column": 4
} | {
"line": 200,
"column": 52
} | [
{
"pp": "case refine_1\nα : Type u_1\ninst✝ : Preorder α\nh : WellFoundedGT α\na : ℕ →o α\nn : ℕ\nH : ∀ x ∈ Set.range ⇑a, ¬a n < x\n⊢ ∃ n, ∀ (m : ℕ), n ≤ m → ¬a n < a m",
"usedConstants": [
"Set.mem_range_self",
"Preorder.toLT",
"LE.le",
"instLENat",
"OrderHom.instFunLike",
... | exact ⟨n, fun m _ => H _ (Set.mem_range_self _)⟩ | Lean.Elab.Tactic.evalExact | Lean.Parser.Tactic.exact |
Mathlib.Order.WellFoundedSet | {
"line": 398,
"column": 8
} | {
"line": 398,
"column": 57
} | [
{
"pp": "ι : Type u_1\nα : ι → Type u_6\ninst✝¹ : Finite ι\nr : (i : ι) → α i → α i → Prop\ninst✝ : ∀ (i : ι), IsPreorder (α i) (r i)\ns : (i : ι) → Set (α i)\nhs : ∀ (i : ι), (s i).PartiallyWellOrderedOn (r i)\nthis✝¹ : Fintype ι\nthis✝ : IsPreorder ((i : ι) → α i) fun a b ↦ ∀ (i : ι), r i (a i) (b i)\nthis :\... | partiallyWellOrderedOn_iff_exists_monotone_subseq | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.GroupTheory.Subgroup.Center | {
"line": 141,
"column": 2
} | {
"line": 151,
"column": 18
} | [
{
"pp": "case refine_3\nG : Type u_2\ninst✝ : Group G\n⊢ Set.SurjOn ConjClasses.mk (↑(Subgroup.center G)) (noncenter G)ᶜ",
"usedConstants": [
"Iff.mpr",
"Eq.mpr",
"isConj_iff",
"HMul.hMul",
"DivInvOneMonoid.toInvOneClass",
"IsConj.setoid",
"Monoid.toMulOneClass",
... | · rintro ⟨g⟩ hg
refine ⟨g, ?_, rfl⟩
simp only [mem_noncenter, Set.compl_def, Set.mem_setOf, Set.not_nontrivial_iff] at hg
rw [SetLike.mem_coe, Subgroup.mem_center_iff]
intro h
rw [← mul_inv_eq_iff_eq_mul]
refine hg ?_ mem_carrier_mk
rw [mem_carrier_iff_mk_eq]
apply mk_eq_mk_iff_isConj.mp... | Lean.Elab.Tactic.evalTacticCDot | Lean.cdot |
Mathlib.Data.Finset.NoncommProd | {
"line": 166,
"column": 46
} | {
"line": 166,
"column": 51
} | [
{
"pp": "case h\nα : Type u_3\ninst✝ : Monoid α\np : α → Prop\nhom : ∀ (a b : α), p a → p b → p (a * b)\nunit : p 1\nl : List α\ncomm : {x | x ∈ ⟦l⟧}.Pairwise Commute\nbase : ∀ x ∈ ⟦l⟧, p x\n⊢ p (noncommProd ⟦l⟧ comm)",
"usedConstants": []
}
] | | _ l
=> | _private.Lean.Elab.Tactic.Induction.0.Lean.Elab.Tactic.evalInduction | null |
Mathlib.Data.Finset.NoncommProd | {
"line": 208,
"column": 46
} | {
"line": 208,
"column": 51
} | [
{
"pp": "case h\nα : Type u_3\ninst✝¹ : Monoid α\ninst✝ : DecidableEq α\na : α\nl : List α\nh : a ∈ ⟦l⟧\ncomm : {x | x ∈ ⟦l⟧}.Pairwise Commute\ncomm' : ∀ x ∈ {x | x ∈ erase ⟦l⟧ a}, ∀ x_1 ∈ {x | x ∈ erase ⟦l⟧ a}, x ≠ x_1 → Commute x x_1\n⊢ a * (erase ⟦l⟧ a).noncommProd comm' = noncommProd ⟦l⟧ comm",
"usedCon... | | _ l
=> | _private.Lean.Elab.Tactic.Induction.0.Lean.Elab.Tactic.evalInduction | null |
Mathlib.Data.Finset.NoncommProd | {
"line": 290,
"column": 2
} | {
"line": 290,
"column": 87
} | [
{
"pp": "α : Type u_3\nβ : Type u_4\ninst✝ : Monoid β\ns : Finset α\na : α\nf : α → β\nha : a ∉ s\ncomm : (↑(cons a s ha)).Pairwise (Commute on f)\n⊢ (cons a s ha).noncommProd f comm = s.noncommProd f ⋯ * f a",
"usedConstants": [
"Iff.mpr",
"Eq.mpr",
"Multiset.Mem._proof_1",
"HMul.hM... | simp_rw [noncommProd, Finset.cons_val, Multiset.map_cons, Multiset.noncommProd_cons'] | Mathlib.Tactic._aux_Mathlib_Tactic_SimpRw___elabRules_Mathlib_Tactic_tacticSimp_rw____1 | Mathlib.Tactic.tacticSimp_rw___ |
Mathlib.Data.Finset.NoncommProd | {
"line": 290,
"column": 2
} | {
"line": 290,
"column": 87
} | [
{
"pp": "α : Type u_3\nβ : Type u_4\ninst✝ : Monoid β\ns : Finset α\na : α\nf : α → β\nha : a ∉ s\ncomm : (↑(cons a s ha)).Pairwise (Commute on f)\n⊢ (cons a s ha).noncommProd f comm = s.noncommProd f ⋯ * f a",
"usedConstants": [
"Iff.mpr",
"Eq.mpr",
"Multiset.Mem._proof_1",
"HMul.hM... | simp_rw [noncommProd, Finset.cons_val, Multiset.map_cons, Multiset.noncommProd_cons'] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Data.Finset.NoncommProd | {
"line": 290,
"column": 2
} | {
"line": 290,
"column": 87
} | [
{
"pp": "α : Type u_3\nβ : Type u_4\ninst✝ : Monoid β\ns : Finset α\na : α\nf : α → β\nha : a ∉ s\ncomm : (↑(cons a s ha)).Pairwise (Commute on f)\n⊢ (cons a s ha).noncommProd f comm = s.noncommProd f ⋯ * f a",
"usedConstants": [
"Iff.mpr",
"Eq.mpr",
"Multiset.Mem._proof_1",
"HMul.hM... | simp_rw [noncommProd, Finset.cons_val, Multiset.map_cons, Multiset.noncommProd_cons'] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.GroupTheory.Congruence.Defs | {
"line": 405,
"column": 10
} | {
"line": 405,
"column": 37
} | [
{
"pp": "case of\nM : Type u_1\ninst✝ : Mul M\nr : M → M → Prop\ns : Con M\nhs : s ∈ {s | ∀ (x y : M), r x y → s x y}\nx y : M\nhxy : (conGen r) x y\n⊢ ∀ (x y : M), r x y → s x y",
"usedConstants": []
}
] | exact fun x y h => hs x y h | Lean.Elab.Tactic.evalExact | Lean.Parser.Tactic.exact |
Mathlib.GroupTheory.Congruence.Defs | {
"line": 405,
"column": 10
} | {
"line": 405,
"column": 37
} | [
{
"pp": "case of\nM : Type u_1\ninst✝ : Mul M\nr : M → M → Prop\ns : Con M\nhs : s ∈ {s | ∀ (x y : M), r x y → s x y}\nx y : M\nhxy : (conGen r) x y\n⊢ ∀ (x y : M), r x y → s x y",
"usedConstants": []
}
] | exact fun x y h => hs x y h | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.GroupTheory.Congruence.Defs | {
"line": 405,
"column": 10
} | {
"line": 405,
"column": 37
} | [
{
"pp": "case of\nM : Type u_1\ninst✝ : Mul M\nr : M → M → Prop\ns : Con M\nhs : s ∈ {s | ∀ (x y : M), r x y → s x y}\nx y : M\nhxy : (conGen r) x y\n⊢ ∀ (x y : M), r x y → s x y",
"usedConstants": []
}
] | exact fun x y h => hs x y h | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.GroupTheory.Finiteness | {
"line": 128,
"column": 64
} | {
"line": 132,
"column": 94
} | [
{
"pp": "ι : Type u_3\ninst✝² : Finite ι\nM : ι → Type u_4\ninst✝¹ : (i : ι) → Monoid (M i)\nP : (i : ι) → Submonoid (M i)\ninst✝ : DecidableEq ι\n⊢ ⨆ i, map (MonoidHom.mulSingle M i) (P i) = pi Set.univ P",
"usedConstants": [
"Eq.mpr",
"MonoidHom.instMonoidHomClass",
"MulOne.toOne",
... | by
haveI := Fintype.ofFinite ι
refine iSup_map_mulSingle_le.antisymm fun x hx => ?_
rw [← Finset.noncommProd_mulSingle x]
exact noncommProd_mem _ _ _ _ fun i _ => mem_iSup_of_mem _ (mem_map_of_mem _ (hx i trivial)) | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.GroupTheory.FreeAbelianGroup | {
"line": 322,
"column": 19
} | {
"line": 322,
"column": 52
} | [
{
"pp": "α : Type u\nG : Type u_1\nβ α✝ : Type u\nx✝ : FreeAbelianGroup α✝\nx : α✝\nih : id <$> pure x = pure x\n⊢ id <$> (-pure x) = -pure x",
"usedConstants": [
"Pure.pure",
"Eq.mpr",
"NegZeroClass.toNeg",
"congrArg",
"Monad.toApplicative",
"id",
"FreeAbelianGroup... | rw [FreeAbelianGroup.map_neg, ih] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.GroupTheory.FreeAbelianGroup | {
"line": 322,
"column": 19
} | {
"line": 322,
"column": 52
} | [
{
"pp": "α : Type u\nG : Type u_1\nβ α✝ : Type u\nx✝ : FreeAbelianGroup α✝\nx : α✝\nih : id <$> pure x = pure x\n⊢ id <$> (-pure x) = -pure x",
"usedConstants": [
"Pure.pure",
"Eq.mpr",
"NegZeroClass.toNeg",
"congrArg",
"Monad.toApplicative",
"id",
"FreeAbelianGroup... | rw [FreeAbelianGroup.map_neg, ih] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.GroupTheory.FreeAbelianGroup | {
"line": 322,
"column": 19
} | {
"line": 322,
"column": 52
} | [
{
"pp": "α : Type u\nG : Type u_1\nβ α✝ : Type u\nx✝ : FreeAbelianGroup α✝\nx : α✝\nih : id <$> pure x = pure x\n⊢ id <$> (-pure x) = -pure x",
"usedConstants": [
"Pure.pure",
"Eq.mpr",
"NegZeroClass.toNeg",
"congrArg",
"Monad.toApplicative",
"id",
"FreeAbelianGroup... | rw [FreeAbelianGroup.map_neg, ih] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.GroupTheory.FreeAbelianGroup | {
"line": 341,
"column": 18
} | {
"line": 341,
"column": 69
} | [
{
"pp": "case neg\nα : Type u\nG : Type u_1\nβ α✝ β✝ : Type u\ny : FreeAbelianGroup β✝\np : α✝\nih : Prod.mk <$> pure p <*> y = (fun b a ↦ (a, b)) <$> y <*> pure p\n⊢ Prod.mk <$> (-pure p) <*> y = (fun b a ↦ (a, b)) <$> y <*> -pure p",
"usedConstants": [
"Pure.pure",
"Eq.mpr",
"NegZeroClas... | rw [FreeAbelianGroup.map_neg, neg_seq, seq_neg, ih] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.GroupTheory.FreeAbelianGroup | {
"line": 341,
"column": 18
} | {
"line": 341,
"column": 69
} | [
{
"pp": "case neg\nα : Type u\nG : Type u_1\nβ α✝ β✝ : Type u\ny : FreeAbelianGroup β✝\np : α✝\nih : Prod.mk <$> pure p <*> y = (fun b a ↦ (a, b)) <$> y <*> pure p\n⊢ Prod.mk <$> (-pure p) <*> y = (fun b a ↦ (a, b)) <$> y <*> -pure p",
"usedConstants": [
"Pure.pure",
"Eq.mpr",
"NegZeroClas... | rw [FreeAbelianGroup.map_neg, neg_seq, seq_neg, ih] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.GroupTheory.FreeAbelianGroup | {
"line": 341,
"column": 18
} | {
"line": 341,
"column": 69
} | [
{
"pp": "case neg\nα : Type u\nG : Type u_1\nβ α✝ β✝ : Type u\ny : FreeAbelianGroup β✝\np : α✝\nih : Prod.mk <$> pure p <*> y = (fun b a ↦ (a, b)) <$> y <*> pure p\n⊢ Prod.mk <$> (-pure p) <*> y = (fun b a ↦ (a, b)) <$> y <*> -pure p",
"usedConstants": [
"Pure.pure",
"Eq.mpr",
"NegZeroClas... | rw [FreeAbelianGroup.map_neg, neg_seq, seq_neg, ih] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.GroupTheory.OreLocalization.Basic | {
"line": 79,
"column": 6
} | {
"line": 79,
"column": 79
} | [
{
"pp": "case refine_2\nR : Type u_1\ninst✝² : Monoid R\nS : Submonoid R\ninst✝¹ : OreSet S\nX : Type ?u.117\ninst✝ : MulAction R X\n⊢ ∀ {x y z : X × ↥S},\n (∃ u v, u • y.fst = v • x.fst ∧ ↑u * ↑y.snd = v * ↑x.snd) →\n (∃ u v, u • z.fst = v • y.fst ∧ ↑u * ↑z.snd = v * ↑y.snd) →\n ∃ u v, u • z.fst... | rintro ⟨r₁, s₁⟩ ⟨r₂, s₂⟩ ⟨r₃, s₃⟩ ⟨u, v, hur₁, hs₁u⟩ ⟨u', v', hur₂, hs₂u⟩ | _private.Lean.Elab.Tactic.RCases.0.Lean.Elab.Tactic.RCases.evalRIntro | Lean.Parser.Tactic.rintro |
Mathlib.GroupTheory.OreLocalization.Basic | {
"line": 83,
"column": 42
} | {
"line": 83,
"column": 46
} | [
{
"pp": "case refine_2.refine_1\nR : Type u_1\ninst✝² : Monoid R\nS : Submonoid R\ninst✝¹ : OreSet S\nX : Type ?u.117\ninst✝ : MulAction R X\nr₁ : X\ns₁ : ↥S\nr₂ : X\ns₂ : ↥S\nr₃ : X\ns₃ u : ↥S\nv : R\nhur₁ : ↑u • r₂ = v • r₁\nhs₁u : ↑u * ↑s₂ = v * ↑s₁\nu' : ↥S\nv' : R\nhur₂ : ↑u' • r₃ = v' • r₂\nhs₂u : ↑u' * ↑... | hur₁ | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.GroupTheory.MonoidLocalization.Maps | {
"line": 365,
"column": 2
} | {
"line": 365,
"column": 92
} | [
{
"pp": "M : Type u_1\ninst✝³ : CommMonoid M\nS : Submonoid M\nN : Type u_2\ninst✝² : CommMonoid N\nP : Type u_3\ninst✝¹ : CommMonoid P\nf : S.LocalizationMap N\ng : M →* P\nT : Submonoid P\nhy : ∀ (y : ↥S), g ↑y ∈ T\nQ : Type u_4\ninst✝ : CommMonoid Q\nk : T.LocalizationMap Q\nor : Set.SurjOn ⇑g ↑S ↑T ∨ Inject... | have : k (g z') = k (g w') := by rw [← ifkg, ← ifkg, ← hxz, ← hxw, map_mul, map_mul, hizw] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_tacticHave___1 | Lean.Parser.Tactic.tacticHave__ |
Mathlib.Algebra.Ring.Equiv | {
"line": 470,
"column": 2
} | {
"line": 470,
"column": 84
} | [
{
"pp": "case a\nR : Type u_4\nS : Type u_5\ninst✝¹ : NonUnitalNonAssocSemiring R\ninst✝ : NonUnitalNonAssocSemiring S\nf : R →ₙ+* S\nhf : Function.Bijective ⇑f\nx✝ : S\n⊢ (f.comp ↑(ofBijective f hf).symm) x✝ = (NonUnitalRingHom.id S) x✝",
"usedConstants": [
"RingEquiv.apply_symm_apply",
"MulHom... | exact (RingEquiv.ofBijective f hf).symm.injective <| RingEquiv.apply_symm_apply .. | Lean.Elab.Tactic.evalExact | Lean.Parser.Tactic.exact |
Mathlib.GroupTheory.MonoidLocalization.Basic | {
"line": 532,
"column": 2
} | {
"line": 533,
"column": 14
} | [
{
"pp": "M : Type u_1\ninst✝¹ : CommMonoid M\nS : Submonoid M\nN : Type u_2\ninst✝ : CommMonoid N\nf : M →* N\nh : ∀ (y : ↥S), IsUnit (f ↑y)\ny : ↥S\nz : N\nH : f ↑y * z = 1\n⊢ ↑((IsUnit.liftRight (f.restrict S) h) y)⁻¹ = z",
"usedConstants": [
"IsUnit.liftRight",
"Units.val",
"Eq.mpr",
... | rw [← one_mul _⁻¹, Units.val_mul, mul_inv_left]
exact H.symm | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.GroupTheory.MonoidLocalization.Basic | {
"line": 532,
"column": 2
} | {
"line": 533,
"column": 14
} | [
{
"pp": "M : Type u_1\ninst✝¹ : CommMonoid M\nS : Submonoid M\nN : Type u_2\ninst✝ : CommMonoid N\nf : M →* N\nh : ∀ (y : ↥S), IsUnit (f ↑y)\ny : ↥S\nz : N\nH : f ↑y * z = 1\n⊢ ↑((IsUnit.liftRight (f.restrict S) h) y)⁻¹ = z",
"usedConstants": [
"IsUnit.liftRight",
"Units.val",
"Eq.mpr",
... | rw [← one_mul _⁻¹, Units.val_mul, mul_inv_left]
exact H.symm | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.GroupTheory.MonoidLocalization.Basic | {
"line": 855,
"column": 2
} | {
"line": 855,
"column": 20
} | [
{
"pp": "M : Type u_1\nN : Type u_2\ninst✝¹ : CommMonoid M\nS : Submonoid M\ninst✝ : CommMonoid N\nf : S.LocalizationMap N\n⊢ (∀ ⦃a₁ a₂ : M⦄, ∀ a ∈ S, a * a₁ = a * a₂ → a₁ = a₂) ↔ ∀ ⦃x : M⦄, x ∈ S → ∀ ⦃a₁ a₂ : M⦄, x * a₁ = x * a₂ → a₁ = a₂",
"usedConstants": [
"HMul.hMul",
"Monoid.toMulOneClass"... | exact forall₂_comm | Lean.Elab.Tactic.evalExact | Lean.Parser.Tactic.exact |
Mathlib.Algebra.Order.Ring.WithTop | {
"line": 65,
"column": 12
} | {
"line": 65,
"column": 35
} | [
{
"pp": "α : Type u_1\ninst✝¹ : DecidableEq α\ninst✝ : MulZeroClass α\nb : α\nhb : b ≠ 0\n⊢ ⊤ * ↑b = Option.bind ⊤ fun a ↦ Option.some (a * b)",
"usedConstants": [
"Eq.mpr",
"False",
"HMul.hMul",
"eq_false",
"WithTop.top_mul",
"MulZeroClass.toMul",
"congrArg",
... | simp [top_mul, hb]; rfl | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Algebra.Order.Ring.WithTop | {
"line": 65,
"column": 12
} | {
"line": 65,
"column": 35
} | [
{
"pp": "α : Type u_1\ninst✝¹ : DecidableEq α\ninst✝ : MulZeroClass α\nb : α\nhb : b ≠ 0\n⊢ ⊤ * ↑b = Option.bind ⊤ fun a ↦ Option.some (a * b)",
"usedConstants": [
"Eq.mpr",
"False",
"HMul.hMul",
"eq_false",
"WithTop.top_mul",
"MulZeroClass.toMul",
"congrArg",
... | simp [top_mul, hb]; rfl | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Algebra.Order.Ring.WithTop | {
"line": 277,
"column": 2
} | {
"line": 277,
"column": 58
} | [
{
"pp": "case inr.inr\nα : Type u_1\ninst✝⁵ : DecidableEq α\ninst✝⁴ : CommSemiring α\ninst✝³ : PartialOrder α\ninst✝² : OrderBot α\ninst✝¹ : CanonicallyOrderedAdd α\ninst✝ : PosMulStrictMono α\nthis : MulPosStrictMono α\na₁ b₁ a₂ b₂ : α\nha : a₁ < a₂\nhb : b₁ < b₂\n⊢ a₁ * b₁ < a₂ * b₂",
"usedConstants": [
... | exact CanonicallyOrderedAdd.mul_lt_mul_of_lt_of_lt ha hb | Lean.Elab.Tactic.evalExact | Lean.Parser.Tactic.exact |
Mathlib.Algebra.Order.Ring.WithTop | {
"line": 286,
"column": 4
} | {
"line": 286,
"column": 78
} | [
{
"pp": "α : Type u_1\ninst✝⁷ : DecidableEq α\ninst✝⁶ : CommSemiring α\ninst✝⁵ : PartialOrder α\ninst✝⁴ : OrderBot α\ninst✝³ : CanonicallyOrderedAdd α\ninst✝² : PosMulStrictMono α\ninst✝¹ : NoZeroDivisors α\ninst✝ : Nontrivial α\nn : ℕ\nx✝ : n + 2 ≠ 0\nx y : WithTop α\nh : x < y\n⊢ x ^ (n + 1) * x < y ^ (n + 1)... | exact WithTop.mul_lt_mul (WithTop.pow_right_strictMono n.succ_ne_zero h) h | Lean.Elab.Tactic.evalExact | Lean.Parser.Tactic.exact |
Mathlib.Algebra.Order.SuccPred | {
"line": 54,
"column": 25
} | {
"line": 54,
"column": 52
} | [
{
"pp": "α : Type u_1\nx y : α\ninst✝³ : Preorder α\ninst✝² : Add α\ninst✝¹ : One α\ninst✝ : SuccAddOrder α\nhx : ¬IsMax x\n⊢ succ x ≤ y ↔ x < y",
"usedConstants": [
"Eq.mpr",
"Preorder.toLT",
"Order.succ",
"congrArg",
"Preorder.toLE",
"Order.succ_le_iff_of_not_isMax",
... | succ_le_iff_of_not_isMax hx | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Order.SuccPred.Basic | {
"line": 756,
"column": 6
} | {
"line": 756,
"column": 42
} | [
{
"pp": "case neg\nα : Type u_1\nβ : Type u_2\ninst✝² : PartialOrder α\ninst✝¹ : SuccOrder α\ninst✝ : (a : α) → Decidable (succ a = a)\na✝¹ a✝ : α\nh : a✝ < a✝¹\nha : ¬succ a✝ = a✝\n⊢ ↑(succ a✝) ≤ ↑a✝¹",
"usedConstants": [
"Iff.mpr",
"Order.succ",
"PartialOrder.toPreorder",
"Preorder... | exact coe_le_coe.2 (succ_le_of_lt h) | Lean.Elab.Tactic.evalExact | Lean.Parser.Tactic.exact |
Mathlib.Order.SuccPred.Basic | {
"line": 756,
"column": 6
} | {
"line": 756,
"column": 42
} | [
{
"pp": "case neg\nα : Type u_1\nβ : Type u_2\ninst✝² : PartialOrder α\ninst✝¹ : SuccOrder α\ninst✝ : (a : α) → Decidable (succ a = a)\na✝¹ a✝ : α\nh : a✝ < a✝¹\nha : ¬succ a✝ = a✝\n⊢ ↑(succ a✝) ≤ ↑a✝¹",
"usedConstants": [
"Iff.mpr",
"Order.succ",
"PartialOrder.toPreorder",
"Preorder... | exact coe_le_coe.2 (succ_le_of_lt h) | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Order.SuccPred.Basic | {
"line": 756,
"column": 6
} | {
"line": 756,
"column": 42
} | [
{
"pp": "case neg\nα : Type u_1\nβ : Type u_2\ninst✝² : PartialOrder α\ninst✝¹ : SuccOrder α\ninst✝ : (a : α) → Decidable (succ a = a)\na✝¹ a✝ : α\nh : a✝ < a✝¹\nha : ¬succ a✝ = a✝\n⊢ ↑(succ a✝) ≤ ↑a✝¹",
"usedConstants": [
"Iff.mpr",
"Order.succ",
"PartialOrder.toPreorder",
"Preorder... | exact coe_le_coe.2 (succ_le_of_lt h) | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Order.SuccPred.Basic | {
"line": 805,
"column": 42
} | {
"line": 805,
"column": 65
} | [
{
"pp": "α : Type u_1\nβ : Type u_2\ninst✝² : Preorder α\ninst✝¹ : OrderTop α\ninst✝ : PredOrder α\na : WithTop α\nha : a ≠ ⊤\n⊢ pred a ≠ ⊤",
"usedConstants": [
"False",
"WithTop.instPreorder",
"congrArg",
"WithTop.coe_ne_top._simp_1",
"Preorder.toLE",
"Ne",
"WithTo... | by induction a <;> simp | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Order.SuccPred.Limit | {
"line": 186,
"column": 4
} | {
"line": 186,
"column": 15
} | [
{
"pp": "α : Type u_1\ninst✝ : Preorder α\ns : Set α\nhs : IsLowerSet s\na : ↑s\nha : IsSuccPrelimit a\nb : α\nhb : b ⋖ ↑a\nthis : ¬⟨b, ⋯⟩ ⋖ a\n⊢ ⟨b, ⋯⟩ < a",
"usedConstants": [
"Preorder.toLT",
"Membership.mem",
"CovBy.lt",
"Subtype.val",
"Set.instMembership",
"Set"
... | exact hb.lt | Lean.Elab.Tactic.evalExact | Lean.Parser.Tactic.exact |
Mathlib.Order.SuccPred.Limit | {
"line": 186,
"column": 4
} | {
"line": 186,
"column": 15
} | [
{
"pp": "α : Type u_1\ninst✝ : Preorder α\ns : Set α\nhs : IsLowerSet s\na : ↑s\nha : IsSuccPrelimit a\nb : α\nhb : b ⋖ ↑a\nthis : ¬⟨b, ⋯⟩ ⋖ a\n⊢ ⟨b, ⋯⟩ < a",
"usedConstants": [
"Preorder.toLT",
"Membership.mem",
"CovBy.lt",
"Subtype.val",
"Set.instMembership",
"Set"
... | exact hb.lt | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Order.SuccPred.Limit | {
"line": 186,
"column": 4
} | {
"line": 186,
"column": 15
} | [
{
"pp": "α : Type u_1\ninst✝ : Preorder α\ns : Set α\nhs : IsLowerSet s\na : ↑s\nha : IsSuccPrelimit a\nb : α\nhb : b ⋖ ↑a\nthis : ¬⟨b, ⋯⟩ ⋖ a\n⊢ ⟨b, ⋯⟩ < a",
"usedConstants": [
"Preorder.toLT",
"Membership.mem",
"CovBy.lt",
"Subtype.val",
"Set.instMembership",
"Set"
... | exact hb.lt | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Data.ENat.Basic | {
"line": 261,
"column": 4
} | {
"line": 261,
"column": 32
} | [
{
"pp": "case coe.top\na✝ : ℕ\n⊢ (↑a✝ * ⊤).toNat = (↑a✝).toNat * ⊤.toNat",
"usedConstants": [
"False",
"Nat.instMulZeroClass",
"NeZero.one",
"instCharZeroENat",
"instAddMonoidWithOneENat",
"HMul.hMul",
"AddMonoid.toAddSemigroup",
"ENat.instNatCast",
"ins... | rename_i a; cases a <;> simp | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Data.ENat.Basic | {
"line": 261,
"column": 4
} | {
"line": 261,
"column": 32
} | [
{
"pp": "case coe.top\na✝ : ℕ\n⊢ (↑a✝ * ⊤).toNat = (↑a✝).toNat * ⊤.toNat",
"usedConstants": [
"False",
"Nat.instMulZeroClass",
"NeZero.one",
"instCharZeroENat",
"instAddMonoidWithOneENat",
"HMul.hMul",
"AddMonoid.toAddSemigroup",
"ENat.instNatCast",
"ins... | rename_i a; cases a <;> simp | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Order.SuccPred.Limit | {
"line": 410,
"column": 97
} | {
"line": 411,
"column": 73
} | [
{
"pp": "α : Type u_1\na : α\ninst✝² : PartialOrder α\ninst✝¹ : SuccOrder α\ninst✝ : NoMaxOrder α\n⊢ ¬IsSuccPrelimit a ↔ a ∈ range succ",
"usedConstants": [
"Eq.mpr",
"Preorder.toLT",
"Order.succ",
"Order.IsSuccPrelimit",
"congrArg",
"PartialOrder.toPreorder",
"Memb... | by
simp_rw [isSuccPrelimit_iff_succ_ne, not_forall, not_ne_iff, mem_range] | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Order.SuccPred.Limit | {
"line": 487,
"column": 2
} | {
"line": 490,
"column": 15
} | [
{
"pp": "α : Type u_1\na : α\ninst✝ : LinearOrder α\ns : Set α\nhs : IsLUB s a\nha : a ∉ s\n⊢ IsSuccPrelimit a",
"usedConstants": [
"False",
"Preorder.toLT",
"CovBy",
"False.elim",
"PartialOrder.toPreorder",
"IsLUB.exists_between",
"Preorder.toLE",
"Membership... | intro b hb
obtain ⟨c, hc, hbc, hca⟩ := hs.exists_between hb.lt
obtain rfl := (hb.ge_of_gt hbc).antisymm hca
contradiction | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Order.SuccPred.Limit | {
"line": 487,
"column": 2
} | {
"line": 490,
"column": 15
} | [
{
"pp": "α : Type u_1\na : α\ninst✝ : LinearOrder α\ns : Set α\nhs : IsLUB s a\nha : a ∉ s\n⊢ IsSuccPrelimit a",
"usedConstants": [
"False",
"Preorder.toLT",
"CovBy",
"False.elim",
"PartialOrder.toPreorder",
"IsLUB.exists_between",
"Preorder.toLE",
"Membership... | intro b hb
obtain ⟨c, hc, hbc, hca⟩ := hs.exists_between hb.lt
obtain rfl := (hb.ge_of_gt hbc).antisymm hca
contradiction | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Algebra.BigOperators.Group.Finset.Piecewise | {
"line": 308,
"column": 2
} | {
"line": 308,
"column": 47
} | [
{
"pp": "ι : Type u_1\nM : Type u_3\ninst✝² : CommMonoid M\ninst✝¹ : Fintype ι\ninst✝ : DecidableEq ι\ni : ι\nf : ι → M\n⊢ (∏ j, if j = i then f j else 1) = f i",
"usedConstants": [
"Finset.mem_univ",
"Eq.mpr",
"MulOne.toOne",
"Finset.univ",
"Monoid.toMulOneClass",
"congr... | rw [Finset.prod_ite_eq', if_pos (mem_univ _)] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.Algebra.BigOperators.Group.Finset.Piecewise | {
"line": 308,
"column": 2
} | {
"line": 308,
"column": 47
} | [
{
"pp": "ι : Type u_1\nM : Type u_3\ninst✝² : CommMonoid M\ninst✝¹ : Fintype ι\ninst✝ : DecidableEq ι\ni : ι\nf : ι → M\n⊢ (∏ j, if j = i then f j else 1) = f i",
"usedConstants": [
"Finset.mem_univ",
"Eq.mpr",
"MulOne.toOne",
"Finset.univ",
"Monoid.toMulOneClass",
"congr... | rw [Finset.prod_ite_eq', if_pos (mem_univ _)] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Algebra.BigOperators.Group.Finset.Piecewise | {
"line": 308,
"column": 2
} | {
"line": 308,
"column": 47
} | [
{
"pp": "ι : Type u_1\nM : Type u_3\ninst✝² : CommMonoid M\ninst✝¹ : Fintype ι\ninst✝ : DecidableEq ι\ni : ι\nf : ι → M\n⊢ (∏ j, if j = i then f j else 1) = f i",
"usedConstants": [
"Finset.mem_univ",
"Eq.mpr",
"MulOne.toOne",
"Finset.univ",
"Monoid.toMulOneClass",
"congr... | rw [Finset.prod_ite_eq', if_pos (mem_univ _)] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Data.Vector.Basic | {
"line": 59,
"column": 42
} | {
"line": 59,
"column": 58
} | [
{
"pp": "α : Type u_1\nn : ℕ\na : α\nv : Vector α n.succ\nv' : Vector α n\nh : v.head = a ∧ v.tail = v'\n⊢ v.head ::ᵥ v.tail = a ::ᵥ v'",
"usedConstants": [
"Eq.mpr",
"congrArg",
"List.Vector.head",
"List.Vector",
"HSub.hSub",
"id",
"instSubNat",
"instOfNatNat... | by rw [h.1, h.2] | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Data.Sym.Basic | {
"line": 482,
"column": 6
} | {
"line": 482,
"column": 86
} | [
{
"pp": "α : Type u_1\nβ : Type u_2\nn n' m : ℕ\ns✝ : Sym α n\na✝ b : α\ns : Sym α 1\nx✝¹ x✝ : { x // x.length = 1 }\nval✝ : List α\nproperty✝ : val✝.length = 1\na : α\nh : [a].length = 1\nperm : ⟨val✝, property✝⟩ ≈ ⟨[a], h⟩\n⊢ (fun l ↦ (↑l).head ⋯) ⟨val✝, property✝⟩ = (fun l ↦ (↑l).head ⋯) ⟨[a], h⟩",
"used... | exact List.eq_of_mem_singleton (List.Perm.mem_iff perm |>.mp <| List.head_mem _) | Lean.Elab.Tactic.evalExact | Lean.Parser.Tactic.exact |
Mathlib.Data.Vector.Basic | {
"line": 238,
"column": 20
} | {
"line": 238,
"column": 62
} | [
{
"pp": "α : Type u_1\nn : ℕ\nv : Vector α n\n⊢ (map id v).toList = v.toList",
"usedConstants": [
"congrArg",
"List.map_id",
"List.map",
"List.Vector.map",
"id",
"List.Vector.toList_map",
"List",
"True",
"eq_self",
"of_eq_true",
"congrFun'",
... | simp only [List.map_id, Vector.toList_map] | Lean.Elab.Tactic.evalSimp | Lean.Parser.Tactic.simp |
Mathlib.Data.Vector.Basic | {
"line": 238,
"column": 20
} | {
"line": 238,
"column": 62
} | [
{
"pp": "α : Type u_1\nn : ℕ\nv : Vector α n\n⊢ (map id v).toList = v.toList",
"usedConstants": [
"congrArg",
"List.map_id",
"List.map",
"List.Vector.map",
"id",
"List.Vector.toList_map",
"List",
"True",
"eq_self",
"of_eq_true",
"congrFun'",
... | simp only [List.map_id, Vector.toList_map] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Data.Vector.Basic | {
"line": 238,
"column": 20
} | {
"line": 238,
"column": 62
} | [
{
"pp": "α : Type u_1\nn : ℕ\nv : Vector α n\n⊢ (map id v).toList = v.toList",
"usedConstants": [
"congrArg",
"List.map_id",
"List.map",
"List.Vector.map",
"id",
"List.Vector.toList_map",
"List",
"True",
"eq_self",
"of_eq_true",
"congrFun'",
... | simp only [List.map_id, Vector.toList_map] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Data.Fintype.BigOperators | {
"line": 181,
"column": 8
} | {
"line": 181,
"column": 22
} | [
{
"pp": "ι : Type u_4\nκ : Type u_5\ninst✝² : DecidableEq ι\ninst✝¹ : DecidableEq κ\ninst✝ : Fintype ι\ns : Finset κ\ni : ι\nx : κ\nhx : x ∈ s\n⊢ ∏ j ∈ univ.erase i, #s = #s ^ (card ι - 1)",
"usedConstants": [
"Eq.mpr",
"Finset.univ",
"congrArg",
"Nat.instMonoid",
"HSub.hSub",
... | prod_const #s, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Data.Fintype.BigOperators | {
"line": 192,
"column": 8
} | {
"line": 192,
"column": 22
} | [
{
"pp": "ι : Type u_4\nκ : Type u_5\ninst✝² : DecidableEq ι\ninst✝¹ : DecidableEq κ\ninst✝ : Fintype ι\ns : Finset κ\ni : ι\nj : κ\n⊢ (if j ∈ s then ∏ b ∈ univ.erase i, #s else 0) = if j ∈ s then #s ^ (card ι - 1) else 0",
"usedConstants": [
"Eq.mpr",
"Finset.univ",
"congrArg",
"Fins... | prod_const #s, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Data.Fintype.BigOperators | {
"line": 235,
"column": 74
} | {
"line": 238,
"column": 25
} | [
{
"pp": "β : Type u_2\ninst✝ : CommMonoid β\nn : ℕ\nc : Fin n → β\n⊢ ∏ i, c i = ∏ i ∈ range n, if h : i < n then c ⟨i, h⟩ else 1",
"usedConstants": [
"Eq.mpr",
"MulOne.toOne",
"dite_congr",
"instDecidableTrue",
"Finset.univ",
"Fin.casesOn",
"Monoid.toMulOneClass",
... | by
rw [← Fin.prod_univ_eq_prod_range, Finset.prod_congr rfl]
rintro ⟨i, hi⟩ _
simp only [hi, dif_pos] | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Data.Set.Countable | {
"line": 199,
"column": 6
} | {
"line": 199,
"column": 27
} | [
{
"pp": "case mpr.inl\nα : Type u\ninst✝ : CompleteLattice α\np : α → Prop\nh : ∃ x, p x\nhSc : ∅.Countable\nhps : ∀ s ∈ ∅, p s\nhS : ⊥ = ⊤\nthis : Subsingleton α\n⊢ ∃ s, (∀ (n : ℕ), p (s n)) ∧ ⨆ n, s n = ⊤",
"usedConstants": []
}
] | rcases h with ⟨x, hx⟩ | _private.Lean.Elab.Tactic.RCases.0.Lean.Elab.Tactic.RCases.evalRCases | Lean.Parser.Tactic.rcases |
Mathlib.Data.Sum.Order | {
"line": 379,
"column": 8
} | {
"line": 379,
"column": 34
} | [
{
"pp": "case refine_1.sep\nα : Type u_1\nβ : Type u_2\nγ : Type u_3\ninst✝¹ : Preorder α\ninst✝ : Preorder β\nb : α\na : β\nhab : inr a < inl b\n⊢ False",
"usedConstants": [
"Preorder.toLT",
"Sum.Lex.not_inr_lt_inl"
]
}
] | · exact not_inr_lt_inl hab | Lean.Elab.Tactic.evalTacticCDot | Lean.cdot |
Mathlib.SetTheory.Cardinal.Defs | {
"line": 183,
"column": 2
} | {
"line": 183,
"column": 38
} | [
{
"pp": "a : Cardinal.{u}\n⊢ Nonempty (Quotient.out #(ULift (Quotient.out a)) ≃ Quotient.out a)",
"usedConstants": [
"Equiv.trans",
"ULift",
"Cardinal.mk",
"Equiv.ulift",
"Equiv",
"Quotient.out",
"Cardinal.outMkEquiv",
"Nonempty.intro",
"Cardinal.isEquiv... | exact ⟨outMkEquiv.trans Equiv.ulift⟩ | Lean.Elab.Tactic.evalExact | Lean.Parser.Tactic.exact |
Mathlib.SetTheory.Cardinal.Defs | {
"line": 233,
"column": 2
} | {
"line": 233,
"column": 32
} | [
{
"pp": "x : Cardinal.{u_1}\nh : x ≠ 0\n⊢ Nonempty (Quotient.out x)",
"usedConstants": [
"Cardinal.mk_ne_zero_iff",
"Eq.mpr",
"Cardinal",
"Cardinal.mk_out",
"congrArg",
"Cardinal.mk",
"id",
"Quotient.out",
"Ne",
"Cardinal.isEquivalent",
"prop... | rwa [← mk_ne_zero_iff, mk_out] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_tacticRwa___1 | Lean.Parser.Tactic.tacticRwa__ |
Mathlib.SetTheory.Cardinal.Defs | {
"line": 233,
"column": 2
} | {
"line": 233,
"column": 32
} | [
{
"pp": "x : Cardinal.{u_1}\nh : x ≠ 0\n⊢ Nonempty (Quotient.out x)",
"usedConstants": [
"Cardinal.mk_ne_zero_iff",
"Eq.mpr",
"Cardinal",
"Cardinal.mk_out",
"congrArg",
"Cardinal.mk",
"id",
"Quotient.out",
"Ne",
"Cardinal.isEquivalent",
"prop... | rwa [← mk_ne_zero_iff, mk_out] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.SetTheory.Cardinal.Defs | {
"line": 233,
"column": 2
} | {
"line": 233,
"column": 32
} | [
{
"pp": "x : Cardinal.{u_1}\nh : x ≠ 0\n⊢ Nonempty (Quotient.out x)",
"usedConstants": [
"Cardinal.mk_ne_zero_iff",
"Eq.mpr",
"Cardinal",
"Cardinal.mk_out",
"congrArg",
"Cardinal.mk",
"id",
"Quotient.out",
"Ne",
"Cardinal.isEquivalent",
"prop... | rwa [← mk_ne_zero_iff, mk_out] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Order.InitialSeg | {
"line": 159,
"column": 4
} | {
"line": 163,
"column": 74
} | [
{
"pp": "α : Type u_1\nβ : Type u_2\nγ : Type u_3\nr : α → α → Prop\ns : β → β → Prop\nt : γ → γ → Prop\ninst✝² : Std.Trichotomous s\ninst✝¹ : Std.Irrefl s\ninst✝ : IsWellFounded α r\nf g : r ≼i s\n⊢ f = g",
"usedConstants": [
"Eq.mpr",
"congrArg",
"InitialSeg.exists_eq_iff_rel",
"If... | ext a
refine IsWellFounded.induction r a fun b IH =>
extensional_of_trichotomous_of_irrefl s fun x => ?_
rw [f.exists_eq_iff_rel, g.exists_eq_iff_rel]
exact exists_congr fun x => and_congr_left fun hx => IH _ hx ▸ Iff.rfl | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Order.InitialSeg | {
"line": 159,
"column": 4
} | {
"line": 163,
"column": 74
} | [
{
"pp": "α : Type u_1\nβ : Type u_2\nγ : Type u_3\nr : α → α → Prop\ns : β → β → Prop\nt : γ → γ → Prop\ninst✝² : Std.Trichotomous s\ninst✝¹ : Std.Irrefl s\ninst✝ : IsWellFounded α r\nf g : r ≼i s\n⊢ f = g",
"usedConstants": [
"Eq.mpr",
"congrArg",
"InitialSeg.exists_eq_iff_rel",
"If... | ext a
refine IsWellFounded.induction r a fun b IH =>
extensional_of_trichotomous_of_irrefl s fun x => ?_
rw [f.exists_eq_iff_rel, g.exists_eq_iff_rel]
exact exists_congr fun x => and_congr_left fun hx => IH _ hx ▸ Iff.rfl | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Data.Sum.Order | {
"line": 690,
"column": 6
} | {
"line": 693,
"column": 31
} | [
{
"pp": "case inr.inr\nα✝ : Type u_1\nβ✝ : Type u_2\nγ : Type u_3\nα₁ : Type u_4\nα₂ : Type u_5\nβ₁ : Type u_6\nβ₂ : Type u_7\nγ₁ : Type u_8\nγ₂ : Type u_9\ninst✝¹⁰ : LE α✝\ninst✝⁹ : LE β✝\ninst✝⁸ : LE γ\ninst✝⁷ : LE α₁\ninst✝⁶ : LE α₂\ninst✝⁵ : LE β₁\ninst✝⁴ : LE β₂\ninst✝³ : LE γ₁\ninst✝² : LE γ₂\na✝ : α✝\nb✝... | · change
toLex (inl <| toDual a) ≤ toLex (inl <| toDual b) ↔
toDual (toLex <| inr a) ≤ toDual (toLex <| inr b)
simp [toDual_le_toDual] | Lean.Elab.Tactic.evalTacticCDot | Lean.cdot |
Mathlib.Order.UpperLower.Basic | {
"line": 256,
"column": 11
} | {
"line": 256,
"column": 31
} | [
{
"pp": "α : Type u_1\ninst✝¹ : LinearOrder α\ns : Set α\ninst✝ : WellFoundedLT α\nh : IsLowerSet s\n⊢ s = univ ∨ ∃ a, s = Iio a",
"usedConstants": [
"Eq.mpr",
"BooleanAlgebra",
"congrArg",
"Compl.compl",
"Set.univ",
"PartialOrder.toPreorder",
"Exists",
"Boole... | ← @compl_inj_iff _ s | Mathlib.Tactic._aux_Mathlib_Tactic_SimpRw___elabRules_Mathlib_Tactic_tacticSimp_rw____1 | null |
Mathlib.Data.Part | {
"line": 370,
"column": 9
} | {
"line": 370,
"column": 20
} | [
{
"pp": "case inr.h\nα : Type u_1\nx y z : Part α\nhx : x ≤ z\nhy : y ≤ z\nb : α\nh₀ : x = some b\n⊢ y ≤ x",
"usedConstants": []
}
] | intro b' h₁ | Lean.Elab.Tactic.evalIntro | Lean.Parser.Tactic.intro |
Mathlib.Data.Part | {
"line": 750,
"column": 80
} | {
"line": 750,
"column": 99
} | [
{
"pp": "α : Type u_1\ninst✝ : SDiff α\na b : α\n⊢ some a \\ some b = some (a \\ b)",
"usedConstants": [
"Part",
"congrArg",
"Part.some",
"Part.bind_some",
"SDiff.sdiff",
"funext",
"Part.map_some",
"True",
"eq_self",
"of_eq_true",
"Part.instS... | by simp [sdiff_def] | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Order.Zorn | {
"line": 138,
"column": 2
} | {
"line": 139,
"column": 46
} | [
{
"pp": "case refine_1\nα : Type u_1\ninst✝ : Preorder α\na : α\nih : ∀ c ⊆ Ici a, IsChain (fun x1 x2 ↦ x1 ≤ x2) c → ∀ y ∈ c, ∃ ub, ∀ z ∈ c, z ≤ ub\nx : α\nhax : a ≤ x\nc : Set α\nhca : c ⊆ Ici a\nhc : IsChain (fun x1 x2 ↦ x1 ≤ x2) c\ny : α\nhy : y ∈ c\n⊢ ∃ ub ∈ Ici a, ∀ z ∈ c, z ≤ ub",
"usedConstants": [
... | · have ⟨ub, hub⟩ := ih c hca hc y hy
exact ⟨ub, (hca hy).trans (hub y hy), hub⟩ | Lean.Elab.Tactic.evalTacticCDot | Lean.cdot |
Mathlib.Order.OmegaCompletePartialOrder | {
"line": 208,
"column": 30
} | {
"line": 208,
"column": 77
} | [
{
"pp": "α : Type u_2\ninst✝ : OmegaCompletePartialOrder α\nc : Chain α\nx : α\nh : ∀ (i : ℕ), c i ≤ x ∨ x ≤ c i\nthis : ¬∀ (i : ℕ), c i ≤ x\n⊢ ∃ i, ¬c i ≤ x",
"usedConstants": [
"_private.Mathlib.Order.OmegaCompletePartialOrder.0.OmegaCompletePartialOrder.ωSup_total._simp_1_3",
"PartialOrder.to... | by simp only [not_forall] at this ⊢; assumption | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.SetTheory.Cardinal.SchroederBernstein | {
"line": 92,
"column": 2
} | {
"line": 92,
"column": 92
} | [
{
"pp": "α : Type u\nβ : Type v\nf : α → β\ng : β → α\nhf : Injective f\nhg : Injective g\n⊢ ∃ h, Bijective h",
"usedConstants": [
"True",
"of_eq_true",
"Function.Embedding.schroeder_bernstein_of_rel",
"implies_true"
]
}
] | obtain ⟨f, hf, _⟩ := schroeder_bernstein_of_rel hf hg (fun x y ↦ True) (by simp) (by simp) | _private.Lean.Elab.Tactic.RCases.0.Lean.Elab.Tactic.RCases.evalObtain | Lean.Parser.Tactic.obtain |
Mathlib.SetTheory.Cardinal.ENat | {
"line": 294,
"column": 58
} | {
"line": 294,
"column": 93
} | [
{
"pp": "c : Cardinal.{u}\nn : ℕ\n⊢ ↑n = toENat c ↔ ↑n = c",
"usedConstants": [
"ENat.instNatCast",
"Cardinal",
"congrArg",
"CommSemiring.toSemiring",
"Cardinal.commSemiring",
"PartialOrder.toPreorder",
"OrderRingHom.instFunLike",
"Cardinal.toENat_eq_natCast._... | by simp [eq_comm (a := Nat.cast _)] | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Algebra.Module.LinearMap.End | {
"line": 66,
"column": 2
} | {
"line": 66,
"column": 37
} | [
{
"pp": "R : Type u_1\nR₂ : Type u_2\nS : Type u_3\nM : Type u_4\nM₁ : Type u_5\nM₂ : Type u_6\nM₃ : Type u_7\nN₁ : Type u_8\ninst✝⁵ : Semiring R\ninst✝⁴ : AddCommMonoid M\ninst✝³ : AddCommGroup N₁\ninst✝² : Module R M\ninst✝¹ : Module R N₁\ninst✝ : Nontrivial M\n⊢ Nontrivial (End R M)",
"usedConstants": [
... | obtain ⟨m, ne⟩ := exists_ne (0 : M) | _private.Lean.Elab.Tactic.RCases.0.Lean.Elab.Tactic.RCases.evalObtain | Lean.Parser.Tactic.obtain |
Mathlib.Algebra.Module.Submodule.Defs | {
"line": 230,
"column": 2
} | {
"line": 230,
"column": 28
} | [
{
"pp": "R : Type u\nM : Type v\ninst✝² : Semiring R\ninst✝¹ : AddCommMonoid M\nmodule_M : Module R M\np : Submodule R M\nr : R\nx : M\ninst✝ : Invertible r\nh : r • x ∈ p\n⊢ x ∈ p",
"usedConstants": [
"Eq.mpr",
"Submodule",
"MulOne.toOne",
"instHSMul",
"Monoid.toMulOneClass",
... | rw [← invOf_smul_smul r x] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.GroupTheory.GroupAction.SubMulAction | {
"line": 436,
"column": 71
} | {
"line": 437,
"column": 62
} | [
{
"pp": "R : Type u\nM : Type v\ninst✝¹ : Monoid R\ninst✝ : MulAction R M\np : SubMulAction R M\nm : ↥p\n⊢ Subtype.val ⁻¹' MulAction.orbit R ↑m = MulAction.orbit R m",
"usedConstants": [
"SubMulAction.instSetLike",
"Eq.mpr",
"instSMulOfMul",
"Monoid.toMulOneClass",
"congrArg",
... | by
rw [← val_image_orbit, Subtype.val_injective.preimage_image] | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.GroupTheory.GroupAction.SubMulAction | {
"line": 591,
"column": 3
} | {
"line": 591,
"column": 41
} | [
{
"pp": "R : Type u_1\nM : Type u_2\ninst✝² : Monoid R\ninst✝¹ : AddCommMonoid M\ninst✝ : DistribMulAction R M\nx y : { v // v ≠ 0 }\n⊢ (MulAction.orbitRel Rˣ { v // v ≠ 0 }) x y → (MulAction.orbitRel Rˣ M) ↑x ↑y",
"usedConstants": [
"Units.instMulAction",
"instHSMul",
"AddMonoid.toAddZero... | by rintro ⟨a, rfl⟩; exact ⟨a, by simp⟩ | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Algebra.Module.Submodule.Ker | {
"line": 285,
"column": 46
} | {
"line": 285,
"column": 87
} | [
{
"pp": "R : Type u_1\nR₂ : Type u_2\nR₃ : Type u_3\nM : Type u_5\nM₂ : Type u_7\nM₃ : Type u_8\ninst✝⁹ : Semiring R\ninst✝⁸ : Semiring R₂\ninst✝⁷ : Semiring R₃\ninst✝⁶ : AddCommMonoid M\ninst✝⁵ : AddCommMonoid M₂\ninst✝⁴ : AddCommMonoid M₃\ninst✝³ : Module R M\ninst✝² : Module R₂ M₂\ninst✝¹ : Module R₃ M₃\nτ₁₂... | by rw [ker_comp, hg, Submodule.comap_bot] | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Algebra.Group.Subsemigroup.Membership | {
"line": 67,
"column": 2
} | {
"line": 67,
"column": 41
} | [
{
"pp": "case hS\nM : Type u_2\ninst✝ : Mul M\nι : Type u_3\np : ι → Prop\nS : ι → Subsemigroup M\nhS : DirectedOn ((fun x1 x2 ↦ x1 ≤ x2) on S) {i | p i}\nx : M\n⊢ Directed (fun x1 x2 ↦ x1 ≤ x2) fun x ↦ S ↑x",
"usedConstants": [
"Eq.mpr",
"congrArg",
"Directed",
"PartialOrder.toPreor... | rw [← Function.comp_def, directed_comp] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.Algebra.GroupWithZero.Associated | {
"line": 165,
"column": 90
} | {
"line": 166,
"column": 50
} | [
{
"pp": "M : Type u_1\ninst✝ : Monoid M\na b c : M\nh : b ~ᵤ c\n⊢ a * b ~ᵤ a * c",
"usedConstants": [
"Units.val",
"HMul.hMul",
"Monoid.toMulOneClass",
"mul_assoc",
"Units",
"MulOne.toMul",
"MulOneClass.toMulOne",
"Associated",
"Exists.casesOn",
"E... | by
obtain ⟨d, rfl⟩ := h; exact ⟨d, mul_assoc _ _ _⟩ | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Algebra.GroupWithZero.Associated | {
"line": 373,
"column": 6
} | {
"line": 373,
"column": 25
} | [
{
"pp": "R : Type u_2\ninst✝² : CommMonoidWithZero R\ninst✝¹ : IsCancelMulZero R\ninst✝ : Subsingleton Rˣ\np₁ p₂ : R\nk₁ k₂ : ℕ\nhp₁ : Prime p₁\nhp₂ : Prime p₂\nhk₁ : 0 < k₁\nh : p₁ ^ k₁ = p₂ ^ k₂\n⊢ p₁ = p₂",
"usedConstants": [
"congrArg",
"Eq.mp",
"CommMonoidWithZero.toMonoidWithZero",
... | ← associated_iff_eq | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Algebra.GroupWithZero.Associated | {
"line": 378,
"column": 6
} | {
"line": 378,
"column": 25
} | [
{
"pp": "R : Type u_2\ninst✝² : CommMonoidWithZero R\ninst✝¹ : IsCancelMulZero R\ninst✝ : Subsingleton Rˣ\np₁ p₂ : R\nk₁ k₂ : ℕ\nhp₁ : Prime p₁\nhp₂ : Prime p₂\nhk₁ : 0 < k₂\nh : p₁ ^ k₁ = p₂ ^ k₂\n⊢ p₁ = p₂",
"usedConstants": [
"congrArg",
"Eq.mp",
"CommMonoidWithZero.toMonoidWithZero",
... | ← associated_iff_eq | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Algebra.GroupWithZero.Associated | {
"line": 672,
"column": 2
} | {
"line": 672,
"column": 34
} | [
{
"pp": "case right\nM : Type u_1\ninst✝ : CommMonoidWithZero M\na b : Associates M\nhlt : a < b\n⊢ ∃ x, ¬IsUnit x ∧ b = a * x",
"usedConstants": []
}
] | rcases hlt with ⟨⟨x, rfl⟩, ndvd⟩ | _private.Lean.Elab.Tactic.RCases.0.Lean.Elab.Tactic.RCases.evalRCases | Lean.Parser.Tactic.rcases |
Mathlib.Algebra.Ring.Subring.Basic | {
"line": 1036,
"column": 4
} | {
"line": 1036,
"column": 83
} | [
{
"pp": "case cons.inr.inr\nR : Type u_1\ninst✝ : Ring R\ns : Set R\nC : R → Prop\nh1 : C 1\nhneg1 : C (-1)\nhs : ∀ z ∈ s, ∀ (n : R), C n → C (z * n)\nha : ∀ {x y : R}, C x → C y → C (x + y)\nh0 : C 0\nhd : R\ntl : List R\nih : (∀ y ∈ tl, y ∈ s ∨ y = -1) → ∃ L, (∀ x ∈ L, x ∈ s) ∧ (tl.prod = L.prod ∨ tl.prod = -... | exact ⟨L, HL', Or.inl <| by rw [List.prod_cons, hhd, HP, neg_one_mul, neg_neg]⟩ | Lean.Elab.Tactic.evalExact | Lean.Parser.Tactic.exact |
Mathlib.Algebra.Ring.Subring.Basic | {
"line": 1036,
"column": 4
} | {
"line": 1036,
"column": 83
} | [
{
"pp": "case cons.inr.inr\nR : Type u_1\ninst✝ : Ring R\ns : Set R\nC : R → Prop\nh1 : C 1\nhneg1 : C (-1)\nhs : ∀ z ∈ s, ∀ (n : R), C n → C (z * n)\nha : ∀ {x y : R}, C x → C y → C (x + y)\nh0 : C 0\nhd : R\ntl : List R\nih : (∀ y ∈ tl, y ∈ s ∨ y = -1) → ∃ L, (∀ x ∈ L, x ∈ s) ∧ (tl.prod = L.prod ∨ tl.prod = -... | exact ⟨L, HL', Or.inl <| by rw [List.prod_cons, hhd, HP, neg_one_mul, neg_neg]⟩ | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Algebra.Ring.Subring.Basic | {
"line": 1036,
"column": 4
} | {
"line": 1036,
"column": 83
} | [
{
"pp": "case cons.inr.inr\nR : Type u_1\ninst✝ : Ring R\ns : Set R\nC : R → Prop\nh1 : C 1\nhneg1 : C (-1)\nhs : ∀ z ∈ s, ∀ (n : R), C n → C (z * n)\nha : ∀ {x y : R}, C x → C y → C (x + y)\nh0 : C 0\nhd : R\ntl : List R\nih : (∀ y ∈ tl, y ∈ s ∨ y = -1) → ∃ L, (∀ x ∈ L, x ∈ s) ∧ (tl.prod = L.prod ∨ tl.prod = -... | exact ⟨L, HL', Or.inl <| by rw [List.prod_cons, hhd, HP, neg_one_mul, neg_neg]⟩ | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.LinearAlgebra.Span.Defs | {
"line": 104,
"column": 2
} | {
"line": 104,
"column": 35
} | [
{
"pp": "R : Type u_1\nM : Type u_4\nS : Type u_7\ninst✝⁵ : Semiring R\ninst✝⁴ : AddCommMonoid M\ninst✝³ : Module R M\ninst✝² : SetLike S M\ninst✝¹ : AddSubmonoidClass S M\ninst✝ : SMulMemClass S R M\ns : S\n⊢ ↑(span R ↑s) = ↑s",
"usedConstants": [
"Submodule",
"CompleteLattice.toConditionallyCo... | refine le_antisymm ?_ subset_span | Lean.Elab.Tactic.evalRefine | Lean.Parser.Tactic.refine |
Mathlib.Order.SupClosed | {
"line": 345,
"column": 6
} | {
"line": 345,
"column": 56
} | [
{
"pp": "α : Type u_3\nβ : Type u_4\ninst✝¹ : SemilatticeSup α\ninst✝ : SemilatticeSup β\ns : Set α\nt : Set β\n⊢ supClosure s ×ˢ supClosure t ≤ supClosure (s ×ˢ t)",
"usedConstants": [
"Prod"
]
}
] | rintro ⟨_, _⟩ ⟨⟨u, hu, hus, rfl⟩, v, hv, hvt, rfl⟩ | _private.Lean.Elab.Tactic.RCases.0.Lean.Elab.Tactic.RCases.evalRIntro | Lean.Parser.Tactic.rintro |
Mathlib.Order.SupClosed | {
"line": 417,
"column": 6
} | {
"line": 417,
"column": 56
} | [
{
"pp": "α : Type u_3\nβ : Type u_4\ninst✝¹ : SemilatticeInf α\ninst✝ : SemilatticeInf β\ns : Set α\nt : Set β\n⊢ infClosure s ×ˢ infClosure t ≤ infClosure (s ×ˢ t)",
"usedConstants": [
"Prod"
]
}
] | rintro ⟨_, _⟩ ⟨⟨u, hu, hus, rfl⟩, v, hv, hvt, rfl⟩ | _private.Lean.Elab.Tactic.RCases.0.Lean.Elab.Tactic.RCases.evalRIntro | Lean.Parser.Tactic.rintro |
Mathlib.Order.Interval.Set.OrderIso | {
"line": 49,
"column": 2
} | {
"line": 49,
"column": 65
} | [
{
"pp": "α : Type u_1\nβ : Type u_2\ninst✝¹ : Preorder α\ninst✝ : Preorder β\ne : α ≃o β\na : α\n⊢ ⇑e '' Iic a = Iic (e a)",
"usedConstants": [
"Eq.mpr",
"congrArg",
"OrderIso.symm_symm",
"Preorder.toLE",
"id",
"OrderIso",
"OrderIso.symm",
"instFunLikeOrderIso... | rw [e.image_eq_preimage_symm, e.symm.preimage_Iic, e.symm_symm] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.Order.Interval.Set.OrderIso | {
"line": 49,
"column": 2
} | {
"line": 49,
"column": 65
} | [
{
"pp": "α : Type u_1\nβ : Type u_2\ninst✝¹ : Preorder α\ninst✝ : Preorder β\ne : α ≃o β\na : α\n⊢ ⇑e '' Iic a = Iic (e a)",
"usedConstants": [
"Eq.mpr",
"congrArg",
"OrderIso.symm_symm",
"Preorder.toLE",
"id",
"OrderIso",
"OrderIso.symm",
"instFunLikeOrderIso... | rw [e.image_eq_preimage_symm, e.symm.preimage_Iic, e.symm_symm] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Order.Interval.Set.OrderIso | {
"line": 49,
"column": 2
} | {
"line": 49,
"column": 65
} | [
{
"pp": "α : Type u_1\nβ : Type u_2\ninst✝¹ : Preorder α\ninst✝ : Preorder β\ne : α ≃o β\na : α\n⊢ ⇑e '' Iic a = Iic (e a)",
"usedConstants": [
"Eq.mpr",
"congrArg",
"OrderIso.symm_symm",
"Preorder.toLE",
"id",
"OrderIso",
"OrderIso.symm",
"instFunLikeOrderIso... | rw [e.image_eq_preimage_symm, e.symm.preimage_Iic, e.symm_symm] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Order.Atoms | {
"line": 651,
"column": 76
} | {
"line": 652,
"column": 55
} | [
{
"pp": "α : Type u_4\ninst✝ : CompleteLattice α\n⊢ IsAtomistic α ↔ ∀ (b : α), ∃ s, b = sSup s ∧ ∀ a ∈ s, IsAtom a",
"usedConstants": [
"Eq.mpr",
"_private.Mathlib.Order.Atoms.0.CompleteLattice.isAtomistic_iff._simp_1_3",
"_private.Mathlib.Order.Atoms.0.CompleteLattice.isAtomistic_iff._sim... | by
simp_rw [isAtomistic_iff, isLUB_iff_sSup_eq, eq_comm] | [anonymous] | Lean.Parser.Term.byTactic |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.