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.Data.Nat.Choose.Basic | {
"line": 318,
"column": 2
} | {
"line": 322,
"column": 92
} | [
{
"pp": "r n : ℕ\nh : r < n / 2\n⊢ n.choose r ≤ n.choose (r + 1)",
"usedConstants": [
"Eq.mpr",
"Nat.choose",
"instHDiv",
"Nat.lt_sub_iff_add_lt",
"HMul.hMul",
"Nat.div_mul_le_self",
"congrArg",
"Nat.sub_pos_of_lt",
"Nat.mul_lt_mul_of_pos_right",
"... | refine Nat.le_of_mul_le_mul_right ?_ (Nat.sub_pos_of_lt (h.trans_le (n.div_le_self 2)))
rw [← choose_succ_right_eq]
apply Nat.mul_le_mul_left
rw [← Nat.lt_iff_add_one_le, Nat.lt_sub_iff_add_lt, ← Nat.mul_two]
exact lt_of_lt_of_le (Nat.mul_lt_mul_of_pos_right h Nat.zero_lt_two) (n.div_mul_le_self 2) | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Data.List.Sublists | {
"line": 386,
"column": 96
} | {
"line": 402,
"column": 37
} | [
{
"pp": "α : Type u\nl l₁ l₂ : List α\nh : (l₁, l₂) ∈ l.sublists.revzip\n⊢ l₁ ++ l₂ ~ l",
"usedConstants": [
"instPowNat",
"Eq.mpr",
"False",
"List.Perm.refl._simp_1",
"_private.Mathlib.Data.List.Sublists.0.List.revzip_sublists._simp_1_4",
"List.append_assoc",
"List... | by
rw [revzip] at h
induction l using List.reverseRecOn generalizing l₁ l₂ with
| nil =>
have : l₁ = [] ∧ l₂ = [] := by simpa using h
simp [this]
| append_singleton l' a ih =>
rw [sublists_concat, reverse_append, zip_append (by simp), ← map_reverse, zip_map_right,
zip_map_left] at *
simp o... | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Data.Set.Pairwise.Lattice | {
"line": 172,
"column": 2
} | {
"line": 172,
"column": 18
} | [
{
"pp": "α : Type u_1\ns : Set α\na : α\nha : a ∉ s\n⊢ ∀ ⦃i : Set α⦄, i ∈ 𝒫 s → ∀ ⦃j : Set α⦄, j ∈ 𝒫 s → ({i, insert a i} ∩ {j, insert a j}).Nonempty → i = j",
"usedConstants": [
"Set"
]
}
] | rintro i hi j hj | _private.Lean.Elab.Tactic.RCases.0.Lean.Elab.Tactic.RCases.evalRIntro | Lean.Parser.Tactic.rintro |
Mathlib.Data.Finset.Powerset | {
"line": 108,
"column": 2
} | {
"line": 108,
"column": 18
} | [
{
"pp": "α : Type u_1\ns : Finset α\ninst✝ : DecidableEq α\na : α\nha : a ∉ s\n⊢ ∀ ⦃i : Finset α⦄, i ⊆ s → ∀ ⦃j : Finset α⦄, j ⊆ s → ({i, insert a i} ∩ {j, insert a j}).Nonempty → i = j",
"usedConstants": [
"Finset"
]
}
] | rintro i hi j hj | _private.Lean.Elab.Tactic.RCases.0.Lean.Elab.Tactic.RCases.evalRIntro | Lean.Parser.Tactic.rintro |
Mathlib.Data.Finset.Lattice.Fold | {
"line": 1048,
"column": 2
} | {
"line": 1049,
"column": 67
} | [
{
"pp": "α : Type u_2\nι : Type u_5\ninst✝ : LinearOrder α\ns : Finset ι\nH : s.Nonempty\nf : ι → α\na : α\n⊢ a ≤ s.sup' H f ↔ ∃ b ∈ s, a ≤ f b",
"usedConstants": [
"Eq.mpr",
"WithBot.some",
"WithBot",
"Preorder.toLT",
"Lattice.toSemilatticeSup",
"and_congr_right'",
... | rw [← WithBot.coe_le_coe, coe_sup', Finset.le_sup_iff (WithBot.bot_lt_coe a)]
exact exists_congr (fun _ => and_congr_right' WithBot.coe_le_coe) | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Data.Finset.Lattice.Fold | {
"line": 1048,
"column": 2
} | {
"line": 1049,
"column": 67
} | [
{
"pp": "α : Type u_2\nι : Type u_5\ninst✝ : LinearOrder α\ns : Finset ι\nH : s.Nonempty\nf : ι → α\na : α\n⊢ a ≤ s.sup' H f ↔ ∃ b ∈ s, a ≤ f b",
"usedConstants": [
"Eq.mpr",
"WithBot.some",
"WithBot",
"Preorder.toLT",
"Lattice.toSemilatticeSup",
"and_congr_right'",
... | rw [← WithBot.coe_le_coe, coe_sup', Finset.le_sup_iff (WithBot.bot_lt_coe a)]
exact exists_congr (fun _ => and_congr_right' WithBot.coe_le_coe) | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Data.Set.Finite.Range | {
"line": 102,
"column": 2
} | {
"line": 102,
"column": 41
} | [
{
"pp": "α : Type u\nβ : Type v\nf : α → β\ns : Set α\nu : Set β\nhu : u.Finite\nhsu : u ⊆ f '' s\n⊢ ∃ t ⊆ s, ∃ (_ : t.Finite), f '' t = u",
"usedConstants": [
"Finite",
"Set.Elem",
"Set.Finite.to_subtype"
]
}
] | have : Finite u := Finite.to_subtype hu | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_tacticHave___1 | Lean.Parser.Tactic.tacticHave__ |
Mathlib.Data.Set.Finite.Lattice | {
"line": 56,
"column": 73
} | {
"line": 58,
"column": 85
} | [
{
"pp": "α : Type u\nβ : Type v\ninst✝² : Fintype β\ninst✝¹ : DecidableEq α\nf : β → Set α\ninst✝ : (w : β) → Fintype ↑(f w)\n⊢ (⋃ x, f x).toFinset = Finset.univ.biUnion fun x ↦ (f x).toFinset",
"usedConstants": [
"Finset.univ",
"congrArg",
"PLift.fintype",
"Finset",
"Finset.ex... | by
ext v
simp only [mem_toFinset, mem_iUnion, Finset.mem_biUnion, Finset.mem_univ, true_and] | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Order.ConditionallyCompleteLattice.Finset | {
"line": 62,
"column": 2
} | {
"line": 67,
"column": 16
} | [
{
"pp": "case refine_1\nι : Type u_1\nα : Type u_2\ninst✝ : ConditionallyCompleteLinearOrder α\nf : ι → α\ns : Finset ι\nh : ∃ x ∈ s, sSup ∅ ≤ f x\nh' : (image f s).Nonempty\n⊢ ∀ x ∈ Set.range fun i ↦ ⨆ (_ : i ∈ s), f i, ∃ y ∈ f '' ↑s, x ≤ y",
"usedConstants": [
"Eq.mpr",
"_private.Mathlib.Order... | · simp only [ciSup_eq_ite, dite_eq_ite, Set.mem_range, Set.mem_image, mem_coe,
exists_exists_and_eq_and, forall_exists_index, forall_apply_eq_imp_iff]
intro i
split_ifs
· exact ⟨_, by assumption, le_rfl⟩
· assumption | Lean.Elab.Tactic.evalTacticCDot | Lean.cdot |
Mathlib.Data.Set.Finite.Lattice | {
"line": 242,
"column": 2
} | {
"line": 242,
"column": 50
} | [
{
"pp": "α : Type u\ns : Set α\nhs : s.Finite\nι : Type u_1\nt : ι → Set α\nh : s ⊆ ⋃ i, t i\nthis : Finite ↑s\nf : ↑s → ι\nhf : ∀ (x : ↑s), ↑x ∈ t (f x)\n⊢ ∃ I, I.Finite ∧ s ⊆ ⋃ i ∈ I, t i",
"usedConstants": [
"Set.Finite",
"Membership.mem",
"Set.Elem",
"Set.finite_range",
"Ha... | refine ⟨range f, finite_range f, fun x hx => ?_⟩ | Lean.Elab.Tactic.evalRefine | Lean.Parser.Tactic.refine |
Mathlib.Data.Finset.Sigma | {
"line": 109,
"column": 30
} | {
"line": 109,
"column": 47
} | [
{
"pp": "ι : Type u_1\nα : ι → Type u_2\nβ : Type u_3\ninst✝ : CompleteLattice β\ns : Finset ι\nt : (i : ι) → Finset (α i)\nf : Sigma α → β\n⊢ ⨆ x ∈ ↑(s.sigma t), f x = ⨆ x ∈ ↑s, ⨆ x_1 ∈ ↑(t x), f ⟨x, x_1⟩",
"usedConstants": [
"Eq.mpr",
"Iff.of_eq",
"congrArg",
"iSup",
"Finset"... | Finset.coe_sigma, | Mathlib.Tactic._aux_Mathlib_Tactic_SimpRw___elabRules_Mathlib_Tactic_tacticSimp_rw____1 | null |
Mathlib.Data.Finset.Preimage | {
"line": 137,
"column": 2
} | {
"line": 141,
"column": 78
} | [
{
"pp": "α : Type u_1\nβ : Type u_2\ninst✝² : Nonempty α\ninst✝¹ : SemilatticeSup β\ninst✝ : OrderBot β\ns : Finset β\nf : α → β\nhf : BijOn f (f ⁻¹' ↑s) ↑s\n⊢ (s.preimage f ⋯).sup f = s.sup id",
"usedConstants": [
"Finset.image_eq_preimage_of_leftInvOn_injOn",
"Eq.mpr",
"Set.LeftInvOn",
... | classical
have hfinvs : ∀ x ∈ s, (f ∘ invFunOn f (f ⁻¹' ↑s)) x = id x := hf.invOn_invFunOn.2
rw [← sup_congr (Eq.refl s) hfinvs, ← sup_image]
congr
exact (image_eq_preimage_of_leftInvOn_injOn hf.invOn_invFunOn.2 hf.2.1).symm | Lean.Elab.Tactic.evalClassical | Lean.Parser.Tactic.classical |
Mathlib.Data.Finset.Preimage | {
"line": 137,
"column": 2
} | {
"line": 141,
"column": 78
} | [
{
"pp": "α : Type u_1\nβ : Type u_2\ninst✝² : Nonempty α\ninst✝¹ : SemilatticeSup β\ninst✝ : OrderBot β\ns : Finset β\nf : α → β\nhf : BijOn f (f ⁻¹' ↑s) ↑s\n⊢ (s.preimage f ⋯).sup f = s.sup id",
"usedConstants": [
"Finset.image_eq_preimage_of_leftInvOn_injOn",
"Eq.mpr",
"Set.LeftInvOn",
... | classical
have hfinvs : ∀ x ∈ s, (f ∘ invFunOn f (f ⁻¹' ↑s)) x = id x := hf.invOn_invFunOn.2
rw [← sup_congr (Eq.refl s) hfinvs, ← sup_image]
congr
exact (image_eq_preimage_of_leftInvOn_injOn hf.invOn_invFunOn.2 hf.2.1).symm | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Data.Finset.Preimage | {
"line": 137,
"column": 2
} | {
"line": 141,
"column": 78
} | [
{
"pp": "α : Type u_1\nβ : Type u_2\ninst✝² : Nonempty α\ninst✝¹ : SemilatticeSup β\ninst✝ : OrderBot β\ns : Finset β\nf : α → β\nhf : BijOn f (f ⁻¹' ↑s) ↑s\n⊢ (s.preimage f ⋯).sup f = s.sup id",
"usedConstants": [
"Finset.image_eq_preimage_of_leftInvOn_injOn",
"Eq.mpr",
"Set.LeftInvOn",
... | classical
have hfinvs : ∀ x ∈ s, (f ∘ invFunOn f (f ⁻¹' ↑s)) x = id x := hf.invOn_invFunOn.2
rw [← sup_congr (Eq.refl s) hfinvs, ← sup_image]
congr
exact (image_eq_preimage_of_leftInvOn_injOn hf.invOn_invFunOn.2 hf.2.1).symm | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Data.Finset.Preimage | {
"line": 203,
"column": 2
} | {
"line": 203,
"column": 9
} | [
{
"pp": "α : Type u\nβ : Type v\nπ : β → Type u_1\ns : Finset β\ne : α ≃ β\n⊢ s.restrict ∘ ⇑(Equiv.piCongrLeft π e) =\n ⇑(Equiv.piCongrLeft (fun b ↦ π ↑b) (e.restrictPreimageFinset s)) ∘ (s.preimage ⇑e ⋯).restrict",
"usedConstants": [
"Equiv.instEquivLike",
"Function.Injective.injOn",
"... | ext x b | _private.Lean.Elab.Tactic.Ext.0.Lean.Elab.Tactic.Ext.evalExt | Lean.Elab.Tactic.Ext.ext |
Mathlib.Order.Preorder.Finite | {
"line": 51,
"column": 53
} | {
"line": 52,
"column": 98
} | [
{
"pp": "α : Type u_2\ninst✝ : Preorder α\na : α\ns : Finset α\nha : a ∈ s\n⊢ ∃ b ∈ s, a ≤ b ∧ ?m.24 b",
"usedConstants": [
"Iff.mpr",
"Finset.mem_filter._simp_1",
"le_rfl",
"congrArg",
"Finset",
"Classical.propDecidable",
"Preorder.toLE",
"_private.Mathlib.Or... | by
simpa [Maximal, and_assoc] using {x ∈ s | a ≤ x}.exists_maximal ⟨a, mem_filter.2 ⟨ha, le_rfl⟩⟩ | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Order.Interval.Finset.Nat | {
"line": 66,
"column": 71
} | {
"line": 66,
"column": 84
} | [
{
"pp": "⊢ Ico ⊥ = range",
"usedConstants": [
"Eq.mpr",
"congrArg",
"Finset.Iio_eq_Ico",
"Finset",
"OrderBot.toBot",
"Finset.Iio",
"Preorder.toLE",
"Nat.instLocallyFiniteOrder",
"LocallyFiniteOrder.toLocallyFiniteOrderBot",
"id",
"Finset.Ico"... | ← Iio_eq_Ico, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Data.Nat.Lattice | {
"line": 121,
"column": 40
} | {
"line": 121,
"column": 51
} | [
{
"pp": "case mpr\ns : Set ℕ\nhs : ∀ (k₁ k₂ : ℕ), k₁ ≤ k₂ → k₁ ∈ s → k₂ ∈ s\nk : ℕ\nH : k + 1 ∈ s\nH' : k ∉ s\n⊢ Nat.find ⋯ = k + 1",
"usedConstants": [
"Eq.mpr",
"congrArg",
"Classical.propDecidable",
"Membership.mem",
"id",
"instOfNatNat",
"instHAdd",
"And",... | find_eq_iff | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Data.List.MinMax | {
"line": 47,
"column": 4
} | {
"line": 47,
"column": 31
} | [
{
"pp": "α : Type u_1\nr : α → α → Prop\ninst✝ : DecidableRel r\nl : List α\no : Option α\ntl : List α\nhd : α\n⊢ (foldl (argAux r) o tl = none ↔ tl = [] ∧ o = none) →\n (Option.rec (some hd) (fun val ↦ if r hd val then some hd else some val) (foldl (argAux r) o tl) = none ↔\n (tl = [] ∧ [hd] = []) ∧ o ... | cases foldl (argAux r) o tl | _private.Lean.Elab.Tactic.Induction.0.Lean.Elab.Tactic.evalCases | Lean.Parser.Tactic.cases |
Mathlib.Order.Interval.Finset.Nat | {
"line": 272,
"column": 2
} | {
"line": 272,
"column": 58
} | [
{
"pp": "P : ℕ → Prop\nseed : ℕ\nh : ∀ (n : ℕ), P (n + 1) → P n\nhs : P seed\nhi : ∀ (x : ℕ), seed ≤ x → P x → ∃ y, x < y ∧ P y\nn : ℕ\n⊢ P n",
"usedConstants": [
"setOf",
"Set.Finite",
"Nat",
"Nat.decreasing_induction_of_infinite"
]
}
] | apply Nat.decreasing_induction_of_infinite h fun hf => _ | Lean.Elab.Tactic.evalApply | Lean.Parser.Tactic.apply |
Mathlib.Data.List.MinMax | {
"line": 189,
"column": 49
} | {
"line": 189,
"column": 69
} | [
{
"pp": "case pos\nα : Type u_1\nβ : Type u_2\ninst✝¹ : LinearOrder β\nf : α → β\ninst✝ : DecidableEq α\nhd : α\ntl : List α\nm val✝ : α\nh : argmax f tl = some val✝\nham : f m ≤ f hd\nh✝ : f hd < f val✝\nhm : some val✝ = some m\n⊢ (if hd = m then 0 else idxOf m tl + 1) ≤ if hd = hd then 0 else idxOf hd tl + 1"... | injection hm with hm | Lean.Elab.Tactic.evalInjection | Lean.Parser.Tactic.injection |
Mathlib.Data.List.MinMax | {
"line": 189,
"column": 49
} | {
"line": 189,
"column": 69
} | [
{
"pp": "case neg\nα : Type u_1\nβ : Type u_2\ninst✝¹ : LinearOrder β\nf : α → β\ninst✝ : DecidableEq α\nhd : α\ntl : List α\nm val✝ : α\nh : argmax f tl = some val✝\nham : f m ≤ f hd\nh✝ : ¬f hd < f val✝\nhm : some hd = some m\n⊢ (if hd = m then 0 else idxOf m tl + 1) ≤ if hd = hd then 0 else idxOf hd tl + 1",... | injection hm with hm | Lean.Elab.Tactic.evalInjection | Lean.Parser.Tactic.injection |
Mathlib.Data.List.MinMax | {
"line": 189,
"column": 49
} | {
"line": 189,
"column": 69
} | [
{
"pp": "case pos\nα : Type u_1\nβ : Type u_2\ninst✝¹ : LinearOrder β\nf : α → β\ninst✝ : DecidableEq α\nhd : α\ntl : List α\nm a : α\nham : f m ≤ f a\nval✝ : α\nh : argmax f tl = some val✝\na✝ : Mem a tl\nh✝ : f hd < f val✝\nhm : some val✝ = some m\n⊢ (if hd = m then 0 else idxOf m tl + 1) ≤ if hd = a then 0 e... | injection hm with hm | Lean.Elab.Tactic.evalInjection | Lean.Parser.Tactic.injection |
Mathlib.Data.List.MinMax | {
"line": 189,
"column": 49
} | {
"line": 189,
"column": 69
} | [
{
"pp": "case neg\nα : Type u_1\nβ : Type u_2\ninst✝¹ : LinearOrder β\nf : α → β\ninst✝ : DecidableEq α\nhd : α\ntl : List α\nm a : α\nham : f m ≤ f a\nval✝ : α\nh : argmax f tl = some val✝\na✝ : Mem a tl\nh✝ : ¬f hd < f val✝\nhm : some hd = some m\n⊢ (if hd = m then 0 else idxOf m tl + 1) ≤ if hd = a then 0 el... | injection hm with hm | Lean.Elab.Tactic.evalInjection | Lean.Parser.Tactic.injection |
Mathlib.Logic.Denumerable | {
"line": 145,
"column": 24
} | {
"line": 145,
"column": 70
} | [
{
"pp": "α : Type u_1\ninst✝¹ : Denumerable α\nγ : α → Type u_3\ninst✝ : (a : α) → Denumerable (γ a)\nn : ℕ\n⊢ some (ofNat (Sigma γ) n) = some ⟨ofNat α (unpair n).1, ofNat (γ (ofNat α (unpair n).1)) (unpair n).2⟩",
"usedConstants": [
"Eq.mpr",
"Encodable.decode_sigma_val",
"Option.bind_con... | rw [← decode_eq_ofNat, decode_sigma_val]; simp | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Logic.Denumerable | {
"line": 145,
"column": 24
} | {
"line": 145,
"column": 70
} | [
{
"pp": "α : Type u_1\ninst✝¹ : Denumerable α\nγ : α → Type u_3\ninst✝ : (a : α) → Denumerable (γ a)\nn : ℕ\n⊢ some (ofNat (Sigma γ) n) = some ⟨ofNat α (unpair n).1, ofNat (γ (ofNat α (unpair n).1)) (unpair n).2⟩",
"usedConstants": [
"Eq.mpr",
"Encodable.decode_sigma_val",
"Option.bind_con... | rw [← decode_eq_ofNat, decode_sigma_val]; simp | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Logic.Denumerable | {
"line": 270,
"column": 2
} | {
"line": 270,
"column": 45
} | [
{
"pp": "s : Set ℕ\ninst✝ : DecidablePred fun x ↦ x ∈ s\nx : ↑s\n⊢ toFunAux x = #({y ∈ range ↑x | y ∈ s})",
"usedConstants": [
"Eq.mpr",
"List.countP",
"congrArg",
"Membership.mem",
"id",
"List.range",
"Finset.range",
"List.countP_eq_length_filter",
"Nat... | rw [toFunAux, List.countP_eq_length_filter] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.Order.OrderIsoNat | {
"line": 183,
"column": 2
} | {
"line": 183,
"column": 72
} | [
{
"pp": "α : Type u_1\nr : α → α → Prop\ninst✝ : IsTrans α r\nf : ℕ → α\n⊢ ∃ g, (∀ (m n : ℕ), m < n → r (f (g m)) (f (g n))) ∨ ∀ (m n : ℕ), m < n → ¬r (f (g m)) (f (g n))",
"usedConstants": [
"exists_increasing_or_nonincreasing_subseq'"
]
}
] | obtain ⟨g, hr | hnr⟩ := exists_increasing_or_nonincreasing_subseq' r f | _private.Lean.Elab.Tactic.RCases.0.Lean.Elab.Tactic.RCases.evalObtain | Lean.Parser.Tactic.obtain |
Mathlib.Order.WellQuasiOrder | {
"line": 169,
"column": 6
} | {
"line": 173,
"column": 69
} | [
{
"pp": "case inr.refine_1\nα : Type u_1\ninst✝ : Preorder α\nx✝ : WellFoundedLT α ∧ ∀ (s : Set α), IsAntichain (fun x1 x2 ↦ x1 ≤ x2) s → s.Finite\nhwf : WellFoundedLT α\nf : ℕ → α\ng : ℕ ↪o ℕ\nh2 : ∀ (m n : ℕ), m < n → ¬f (g m) > f (g n)\nhc : ∀ (m n : ℕ), m < n → ¬f m ≤ f n\n⊢ IsAntichain (fun x1 x2 ↦ x1 ≤ x2... | rintro _ ⟨m, rfl⟩ _ ⟨n, rfl⟩ _ hf
obtain h | rfl | h := lt_trichotomy m n
· exact hc _ _ (g.strictMono h) hf
· contradiction
· exact h2 _ _ h (lt_of_le_not_ge hf (hc _ _ (g.strictMono h))) | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Order.WellQuasiOrder | {
"line": 169,
"column": 6
} | {
"line": 173,
"column": 69
} | [
{
"pp": "case inr.refine_1\nα : Type u_1\ninst✝ : Preorder α\nx✝ : WellFoundedLT α ∧ ∀ (s : Set α), IsAntichain (fun x1 x2 ↦ x1 ≤ x2) s → s.Finite\nhwf : WellFoundedLT α\nf : ℕ → α\ng : ℕ ↪o ℕ\nh2 : ∀ (m n : ℕ), m < n → ¬f (g m) > f (g n)\nhc : ∀ (m n : ℕ), m < n → ¬f m ≤ f n\n⊢ IsAntichain (fun x1 x2 ↦ x1 ≤ x2... | rintro _ ⟨m, rfl⟩ _ ⟨n, rfl⟩ _ hf
obtain h | rfl | h := lt_trichotomy m n
· exact hc _ _ (g.strictMono h) hf
· contradiction
· exact h2 _ _ h (lt_of_le_not_ge hf (hc _ _ (g.strictMono h))) | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Order.Interval.Finset.Basic | {
"line": 557,
"column": 2
} | {
"line": 558,
"column": 16
} | [
{
"pp": "ι : Type u_1\nα : Type u_2\na✝ a₁ a₂ b✝ b₁ b₂ c✝ x : α\ninst✝² : PartialOrder α\ninst✝¹ : LocallyFiniteOrder α\na b c : α\ninst✝ : OrderBot α\n⊢ Unique ↥(Iic ⊥)",
"usedConstants": [
"Eq.mpr",
"Finset.instUniqueSubtypeMemSingleton",
"congrArg",
"Finset",
"Unique",
... | rw [Iic_bot]
infer_instance | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Order.Interval.Finset.Basic | {
"line": 557,
"column": 2
} | {
"line": 558,
"column": 16
} | [
{
"pp": "ι : Type u_1\nα : Type u_2\na✝ a₁ a₂ b✝ b₁ b₂ c✝ x : α\ninst✝² : PartialOrder α\ninst✝¹ : LocallyFiniteOrder α\na b c : α\ninst✝ : OrderBot α\n⊢ Unique ↥(Iic ⊥)",
"usedConstants": [
"Eq.mpr",
"Finset.instUniqueSubtypeMemSingleton",
"congrArg",
"Finset",
"Unique",
... | rw [Iic_bot]
infer_instance | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Order.WellFoundedSet | {
"line": 507,
"column": 2
} | {
"line": 507,
"column": 16
} | [
{
"pp": "α : Type u_2\ninst✝ : Preorder α\ns : Set α\na : α\nhs : s.IsPWO\nha : a ∈ s\nt : Set ↑s := {x | ↑x ≤ a}\nh : t.Nonempty := Exists.intro ⟨a, ha⟩ le_rfl\ny : α\nhy : (fun x ↦ x ∈ s) y\nhle : y ≤ ↑(⋯.min t h)\n⊢ ↑(⋯.min t h) ≤ y",
"usedConstants": [
"WellQuasiOrdered.wellFounded",
"Classi... | by_contra hnle | Batteries.Tactic._aux_Batteries_Tactic_Init___macroRules_Batteries_Tactic_byContra_1 | Batteries.Tactic.byContra |
Mathlib.GroupTheory.Submonoid.Center | {
"line": 136,
"column": 42
} | {
"line": 136,
"column": 64
} | [
{
"pp": "M : Type ?u.4841\ninst✝ : Monoid M\nu : (↥(Submonoid.center M))ˣ\nr : Mˣ\n⊢ ↑r * (Submonoid.center M).subtype ↑u = ↑((Units.map (Submonoid.center M).subtype) u * r)",
"usedConstants": [
"Units.val",
"Eq.mpr",
"MonoidHom.instFunLike",
"HMul.hMul",
"MonoidHom",
"Mo... | Submonoid.coe_subtype, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.GroupTheory.Submonoid.Center | {
"line": 137,
"column": 10
} | {
"line": 137,
"column": 32
} | [
{
"pp": "M : Type ?u.4841\ninst✝ : Monoid M\nu : (↥(Submonoid.center M))ˣ\nr : Mˣ\n⊢ ↑r * ↑↑u = (Submonoid.center M).subtype ↑u * ↑r",
"usedConstants": [
"Units.val",
"Eq.mpr",
"MonoidHom.instFunLike",
"HMul.hMul",
"MonoidHom",
"Monoid.toMulOneClass",
"congrArg",
... | Submonoid.coe_subtype, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Order.WellFoundedSet | {
"line": 894,
"column": 8
} | {
"line": 894,
"column": 50
} | [
{
"pp": "case h.refine_1\nα : Type u_2\nβ : Type u_3\ninst✝¹ : PartialOrder α\ninst✝ : Preorder β\ns : Set (Lex (α × β))\nhα : ∀ (f : ℕ → α), (∀ (n : ℕ), f n ∈ (fun x ↦ (ofLex x).1) '' s) → ∃ g, Monotone (f ∘ ⇑g)\nhβ : ∀ (a : α), {y | toLex (a, y) ∈ s}.IsPWO\nf : ℕ → Lex (α × β)\nhf : ∀ (n : ℕ), f n ∈ s\ng : ℕ ... | exact (hhc (g' 0)).symm.trans (hhc (g' 1)) | Lean.Elab.Tactic.evalExact | Lean.Parser.Tactic.exact |
Mathlib.Order.WellFoundedSet | {
"line": 894,
"column": 8
} | {
"line": 894,
"column": 50
} | [
{
"pp": "case h.refine_1\nα : Type u_2\nβ : Type u_3\ninst✝¹ : PartialOrder α\ninst✝ : Preorder β\ns : Set (Lex (α × β))\nhα : ∀ (f : ℕ → α), (∀ (n : ℕ), f n ∈ (fun x ↦ (ofLex x).1) '' s) → ∃ g, Monotone (f ∘ ⇑g)\nhβ : ∀ (a : α), {y | toLex (a, y) ∈ s}.IsPWO\nf : ℕ → Lex (α × β)\nhf : ∀ (n : ℕ), f n ∈ s\ng : ℕ ... | exact (hhc (g' 0)).symm.trans (hhc (g' 1)) | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Order.WellFoundedSet | {
"line": 894,
"column": 8
} | {
"line": 894,
"column": 50
} | [
{
"pp": "case h.refine_1\nα : Type u_2\nβ : Type u_3\ninst✝¹ : PartialOrder α\ninst✝ : Preorder β\ns : Set (Lex (α × β))\nhα : ∀ (f : ℕ → α), (∀ (n : ℕ), f n ∈ (fun x ↦ (ofLex x).1) '' s) → ∃ g, Monotone (f ∘ ⇑g)\nhβ : ∀ (a : α), {y | toLex (a, y) ∈ s}.IsPWO\nf : ℕ → Lex (α × β)\nhf : ∀ (n : ℕ), f n ∈ s\ng : ℕ ... | exact (hhc (g' 0)).symm.trans (hhc (g' 1)) | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Order.WellFoundedSet | {
"line": 968,
"column": 4
} | {
"line": 969,
"column": 11
} | [
{
"pp": "case inr.convert_6\nι : Type u_1\nγ : Type u_4\nπ : ι → Type u_5\nrι : ι → ι → Prop\nrπ : (i : ι) → π i → π i → Prop\nf : γ → ι\ng : (i : ι) → γ → π i\nhι : WellFounded (rι on f)\nhπ : ∀ (i : ι), (f ⁻¹' {i}).WellFoundedOn (rπ i on g i)\nc c' : γ\nh : (Sigma.Lex rι rπ on fun c ↦ ⟨f c, g (f c) c⟩) c c'\n... | · dsimp only [Subtype.coe_mk, Subrel, Order.Preimage] at *
grind | Lean.Elab.Tactic.evalTacticCDot | Lean.cdot |
Mathlib.Data.Finset.NoncommProd | {
"line": 144,
"column": 35
} | {
"line": 144,
"column": 40
} | [
{
"pp": "case h.cons\nα : Type u_3\ninst✝ : Monoid α\na hd : α\ntl : List α\nIH : {x | x ∈ a ::ₘ ⟦tl⟧}.Pairwise Commute → a * tl.prod = tl.prod * a\ncomm : {x | x ∈ a ::ₘ ⟦hd :: tl⟧}.Pairwise Commute\n⊢ a * (hd * tl.prod) = hd * (tl.prod * a)",
"usedConstants": [
"Eq.mpr",
"MulOne.toOne",
... | ← IH, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Data.Finset.NoncommProd | {
"line": 389,
"column": 2
} | {
"line": 396,
"column": 97
} | [
{
"pp": "α : Type u_3\nβ : Type u_4\ninst✝ : Monoid β\ns : Finset α\nf g : α → β\ncomm_ff : (↑s).Pairwise (Commute on f)\ncomm_gg : (↑s).Pairwise (Commute on g)\ncomm_gf : (↑s).Pairwise fun x y ↦ Commute (g x) (f y)\n⊢ s.noncommProd (f * g) ⋯ = s.noncommProd f comm_ff * s.noncommProd g comm_gg",
"usedConsta... | induction s using Finset.cons_induction_on with
| empty => simp
| cons x s hnotMem ih =>
rw [Finset.noncommProd_cons, Finset.noncommProd_cons, Finset.noncommProd_cons, Pi.mul_apply,
ih (comm_ff.mono fun _ => mem_cons_of_mem) (comm_gg.mono fun _ => mem_cons_of_mem)
(comm_gf.mono fun _ => mem_cons_o... | _private.Lean.Elab.Tactic.Induction.0.Lean.Elab.Tactic.evalInduction | Lean.Parser.Tactic.induction |
Mathlib.Data.Finset.NoncommProd | {
"line": 389,
"column": 2
} | {
"line": 396,
"column": 97
} | [
{
"pp": "α : Type u_3\nβ : Type u_4\ninst✝ : Monoid β\ns : Finset α\nf g : α → β\ncomm_ff : (↑s).Pairwise (Commute on f)\ncomm_gg : (↑s).Pairwise (Commute on g)\ncomm_gf : (↑s).Pairwise fun x y ↦ Commute (g x) (f y)\n⊢ s.noncommProd (f * g) ⋯ = s.noncommProd f comm_ff * s.noncommProd g comm_gg",
"usedConsta... | induction s using Finset.cons_induction_on with
| empty => simp
| cons x s hnotMem ih =>
rw [Finset.noncommProd_cons, Finset.noncommProd_cons, Finset.noncommProd_cons, Pi.mul_apply,
ih (comm_ff.mono fun _ => mem_cons_of_mem) (comm_gg.mono fun _ => mem_cons_of_mem)
(comm_gf.mono fun _ => mem_cons_o... | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Data.Finset.NoncommProd | {
"line": 389,
"column": 2
} | {
"line": 396,
"column": 97
} | [
{
"pp": "α : Type u_3\nβ : Type u_4\ninst✝ : Monoid β\ns : Finset α\nf g : α → β\ncomm_ff : (↑s).Pairwise (Commute on f)\ncomm_gg : (↑s).Pairwise (Commute on g)\ncomm_gf : (↑s).Pairwise fun x y ↦ Commute (g x) (f y)\n⊢ s.noncommProd (f * g) ⋯ = s.noncommProd f comm_ff * s.noncommProd g comm_gg",
"usedConsta... | induction s using Finset.cons_induction_on with
| empty => simp
| cons x s hnotMem ih =>
rw [Finset.noncommProd_cons, Finset.noncommProd_cons, Finset.noncommProd_cons, Pi.mul_apply,
ih (comm_ff.mono fun _ => mem_cons_of_mem) (comm_gg.mono fun _ => mem_cons_of_mem)
(comm_gf.mono fun _ => mem_cons_o... | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.GroupTheory.Congruence.Defs | {
"line": 694,
"column": 4
} | {
"line": 698,
"column": 48
} | [
{
"pp": "case refine_2\nM : Type u_1\nN : Type u_2\nP : Type u_3\nα : Type u_4\ninst✝ : Monoid M\nc : Con M\nu : c.Quotientˣ\nf : (x y : M) → c (x * y) 1 → c (y * x) 1 → α\nHf :\n ∀ (x y : M) (hxy : c (x * y) 1) (hyx : c (y * x) 1) (x' y' : M) (hxy' : c (x' * y') 1) (hyx' : c (y' * x') 1),\n c x x' → c y y'... | rintro Hxy Hxy' -
refine Function.hfunext ?_ ?_
· rw [c.eq.2 hx, c.eq.2 hy]
· rintro Hyx Hyx' -
exact heq_of_eq (Hf _ _ _ _ _ _ _ _ hx hy) | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.GroupTheory.Congruence.Defs | {
"line": 694,
"column": 4
} | {
"line": 698,
"column": 48
} | [
{
"pp": "case refine_2\nM : Type u_1\nN : Type u_2\nP : Type u_3\nα : Type u_4\ninst✝ : Monoid M\nc : Con M\nu : c.Quotientˣ\nf : (x y : M) → c (x * y) 1 → c (y * x) 1 → α\nHf :\n ∀ (x y : M) (hxy : c (x * y) 1) (hyx : c (y * x) 1) (x' y' : M) (hxy' : c (x' * y') 1) (hyx' : c (y' * x') 1),\n c x x' → c y y'... | rintro Hxy Hxy' -
refine Function.hfunext ?_ ?_
· rw [c.eq.2 hx, c.eq.2 hy]
· rintro Hyx Hyx' -
exact heq_of_eq (Hf _ _ _ _ _ _ _ _ hx hy) | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.GroupTheory.Congruence.Defs | {
"line": 718,
"column": 2
} | {
"line": 718,
"column": 37
} | [
{
"pp": "case mk.mk\nM : Type u_1\ninst✝ : Monoid M\nc : Con M\np : c.Quotientˣ → Prop\nH : ∀ (x y : M) (hxy : c (x * y) 1) (hyx : c (y * x) 1), p { val := ↑x, inv := ↑y, val_inv := ⋯, inv_val := ⋯ }\nval✝ inv✝ : c.Quotient\nx y : M\nh₁ : Quot.mk (⇑c.toSetoid) x * Quot.mk (⇑c.toSetoid) y = 1\nh₂ : Quot.mk (⇑c.t... | exact H x y (c.eq.1 h₁) (c.eq.1 h₂) | Lean.Elab.Tactic.evalExact | Lean.Parser.Tactic.exact |
Mathlib.Algebra.BigOperators.Group.Finset.Basic | {
"line": 45,
"column": 2
} | {
"line": 46,
"column": 25
} | [
{
"pp": "ι : Type u_1\nM : Type u_4\ns : Finset ι\na : ι\ninst✝ : CommMonoid M\nh : a ∉ s\n⊢ (cons a s h).prod = fun f ↦ f a * ∏ x ∈ s, f x",
"usedConstants": [
"Eq.mpr",
"HMul.hMul",
"Monoid.toMulOneClass",
"Finset.cons",
"congrArg",
"id",
"MulOne.toMul",
"Fi... | funext f
rw [Finset.prod_cons h] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Algebra.BigOperators.Group.Finset.Basic | {
"line": 45,
"column": 2
} | {
"line": 46,
"column": 25
} | [
{
"pp": "ι : Type u_1\nM : Type u_4\ns : Finset ι\na : ι\ninst✝ : CommMonoid M\nh : a ∉ s\n⊢ (cons a s h).prod = fun f ↦ f a * ∏ x ∈ s, f x",
"usedConstants": [
"Eq.mpr",
"HMul.hMul",
"Monoid.toMulOneClass",
"Finset.cons",
"congrArg",
"id",
"MulOne.toMul",
"Fi... | funext f
rw [Finset.prod_cons h] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Algebra.BigOperators.Group.Finset.Basic | {
"line": 208,
"column": 69
} | {
"line": 208,
"column": 91
} | [
{
"pp": "ι : Type u_1\nκ : Type u_2\nM : Type u_4\ninst✝ : CommMonoid M\ns : Finset (ι ⊕ κ)\nf : ι ⊕ κ → M\n⊢ (∏ x ∈ s.toLeft, f (Sum.inl x)) * ∏ x ∈ s.toRight, f (Sum.inr x) =\n (∏ x ∈ (s.toLeft.disjSum s.toRight).toLeft, f (Sum.inl x)) *\n ∏ x ∈ (s.toLeft.disjSum s.toRight).toRight, f (Sum.inr x)",
... | Finset.toLeft_disjSum, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Algebra.BigOperators.Group.Finset.Basic | {
"line": 395,
"column": 87
} | {
"line": 400,
"column": 27
} | [
{
"pp": "ι : Type u_1\nM : Type u_4\ninst✝ : CommMonoid M\ns : Finset ι\nf : ι → M\na b : ι\nha : a ∈ s\nhb : b ∈ s\nhn : a ≠ b\nh₀ : ∀ c ∈ s, c ≠ a ∧ c ≠ b → f c = 1\n⊢ ∏ x ∈ s, f x = f a * f b",
"usedConstants": [
"Eq.mpr",
"MulOne.toOne",
"HMul.hMul",
"Monoid.toMulOneClass",
... | by
haveI := Classical.decEq ι; let s' := ({a, b} : Finset ι)
have hu : s' ⊆ s := by grind
have hf : ∀ c ∈ s, c ∉ s' → f c = 1 := by grind
rw [← Finset.prod_subset hu hf]
exact Finset.prod_pair hn | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.GroupTheory.Finiteness | {
"line": 256,
"column": 4
} | {
"line": 256,
"column": 66
} | [
{
"pp": "case refine_1\nM : Type u_1\ninst✝ : Monoid M\nx✝ : FG M\nS : Finset M\nhS : Submonoid.closure ↑S = ⊤\n⊢ Function.Surjective ⇑(FreeMonoid.lift Subtype.val)",
"usedConstants": [
"FreeMonoid.lift",
"Eq.mpr",
"MonoidHom.instMonoidHomClass",
"CancelMonoid.toRightCancelMonoid",
... | rwa [← MonoidHom.mrange_eq_top, ← Submonoid.closure_eq_mrange] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_tacticRwa___1 | Lean.Parser.Tactic.tacticRwa__ |
Mathlib.GroupTheory.Finiteness | {
"line": 256,
"column": 4
} | {
"line": 256,
"column": 66
} | [
{
"pp": "case refine_1\nM : Type u_1\ninst✝ : Monoid M\nx✝ : FG M\nS : Finset M\nhS : Submonoid.closure ↑S = ⊤\n⊢ Function.Surjective ⇑(FreeMonoid.lift Subtype.val)",
"usedConstants": [
"FreeMonoid.lift",
"Eq.mpr",
"MonoidHom.instMonoidHomClass",
"CancelMonoid.toRightCancelMonoid",
... | rwa [← MonoidHom.mrange_eq_top, ← Submonoid.closure_eq_mrange] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.GroupTheory.Finiteness | {
"line": 256,
"column": 4
} | {
"line": 256,
"column": 66
} | [
{
"pp": "case refine_1\nM : Type u_1\ninst✝ : Monoid M\nx✝ : FG M\nS : Finset M\nhS : Submonoid.closure ↑S = ⊤\n⊢ Function.Surjective ⇑(FreeMonoid.lift Subtype.val)",
"usedConstants": [
"FreeMonoid.lift",
"Eq.mpr",
"MonoidHom.instMonoidHomClass",
"CancelMonoid.toRightCancelMonoid",
... | rwa [← MonoidHom.mrange_eq_top, ← Submonoid.closure_eq_mrange] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.GroupTheory.Finiteness | {
"line": 274,
"column": 4
} | {
"line": 274,
"column": 38
} | [
{
"pp": "case mpr\nM : Type u_1\ninst✝ : Monoid M\nα : Type\nw✝ : Finite α\nφ : FreeMonoid α →* M\nhφ : Function.Surjective ⇑φ\n⊢ FG M",
"usedConstants": [
"CancelMonoid.toRightCancelMonoid",
"FreeMonoid",
"FreeMonoid.instCancelMonoid",
"instFGFreeMonoidOfFinite",
"RightCancelM... | exact Monoid.fg_of_surjective _ hφ | Lean.Elab.Tactic.evalExact | Lean.Parser.Tactic.exact |
Mathlib.Algebra.BigOperators.Group.Finset.Basic | {
"line": 779,
"column": 6
} | {
"line": 780,
"column": 29
} | [
{
"pp": "case pos\nι : Type u_1\nM : Type u_4\ninst✝ : CommMonoid M\ns : Finset ι\nf : ι → M\na : ι\nhp : ∏ x ∈ s, f x = 1\nh1 : ∀ x ∈ s, x ≠ a → f x = 1\nx : ι\nhx : a ∈ s\nh : x = a\n⊢ f a = 1",
"usedConstants": [
"Finset.notMem_singleton",
"Iff.mpr",
"MulOne.toOne",
"Monoid.toMulO... | rw [← prod_subset (singleton_subset_iff.2 hx) fun t ht ha => h1 t ht (notMem_singleton.1 ha),
prod_singleton] at hp | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.GroupTheory.Finiteness | {
"line": 492,
"column": 2
} | {
"line": 493,
"column": 35
} | [
{
"pp": "case mpr\nG : Type u_3\ninst✝ : Group G\n⊢ (∃ α, ∃ (_ : Finite α), ∃ φ, Function.Surjective ⇑φ) → FG G",
"usedConstants": [
"MonoidHom.instFunLike",
"MonoidHom",
"Monoid.toMulOneClass",
"Finite",
"Group.FG",
"Group.fg_of_surjective",
"Exists",
"DivInv... | · intro ⟨α, _, φ, hφ⟩
exact Group.fg_of_surjective hφ | Lean.Elab.Tactic.evalTacticCDot | Lean.cdot |
Mathlib.GroupTheory.Commutator.Basic | {
"line": 141,
"column": 2
} | {
"line": 141,
"column": 71
} | [
{
"pp": "G : Type u_1\nG' : Type u_2\nF : Type u_3\ninst✝³ : Group G\ninst✝² : Group G'\ninst✝¹ : FunLike F G G'\ninst✝ : MonoidHomClass F G G'\nf : F\ng₁ g₂ g₃ g : G\nH H₁ H₂ H₃ K₁ K₂ : Subgroup G\nh₁ : H₁.Normal\nh₂ : H₂.Normal\nbase : Set G := {x | ∃ g₁ ∈ H₁, ∃ g₂ ∈ H₂, ⁅g₁, g₂⁆ = x}\n⊢ base = Group.conjugat... | refine Set.Subset.antisymm Group.subset_conjugatesOfSet fun a h => ?_ | Lean.Elab.Tactic.evalRefine | Lean.Parser.Tactic.refine |
Mathlib.GroupTheory.Commutator.Basic | {
"line": 212,
"column": 4
} | {
"line": 212,
"column": 22
} | [
{
"pp": "case a\nG : Type u_1\nG' : Type u_2\ninst✝¹ : Group G\ninst✝ : Group G'\nH₁ H₂ : Subgroup G\nK₁ K₂ : Subgroup G'\n⊢ ⁅H₁.prod K₁, H₂.prod K₂⁆ ≤ ⁅H₁, H₂⁆.prod ⁅K₁, K₂⁆",
"usedConstants": [
"Eq.mpr",
"congrArg",
"PartialOrder.toPreorder",
"Bracket.bracket",
"Preorder.toLE... | rw [commutator_le] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.GroupTheory.Commutator.Basic | {
"line": 358,
"column": 4
} | {
"line": 359,
"column": 23
} | [
{
"pp": "case h₁\nG : Type u_1\ninst✝ : Group G\n⊢ ⇑(closureCommutatorRepresentatives G).subtype '' commutatorSet ↥(closureCommutatorRepresentatives G) ⊆ commutatorSet G",
"usedConstants": [
"commutatorSet",
"MonoidHom.instFunLike",
"MonoidHom",
"Monoid.toMulOneClass",
"Subgrou... | rintro - ⟨-, ⟨g₁, g₂, rfl⟩, rfl⟩
exact ⟨g₁, g₂, rfl⟩ | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.GroupTheory.Commutator.Basic | {
"line": 358,
"column": 4
} | {
"line": 359,
"column": 23
} | [
{
"pp": "case h₁\nG : Type u_1\ninst✝ : Group G\n⊢ ⇑(closureCommutatorRepresentatives G).subtype '' commutatorSet ↥(closureCommutatorRepresentatives G) ⊆ commutatorSet G",
"usedConstants": [
"commutatorSet",
"MonoidHom.instFunLike",
"MonoidHom",
"Monoid.toMulOneClass",
"Subgrou... | rintro - ⟨-, ⟨g₁, g₂, rfl⟩, rfl⟩
exact ⟨g₁, g₂, rfl⟩ | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.GroupTheory.Commutator.Basic | {
"line": 377,
"column": 53
} | {
"line": 377,
"column": 74
} | [
{
"pp": "case mp\nG : Type u_1\ninst✝¹ : Group G\nN : Subgroup G\ninst✝ : N.Normal\nhcomm : Std.Commutative fun x1 x2 ↦ x1 * x2\np q : G\n⊢ ↑⁅p, q⁆ = 1",
"usedConstants": [
"Eq.mpr",
"commutatorElement_def",
"DivInvMonoid.toInv",
"InvOneClass.toOne",
"HMul.hMul",
"DivInvO... | commutatorElement_def | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.GroupTheory.OreLocalization.Basic | {
"line": 140,
"column": 22
} | {
"line": 140,
"column": 55
} | [
{
"pp": "R : Type u_1\ninst✝² : Monoid R\nS : Submonoid R\ninst✝¹ : OreSet S\nX : Type u_2\ninst✝ : MulAction R X\nr : X\ns : ↥S\nt : R\nhst : t * ↑s ∈ S\n⊢ s • (t • r, ⟨t * ↑s, hst⟩).fst = (↑s * t) • (r, s).fst",
"usedConstants": [
"Eq.mpr",
"Semigroup.toMul",
"instHSMul",
"HMul.hMu... | rw [mul_smul, Submonoid.smul_def] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.GroupTheory.OreLocalization.Basic | {
"line": 140,
"column": 22
} | {
"line": 140,
"column": 55
} | [
{
"pp": "R : Type u_1\ninst✝² : Monoid R\nS : Submonoid R\ninst✝¹ : OreSet S\nX : Type u_2\ninst✝ : MulAction R X\nr : X\ns : ↥S\nt : R\nhst : t * ↑s ∈ S\n⊢ s • (t • r, ⟨t * ↑s, hst⟩).fst = (↑s * t) • (r, s).fst",
"usedConstants": [
"Eq.mpr",
"Semigroup.toMul",
"instHSMul",
"HMul.hMu... | rw [mul_smul, Submonoid.smul_def] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.GroupTheory.OreLocalization.Basic | {
"line": 140,
"column": 22
} | {
"line": 140,
"column": 55
} | [
{
"pp": "R : Type u_1\ninst✝² : Monoid R\nS : Submonoid R\ninst✝¹ : OreSet S\nX : Type u_2\ninst✝ : MulAction R X\nr : X\ns : ↥S\nt : R\nhst : t * ↑s ∈ S\n⊢ s • (t • r, ⟨t * ↑s, hst⟩).fst = (↑s * t) • (r, s).fst",
"usedConstants": [
"Eq.mpr",
"Semigroup.toMul",
"instHSMul",
"HMul.hMu... | rw [mul_smul, Submonoid.smul_def] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Algebra.Order.Hom.Monoid | {
"line": 280,
"column": 75
} | {
"line": 282,
"column": 5
} | [
{
"pp": "α : Type u_2\nβ : Type u_3\ninst✝³ : Preorder α\ninst✝² : Preorder β\ninst✝¹ : MulOneClass α\ninst✝ : MulOneClass β\nf : α →*o β\nh : Monotone (↑↑f).toFun\n⊢ { toMonoidHom := ↑f, monotone' := h } = f",
"usedConstants": [
"OrderMonoidHom",
"OrderMonoidHom.mk",
"MonoidHomClass.toMon... | by
ext
rfl | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Algebra.Order.Ring.WithTop | {
"line": 97,
"column": 2
} | {
"line": 104,
"column": 37
} | [
{
"pp": "α : Type u_1\ninst✝³ : DecidableEq α\ninst✝² : MulZeroClass α\na : WithTop α\ninst✝¹ : Preorder α\ninst✝ : PosMulStrictMono α\nh₀ : 0 < a\nhinf : a ≠ ⊤\n⊢ StrictMono fun x ↦ a * x",
"usedConstants": [
"Eq.mpr",
"Preorder.toLT",
"HMul.hMul",
"StrictMono",
"MulZeroClass.... | lift a to α using hinf
rintro b c hbc
lift b to α using hbc.ne_top
match c with
| ⊤ => simp [← coe_mul, mul_top h₀.ne']
| (c : α) =>
simp only [coe_pos, coe_lt_coe, ← coe_mul, gt_iff_lt] at *
exact mul_lt_mul_of_pos_left hbc h₀ | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Algebra.Order.Ring.WithTop | {
"line": 97,
"column": 2
} | {
"line": 104,
"column": 37
} | [
{
"pp": "α : Type u_1\ninst✝³ : DecidableEq α\ninst✝² : MulZeroClass α\na : WithTop α\ninst✝¹ : Preorder α\ninst✝ : PosMulStrictMono α\nh₀ : 0 < a\nhinf : a ≠ ⊤\n⊢ StrictMono fun x ↦ a * x",
"usedConstants": [
"Eq.mpr",
"Preorder.toLT",
"HMul.hMul",
"StrictMono",
"MulZeroClass.... | lift a to α using hinf
rintro b c hbc
lift b to α using hbc.ne_top
match c with
| ⊤ => simp [← coe_mul, mul_top h₀.ne']
| (c : α) =>
simp only [coe_pos, coe_lt_coe, ← coe_mul, gt_iff_lt] at *
exact mul_lt_mul_of_pos_left hbc h₀ | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Order.SuccPred.Archimedean | {
"line": 327,
"column": 4
} | {
"line": 327,
"column": 9
} | [
{
"pp": "α : Type u_1\nβ : Type u_2\ninst✝³ : PartialOrder α\ninst✝² : PredOrder α\ninst✝¹ : IsPredArchimedean α\ns : Set α\ninst✝ : s.OrdConnected\nx✝¹ x✝ : ↑s\nb : α\nhb : b ∈ s\nc : α\nhc : c ∈ s\nhbc : b ≤ c\nn : ℕ\nhn : pred^[n] c = b\n⊢ ∃ n, pred^[n] ⟨c, hc⟩ = ⟨b, hb⟩",
"usedConstants": [
"Parti... | use n | Mathlib.Tactic._aux_Mathlib_Tactic_Use___elabRules_Mathlib_Tactic_useSyntax_1 | Mathlib.Tactic.useSyntax |
Mathlib.Order.SuccPred.Basic | {
"line": 385,
"column": 2
} | {
"line": 385,
"column": 42
} | [
{
"pp": "α : Type u_1\ninst✝² : PartialOrder α\ninst✝¹ : SuccOrder α\ninst✝ : OrderTop α\n⊢ succ ⊤ = ⊤",
"usedConstants": [
"isMax_iff_eq_top",
"Eq.mpr",
"Order.succ",
"congrArg",
"PartialOrder.toPreorder",
"Preorder.toLE",
"id",
"Order.succ_eq_iff_isMax",
... | rw [succ_eq_iff_isMax, isMax_iff_eq_top] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.Order.SuccPred.Basic | {
"line": 385,
"column": 2
} | {
"line": 385,
"column": 42
} | [
{
"pp": "α : Type u_1\ninst✝² : PartialOrder α\ninst✝¹ : SuccOrder α\ninst✝ : OrderTop α\n⊢ succ ⊤ = ⊤",
"usedConstants": [
"isMax_iff_eq_top",
"Eq.mpr",
"Order.succ",
"congrArg",
"PartialOrder.toPreorder",
"Preorder.toLE",
"id",
"Order.succ_eq_iff_isMax",
... | rw [succ_eq_iff_isMax, isMax_iff_eq_top] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Order.SuccPred.Basic | {
"line": 385,
"column": 2
} | {
"line": 385,
"column": 42
} | [
{
"pp": "α : Type u_1\ninst✝² : PartialOrder α\ninst✝¹ : SuccOrder α\ninst✝ : OrderTop α\n⊢ succ ⊤ = ⊤",
"usedConstants": [
"isMax_iff_eq_top",
"Eq.mpr",
"Order.succ",
"congrArg",
"PartialOrder.toPreorder",
"Preorder.toLE",
"id",
"Order.succ_eq_iff_isMax",
... | rw [succ_eq_iff_isMax, isMax_iff_eq_top] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Order.SuccPred.Limit | {
"line": 280,
"column": 2
} | {
"line": 280,
"column": 46
} | [
{
"pp": "α : Type u_1\na : α\ninst✝¹ : PartialOrder α\ninst✝ : SuccOrder α\nh : ¬IsSuccPrelimit a\n⊢ a ∈ range succ",
"usedConstants": [
"Preorder.toLT",
"Order.succ",
"Order.IsSuccPrelimit",
"PartialOrder.toPreorder",
"Preorder.toLE",
"Exists",
"And",
"Iff.mp... | obtain ⟨b, hb⟩ := not_isSuccPrelimit_iff.1 h | _private.Lean.Elab.Tactic.RCases.0.Lean.Elab.Tactic.RCases.evalObtain | Lean.Parser.Tactic.obtain |
Mathlib.Algebra.Order.SuccPred | {
"line": 351,
"column": 82
} | {
"line": 352,
"column": 66
} | [
{
"pp": "α : Type u_2\nβ : Type u_3\ninst✝⁵ : PartialOrder α\ninst✝⁴ : Preorder β\ninst✝³ : Sub α\ninst✝² : One α\ninst✝¹ : PredSubOrder α\ninst✝ : IsPredArchimedean α\nf : α → β\n⊢ (∀ (a : α), ¬IsMin a → f (a - 1) ≤ f a) → Monotone f",
"usedConstants": [
"Eq.mpr",
"PredSubOrder.toPredOrder",
... | by
simpa [Order.pred_eq_sub_one] using monotone_of_pred_le (f := f) | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Logic.Small.Defs | {
"line": 73,
"column": 90
} | {
"line": 75,
"column": 29
} | [
{
"pp": "α : Type u_1\ninst✝ : Small.{w, u_1} α\nF : Shrink.{w, u_1} α → Sort v\nf : (a : α) → F ((equivShrink α) a)\na : α\n⊢ Shrink.rec f ((equivShrink α) a) = f a",
"usedConstants": [
"Eq.mpr",
"eqRec_eq_cast",
"Equiv.instEquivLike",
"congrArg",
"Equiv.symm_apply_apply",
... | by
simp only [Shrink.rec, eqRec_eq_cast, cast_eq_iff_heq]
rw [Equiv.symm_apply_apply] | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Data.Vector.Basic | {
"line": 45,
"column": 34
} | {
"line": 45,
"column": 45
} | [
{
"pp": "α : Type u_1\nn : ℕ\nv : List α\nhv : v.length = n\nw : List α\nhw : w.length = n\nh : ∀ (m : Fin n), get ⟨v, hv⟩ m = get ⟨w, hw⟩ m\n⊢ (↑⟨v, hv⟩).length = (↑⟨w, hw⟩).length",
"usedConstants": [
"Eq.mpr",
"congrArg",
"id",
"Subtype.mk",
"List",
"Nat",
"Eq.re... | rw [hv, hw] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.Data.Vector.Basic | {
"line": 45,
"column": 34
} | {
"line": 45,
"column": 45
} | [
{
"pp": "α : Type u_1\nn : ℕ\nv : List α\nhv : v.length = n\nw : List α\nhw : w.length = n\nh : ∀ (m : Fin n), get ⟨v, hv⟩ m = get ⟨w, hw⟩ m\n⊢ (↑⟨v, hv⟩).length = (↑⟨w, hw⟩).length",
"usedConstants": [
"Eq.mpr",
"congrArg",
"id",
"Subtype.mk",
"List",
"Nat",
"Eq.re... | rw [hv, hw] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Data.Vector.Basic | {
"line": 45,
"column": 34
} | {
"line": 45,
"column": 45
} | [
{
"pp": "α : Type u_1\nn : ℕ\nv : List α\nhv : v.length = n\nw : List α\nhw : w.length = n\nh : ∀ (m : Fin n), get ⟨v, hv⟩ m = get ⟨w, hw⟩ m\n⊢ (↑⟨v, hv⟩).length = (↑⟨w, hw⟩).length",
"usedConstants": [
"Eq.mpr",
"congrArg",
"id",
"Subtype.mk",
"List",
"Nat",
"Eq.re... | rw [hv, hw] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Data.Vector.Basic | {
"line": 560,
"column": 6
} | {
"line": 565,
"column": 41
} | [
{
"pp": "case pos\nα : Type u_1\nn : ℕ\na : α\nv : Vector α (n + 1)\ni : ℕ\nhi : i < n + 1\nj : ℕ\nhj : j < n + 2\nhij : i < j\n⊢ ((↑v).insertIdx j a).eraseIdx ↑⟨i, ⋯⟩ =\n (↑(match v with\n | ⟨l, p⟩ => ⟨l.eraseIdx i, ⋯⟩)).insertIdx\n (↑(⟨j, hj⟩.pred ⋯)) a",
"usedConstants": [
"Eq.mpr"... | rcases Nat.exists_eq_succ_of_ne_zero
(Nat.pos_iff_ne_zero.1 (lt_of_le_of_lt (Nat.zero_le _) hij)) with ⟨j, rfl⟩
rw [← List.insertIdx_eraseIdx_of_ge]
· simp; rfl
· simpa
· simpa [Nat.lt_succ_iff] using hij | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Data.Vector.Basic | {
"line": 560,
"column": 6
} | {
"line": 565,
"column": 41
} | [
{
"pp": "case pos\nα : Type u_1\nn : ℕ\na : α\nv : Vector α (n + 1)\ni : ℕ\nhi : i < n + 1\nj : ℕ\nhj : j < n + 2\nhij : i < j\n⊢ ((↑v).insertIdx j a).eraseIdx ↑⟨i, ⋯⟩ =\n (↑(match v with\n | ⟨l, p⟩ => ⟨l.eraseIdx i, ⋯⟩)).insertIdx\n (↑(⟨j, hj⟩.pred ⋯)) a",
"usedConstants": [
"Eq.mpr"... | rcases Nat.exists_eq_succ_of_ne_zero
(Nat.pos_iff_ne_zero.1 (lt_of_le_of_lt (Nat.zero_le _) hij)) with ⟨j, rfl⟩
rw [← List.insertIdx_eraseIdx_of_ge]
· simp; rfl
· simpa
· simpa [Nat.lt_succ_iff] using hij | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Data.Countable.Basic | {
"line": 115,
"column": 2
} | {
"line": 115,
"column": 55
} | [
{
"pp": "α : Type u\nβ : Type v\nπ : α → Type w\ninst✝¹ : Countable α\ninst✝ : ∀ (a : α), Countable (π a)\nf : α → ℕ\nhf : Injective f\n⊢ Countable (Sigma π)",
"usedConstants": [
"Classical.choose_spec",
"Countable.exists_injective_nat",
"Nat",
"Classical.choose",
"Function.Inj... | choose g hg using fun a => exists_injective_nat (π a) | Mathlib.Tactic.Choose._aux_Mathlib_Tactic_Choose___elabRules_Mathlib_Tactic_Choose_choose_1 | Mathlib.Tactic.Choose.choose |
Mathlib.Data.Fintype.BigOperators | {
"line": 186,
"column": 8
} | {
"line": 186,
"column": 44
} | [
{
"pp": "case pos\nι : Type u_4\nα : ι → Type u_6\ninst✝² : DecidableEq ι\ninst✝¹ : Fintype ι\ninst✝ : (i : ι) → DecidableEq (α i)\ns : (i : ι) → Finset (α i)\ni : ι\na : α i\nh : a ∈ s i\n⊢ #({f ∈ piFinset s | f i = a}) = ∏ b ∈ univ.erase i, #(s b)",
"usedConstants": [
"Eq.mpr",
"Finset.univ",
... | card_filter_piFinset_eq_of_mem _ _ h | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Data.Fintype.BigOperators | {
"line": 186,
"column": 4
} | {
"line": 186,
"column": 45
} | [
{
"pp": "case pos\nι : Type u_4\nα : ι → Type u_6\ninst✝² : DecidableEq ι\ninst✝¹ : Fintype ι\ninst✝ : (i : ι) → DecidableEq (α i)\ns : (i : ι) → Finset (α i)\ni : ι\na : α i\nh : a ∈ s i\n⊢ #({f ∈ piFinset s | f i = a}) = ∏ b ∈ univ.erase i, #(s b)",
"usedConstants": [
"Eq.mpr",
"Finset.univ",
... | rw [card_filter_piFinset_eq_of_mem _ _ h] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.Data.Fintype.BigOperators | {
"line": 186,
"column": 4
} | {
"line": 186,
"column": 45
} | [
{
"pp": "case pos\nι : Type u_4\nα : ι → Type u_6\ninst✝² : DecidableEq ι\ninst✝¹ : Fintype ι\ninst✝ : (i : ι) → DecidableEq (α i)\ns : (i : ι) → Finset (α i)\ni : ι\na : α i\nh : a ∈ s i\n⊢ #({f ∈ piFinset s | f i = a}) = ∏ b ∈ univ.erase i, #(s b)",
"usedConstants": [
"Eq.mpr",
"Finset.univ",
... | rw [card_filter_piFinset_eq_of_mem _ _ h] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Data.Fintype.BigOperators | {
"line": 186,
"column": 4
} | {
"line": 186,
"column": 45
} | [
{
"pp": "case pos\nι : Type u_4\nα : ι → Type u_6\ninst✝² : DecidableEq ι\ninst✝¹ : Fintype ι\ninst✝ : (i : ι) → DecidableEq (α i)\ns : (i : ι) → Finset (α i)\ni : ι\na : α i\nh : a ∈ s i\n⊢ #({f ∈ piFinset s | f i = a}) = ∏ b ∈ univ.erase i, #(s b)",
"usedConstants": [
"Eq.mpr",
"Finset.univ",
... | rw [card_filter_piFinset_eq_of_mem _ _ h] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Order.InitialSeg | {
"line": 280,
"column": 2
} | {
"line": 282,
"column": 11
} | [
{
"pp": "α : Type u_1\nβ : Type u_2\nr : α → α → Prop\ns : β → β → Prop\ninst✝¹ : Std.Irrefl s\ninst✝ : Std.Trichotomous s\nf g : r ≺i s\nh : ∀ (x : α), f.toRelEmbedding x = g.toRelEmbedding x\n⊢ f = g",
"usedConstants": [
"Eq.mpr",
"congrArg",
"PrincipalSeg",
"PrincipalSeg.toRelEmbe... | rw [← toRelEmbedding_inj]
ext
exact h _ | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Order.InitialSeg | {
"line": 280,
"column": 2
} | {
"line": 282,
"column": 11
} | [
{
"pp": "α : Type u_1\nβ : Type u_2\nr : α → α → Prop\ns : β → β → Prop\ninst✝¹ : Std.Irrefl s\ninst✝ : Std.Trichotomous s\nf g : r ≺i s\nh : ∀ (x : α), f.toRelEmbedding x = g.toRelEmbedding x\n⊢ f = g",
"usedConstants": [
"Eq.mpr",
"congrArg",
"PrincipalSeg",
"PrincipalSeg.toRelEmbe... | rw [← toRelEmbedding_inj]
ext
exact h _ | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Order.ScottContinuity | {
"line": 176,
"column": 2
} | {
"line": 177,
"column": 49
} | [
{
"pp": "α : Type u_1\nβ : Type u_2\nγ : Type u_3\ninst✝² : Preorder α\ninst✝¹ : Preorder β\ninst✝ : Preorder γ\nf : α → β\ng : α → γ\nhf : ScottContinuous f\nhg : ScottContinuous g\n⊢ ScottContinuous fun x ↦ (f x, g x)",
"usedConstants": [
"Eq.mpr",
"congrArg",
"scottContinuousOn_univ",
... | rw [← scottContinuousOn_univ] at ⊢ hf hg
exact ScottContinuousOn.prodMk (by grind) hf hg | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Order.ScottContinuity | {
"line": 176,
"column": 2
} | {
"line": 177,
"column": 49
} | [
{
"pp": "α : Type u_1\nβ : Type u_2\nγ : Type u_3\ninst✝² : Preorder α\ninst✝¹ : Preorder β\ninst✝ : Preorder γ\nf : α → β\ng : α → γ\nhf : ScottContinuous f\nhg : ScottContinuous g\n⊢ ScottContinuous fun x ↦ (f x, g x)",
"usedConstants": [
"Eq.mpr",
"congrArg",
"scottContinuousOn_univ",
... | rw [← scottContinuousOn_univ] at ⊢ hf hg
exact ScottContinuousOn.prodMk (by grind) hf hg | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Order.ScottContinuity | {
"line": 200,
"column": 2
} | {
"line": 200,
"column": 73
} | [
{
"pp": "β : Type u_2\ninst✝ : SemilatticeSup β\nd : Set (β × β)\nx✝² : d.Nonempty\nx✝¹ : DirectedOn (fun x1 x2 ↦ x1 ≤ x2) d\nx✝ : β × β\np₁ p₂ : β\nhdp : (∀ (a b : β), (a, b) ∈ d → a ≤ p₁ ∧ b ≤ p₂) ∧ (p₁, p₂) ∈ lowerBounds {x | ∀ (a b : β), (a, b) ∈ d → (a, b) ≤ x}\ne1 : (p₁, p₂) ∈ lowerBounds {x | ∀ (b₁ b₂ : ... | simp only [lowerBounds, mem_setOf_eq, Prod.forall, Prod.mk_le_mk] at e1 | Lean.Elab.Tactic.evalSimp | Lean.Parser.Tactic.simp |
Mathlib.Algebra.Regular.SMul | {
"line": 69,
"column": 26
} | {
"line": 69,
"column": 44
} | [
{
"pp": "M : Type u_3\ninst✝ : SubtractionMonoid M\nn : ℤ\n⊢ (Function.Injective fun x ↦ n.natAbs • x) ↔ Function.Injective fun x ↦ n • x",
"usedConstants": [
"instHSMul",
"AddMonoid.toNSMul",
"id",
"Int",
"SubtractionMonoid.toSubNegMonoid",
"Iff",
"Nat",
"Int... | Function.Injective | Mathlib.Tactic._aux_Mathlib_Tactic_SimpRw___elabRules_Mathlib_Tactic_tacticSimp_rw____1 | null |
Mathlib.SetTheory.Cardinal.Basic | {
"line": 88,
"column": 12
} | {
"line": 88,
"column": 14
} | [
{
"pp": "case refine_3\nα✝ : Type u\nh : Fintype α✝\nα : Type u\n⊢ ∀ [inst : Fintype α],\n (∀ (f : α → Cardinal.{v}), prod f = lift.{u, v} (∏ i, f i)) →\n ∀ (f : Option α → Cardinal.{v}), prod f = lift.{u, v} (∏ i, f i)",
"usedConstants": [
"Fintype"
]
}
] | hα | Lean.Elab.Tactic.evalIntro | ident |
Mathlib.SetTheory.Cardinal.Basic | {
"line": 146,
"column": 2
} | {
"line": 146,
"column": 17
} | [
{
"pp": "α β : Type u\na : Cardinal.{u}\n⊢ Small.{u, u + 1} ↑(Iic a)",
"usedConstants": [
"Eq.mpr",
"Cardinal",
"Cardinal.mk_out",
"congrArg",
"PartialOrder.toPreorder",
"Cardinal.mk",
"Set.Elem",
"id",
"Quotient.out",
"Cardinal.isEquivalent",
... | rw [← mk_out a] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.SetTheory.Cardinal.Basic | {
"line": 964,
"column": 82
} | {
"line": 964,
"column": 96
} | [
{
"pp": "α : Type u\n⊢ Nontrivial α ↔ ∃ x y, x ≠ y",
"usedConstants": [
"Nontrivial",
"Eq.mpr",
"congrArg",
"Exists",
"id",
"Ne",
"nontrivial_iff",
"Iff",
"propext",
"Eq"
]
}
] | nontrivial_iff | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Algebra.Group.Action.Prod | {
"line": 139,
"column": 8
} | {
"line": 139,
"column": 80
} | [
{
"pp": "M : Type u_1\nN : Type u_2\nP : Type u_3\nE : Type u_4\nα : Type u_5\nβ : Type u_6\ninst✝¹ : Monoid M\ninst✝ : Monoid N\nx✝ : MulAction (M × N) α\ninstM : MulAction M α := compHom α (MonoidHom.inl M N)\ninstN : MulAction N α := compHom α (MonoidHom.inr M N)\nm : M\nn : N\na : α\n⊢ m • n • a = n • m • a... | change (m, (1 : N)) • ((1 : M), n) • a = ((1 : M), n) • (m, (1 : N)) • a | Lean.Elab.Tactic.evalChange | Lean.Parser.Tactic.change |
Mathlib.Algebra.Ring.Opposite | {
"line": 71,
"column": 63
} | {
"line": 71,
"column": 79
} | [
{
"pp": "R : Type u_1\ninst✝ : AddGroupWithOne R\nn : ℕ\n⊢ op ↑↑n = op ↑n",
"usedConstants": [
"Int.cast",
"Eq.mpr",
"Int.cast_natCast",
"congrArg",
"MulOpposite",
"AddGroupWithOne.toAddMonoidWithOne",
"id",
"AddMonoidWithOne.toNatCast",
"Int",
"Ad... | Int.cast_natCast | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Algebra.Module.Hom | {
"line": 54,
"column": 83
} | {
"line": 54,
"column": 93
} | [
{
"pp": "R : Type u_1\nS✝ : Type u_2\nM✝ : Type u_3\nA : Type u_4\nB : Type u_5\nS : Type u_6\nM : Type u_7\nM₂ : Type u_8\ninst✝³ : Semiring S\ninst✝² : AddCommMonoid M\ninst✝¹ : AddCommMonoid M₂\ninst✝ : Module S M\ns s' : Sᵈᵐᵃ\nf : M →+ M₂\nm : M\n⊢ f (DomMulAct.mk.symm (s + s') • m) = f (DomMulAct.mk.symm s... | ← add_smul | Mathlib.Tactic._aux_Mathlib_Tactic_SimpRw___elabRules_Mathlib_Tactic_tacticSimp_rw____1 | null |
Mathlib.Algebra.Module.LinearMap.Basic | {
"line": 112,
"column": 67
} | {
"line": 112,
"column": 77
} | [
{
"pp": "R : Type u_1\nR' : Type u_2\nS : Type u_3\nM : Type u_4\nM' : Type u_5\ninst✝¹⁰ : Semiring R\ninst✝⁹ : Semiring R'\ninst✝⁸ : AddCommMonoid M\ninst✝⁷ : AddCommMonoid M'\ninst✝⁶ : Module R M\ninst✝⁵ : Module R' M'\nσ₁₂ : R →+* R'\ninst✝⁴ : Semiring S\ninst✝³ : Module S M\ninst✝² : Module S M'\ninst✝¹ : S... | ← add_smul | Mathlib.Tactic._aux_Mathlib_Tactic_SimpRw___elabRules_Mathlib_Tactic_tacticSimp_rw____1 | null |
Mathlib.Algebra.Module.Equiv.Basic | {
"line": 284,
"column": 4
} | {
"line": 284,
"column": 30
} | [
{
"pp": "case h.e'_3\nR : Type u_1\nR₂ : Type u_2\nK : Type u_3\nS : Type u_4\nM : Type u_5\nM₁ : Type u_6\nM₂ : Type u_7\nM₃ : Type u_8\ninst✝² : AddCommGroup M\ninst✝¹ : AddCommGroup M₂\ninst✝ : AddCommGroup M₃\nmodM : Module ℤ M\nmodM₂ : Module ℤ M₂\nmodM₃ : Module ℤ M₃\ne : M ≃+ M₂\nc : ℤ\na : M\n⊢ c • e a ... | exact int_smul_eq_zsmul .. | Lean.Elab.Tactic.evalExact | Lean.Parser.Tactic.exact |
Mathlib.Algebra.Module.Equiv.Basic | {
"line": 284,
"column": 4
} | {
"line": 284,
"column": 30
} | [
{
"pp": "case h.e'_3\nR : Type u_1\nR₂ : Type u_2\nK : Type u_3\nS : Type u_4\nM : Type u_5\nM₁ : Type u_6\nM₂ : Type u_7\nM₃ : Type u_8\ninst✝² : AddCommGroup M\ninst✝¹ : AddCommGroup M₂\ninst✝ : AddCommGroup M₃\nmodM : Module ℤ M\nmodM₂ : Module ℤ M₂\nmodM₃ : Module ℤ M₃\ne : M ≃+ M₂\nc : ℤ\na : M\n⊢ c • e a ... | exact int_smul_eq_zsmul .. | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Algebra.Module.Equiv.Basic | {
"line": 284,
"column": 4
} | {
"line": 284,
"column": 30
} | [
{
"pp": "case h.e'_3\nR : Type u_1\nR₂ : Type u_2\nK : Type u_3\nS : Type u_4\nM : Type u_5\nM₁ : Type u_6\nM₂ : Type u_7\nM₃ : Type u_8\ninst✝² : AddCommGroup M\ninst✝¹ : AddCommGroup M₂\ninst✝ : AddCommGroup M₃\nmodM : Module ℤ M\nmodM₂ : Module ℤ M₂\nmodM₃ : Module ℤ M₃\ne : M ≃+ M₂\nc : ℤ\na : M\n⊢ c • e a ... | exact int_smul_eq_zsmul .. | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.