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.RingTheory.Ideal.KrullsHeightTheorem | {
"line": 434,
"column": 2
} | {
"line": 439,
"column": 75
} | [
{
"pp": "R : Type u_1\ninst✝⁷ : CommRing R\ninst✝⁶ : IsNoetherianRing R\nS : Type u_2\ninst✝⁵ : CommRing S\ninst✝⁴ : Algebra R S\ninst✝³ : IsNoetherianRing S\np : Ideal R\ninst✝² : p.IsPrime\nP : Ideal S\ninst✝¹ : P.IsPrime\ninst✝ : P.LiesOver p\ns : Finset R\nhp : p ∈ (span ↑s).minimalPrimes\nheq : ↑s.card = p... | have : Set.SurjOn (Ideal.Quotient.mk (p.map (algebraMap R S))) P s' := by
refine Set.SurjOn.mono subset_rfl hsP'sub fun x hx ↦ ?_
obtain ⟨y, rfl⟩ := Ideal.Quotient.mk_surjective x
rw [SetLike.mem_coe, Ideal.mem_quotient_iff_mem] at hx
· use y, hx
· rw [Ideal.map_le_iff_le_comap, Ideal.LiesOver.over ... | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_tacticHave___1 | Lean.Parser.Tactic.tacticHave__ |
Mathlib.RingTheory.Regular.RegularSequence | {
"line": 82,
"column": 32
} | {
"line": 82,
"column": 43
} | [
{
"pp": "R : Type u_1\nS : Type u_2\nM : Type u_3\nM₂ : Type u_4\nM₃ : Type u_5\nM₄ : Type u_6\ninst✝⁴ : CommRing R\ninst✝³ : AddCommGroup M\ninst✝² : AddCommGroup M₂\ninst✝¹ : Module R M\ninst✝ : Module R M₂\nr : R\nrs : List R\n⊢ map (r • ⊤).mkQ (Ideal.ofList rs • ⊤) = Ideal.ofList rs • ⊤",
"usedConstants... | map_smul'', | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.RingTheory.KrullDimension.Regular | {
"line": 154,
"column": 2
} | {
"line": 154,
"column": 48
} | [
{
"pp": "case hs\nR : Type u_1\ninst✝² : CommRing R\ninst✝¹ : IsNoetherianRing R\ninst✝ : IsLocalRing R\nS : Finset R\nhS : ↑S ⊆ ↑(maximalIdeal R)\n⊢ ↑S ⊆ ↑(Ring.jacobson R)",
"usedConstants": [
"Eq.mpr",
"Semiring.toModule",
"congrArg",
"Finset",
"IsLocalRing.maximalIdeal",
... | rwa [IsLocalRing.ringJacobson_eq_maximalIdeal] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_tacticRwa___1 | Lean.Parser.Tactic.tacticRwa__ |
Mathlib.RingTheory.Regular.RegularSequence | {
"line": 562,
"column": 4
} | {
"line": 567,
"column": 65
} | [
{
"pp": "case cons\nR : Type u_1\nM₄ : Type u_6\ninst✝¹⁰ : CommRing R\ninst✝⁹ : AddCommGroup M₄\ninst✝⁸ : Module R M₄\nrs✝ : List R\nM✝ : Type u_6\ninst✝⁷ : AddCommGroup M✝\ninst✝⁶ : Module R M✝\nr : R\nrs : List R\nh₄ : IsSMulRegular M✝ r\nh2✝ : IsWeaklyRegular (QuotSMulTop r M✝) rs\nih :\n ∀ {M : Type u_3} {... | specialize ih
(map_first_exact_on_four_term_exact_of_isSMulRegular_last h₁₂ h₂₃ h₄)
(map_exact r h₂₃ h₃) (map_surjective r h₃)
have H₁ := quotOfListConsSMulTopEquivQuotSMulTopInner_naturality r rs f₁
have H₂ := quotOfListConsSMulTopEquivQuotSMulTopInner_naturality r rs f₂
exact (Exact.iff_of_lad... | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.RingTheory.Regular.RegularSequence | {
"line": 562,
"column": 4
} | {
"line": 567,
"column": 65
} | [
{
"pp": "case cons\nR : Type u_1\nM₄ : Type u_6\ninst✝¹⁰ : CommRing R\ninst✝⁹ : AddCommGroup M₄\ninst✝⁸ : Module R M₄\nrs✝ : List R\nM✝ : Type u_6\ninst✝⁷ : AddCommGroup M✝\ninst✝⁶ : Module R M✝\nr : R\nrs : List R\nh₄ : IsSMulRegular M✝ r\nh2✝ : IsWeaklyRegular (QuotSMulTop r M✝) rs\nih :\n ∀ {M : Type u_3} {... | specialize ih
(map_first_exact_on_four_term_exact_of_isSMulRegular_last h₁₂ h₂₃ h₄)
(map_exact r h₂₃ h₃) (map_surjective r h₃)
have H₁ := quotOfListConsSMulTopEquivQuotSMulTopInner_naturality r rs f₁
have H₂ := quotOfListConsSMulTopEquivQuotSMulTopInner_naturality r rs f₂
exact (Exact.iff_of_lad... | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.RingTheory.LocalIso | {
"line": 140,
"column": 4
} | {
"line": 140,
"column": 59
} | [
{
"pp": "R : Type u_1\nS : Type u_2\ninst✝⁸ : CommSemiring R\ninst✝⁷ : CommSemiring S\ninst✝⁶ : Algebra R S\nT : Type u_3\ninst✝⁵ : CommSemiring T\ninst✝⁴ : Algebra S T\ninst✝³ : Algebra R T\ninst✝² : IsScalarTower R S T\ninst✝¹ : IsLocalIso R S\ninst✝ : IsLocalIso S T\ns : Set S := {g | IsStandardOpenImmersion... | exact .of_span_range_eq_top _ h fun i : ι ↦ T'' i.1 i.2 | Lean.Elab.Tactic.evalExact | Lean.Parser.Tactic.exact |
Mathlib.RingTheory.Invariant.Profinite | {
"line": 81,
"column": 2
} | {
"line": 82,
"column": 68
} | [
{
"pp": "A : Type u_1\nB : Type u_2\ninst✝¹⁵ : CommRing A\ninst✝¹⁴ : CommRing B\ninst✝¹³ : Algebra A B\nG : Type u\ninst✝¹² : Group G\ninst✝¹¹ : MulSemiringAction G B\ninst✝¹⁰ : SMulCommClass G A B\ninst✝⁹ : TopologicalSpace G\ninst✝⁸ : CompactSpace G\ninst✝⁷ : TotallyDisconnectedSpace G\ninst✝⁶ : IsTopological... | let a := (ProfiniteGrp.of G).isoLimittoFiniteQuotientFunctor.inv.hom
⟨fun N ↦ (s N).1, (fun {N N'} f ↦ congr_arg Subtype.val (hs f))⟩ | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_tacticLet___1 | Lean.Parser.Tactic.tacticLet__ |
Mathlib.RingTheory.LocalProperties.InjectiveDimension | {
"line": 49,
"column": 2
} | {
"line": 69,
"column": 70
} | [
{
"pp": "R : Type u\ninst✝³ : CommRing R\ninst✝² : Small.{v, u} R\ninst✝¹ : IsNoetherianRing R\nn : ℕ\nS : Submonoid R\nM : ModuleCat R\ninst✝ : HasInjectiveDimensionLE M n\nthis : Small.{v, u} (Localization S)\n⊢ HasInjectiveDimensionLE (M.localizedModule S) n",
"usedConstants": [
"Function.Exact",
... | induction n generalizing M with
| zero =>
have injle : HasInjectiveDimensionLE M 0 := ‹_›
simp only [HasInjectiveDimensionLE, zero_add, ← injective_iff_hasInjectiveDimensionLT_one]
at injle ⊢
rw [← Module.injective_iff_injective_object] at injle ⊢
exact Module.injective_of_isLocalizedModule S (M... | _private.Lean.Elab.Tactic.Induction.0.Lean.Elab.Tactic.evalInduction | Lean.Parser.Tactic.induction |
Mathlib.RingTheory.MvPolynomial.Symmetric.FundamentalTheorem | {
"line": 194,
"column": 2
} | {
"line": 197,
"column": 75
} | [
{
"pp": "case refine_2.refine_1\nR : Type u_3\nm : ℕ\ninst✝¹ : CommSemiring R\ninst✝ : Nontrivial R\ni : ℕ\nhim : i < m\nt : Finset (Fin m)\nht : t ∈ powersetCard (i + 1) univ\nht' : #t = #(Iic ⟨i, him⟩)\nhne : ∃ x, x ∈ Iic ⟨i, him⟩ \\ t\nhkm : (Iic ⟨i, him⟩ \\ t).min' hne ∈ Iic ⟨i, him⟩ ∧ (Iic ⟨i, him⟩ \\ t).m... | · have hki := mem_Iic.2 (hk.le.trans <| mem_Iic.1 hkm.1)
rw [dif_pos hki, dif_pos]
by_contra h
exact lt_irrefl k <| ((lt_min'_iff _ _).1 hk) _ <| mem_sdiff.2 ⟨hki, h⟩ | Lean.Elab.Tactic.evalTacticCDot | Lean.cdot |
Mathlib.RingTheory.MvPolynomial.Symmetric.FundamentalTheorem | {
"line": 221,
"column": 33
} | {
"line": 221,
"column": 64
} | [
{
"pp": "case add_single\nR : Type u_3\nn m : ℕ\ninst✝ : CommSemiring R\nr : R\nhnm : n ≤ m\ni : Fin n\nb✝ : ℕ\nf✝ : Fin n →₀ ℕ\na✝¹ : i ∉ f✝.support\na✝ : b✝ ≠ 0\nih : leadingCoeff (⇑toLex) (esymmAlgHomMonomial (Fin m) f✝ r) = r\n⊢ leadingCoeff (⇑toLex) (esymmAlgHomMonomial (Fin m) f✝ r * esymmAlgHomMonomial (... | esymmAlgHomMonomial_single_one, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.RingTheory.MvPolynomial.Symmetric.FundamentalTheorem | {
"line": 234,
"column": 33
} | {
"line": 234,
"column": 64
} | [
{
"pp": "case add_single\nR : Type u_3\nn m : ℕ\ninst✝¹ : CommSemiring R\nr : R\nhr : r ≠ 0\nhnm : n ≤ m\ninst✝ : Nontrivial R\ni : Fin n\nb✝ : ℕ\nf✝ : Fin n →₀ ℕ\na✝¹ : i ∉ f✝.support\na✝ : b✝ ≠ 0\nih : ⇑(ofLex (supDegree (⇑toLex) (esymmAlgHomMonomial (Fin m) f✝ r))) = (accumulate n m) ⇑f✝\nthis : ↑i < m\n⊢ ⇑(... | esymmAlgHomMonomial_single_one, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.RingTheory.MvPolynomial.Symmetric.FundamentalTheorem | {
"line": 241,
"column": 6
} | {
"line": 241,
"column": 94
} | [
{
"pp": "case add_single.hp\nR : Type u_3\nn m : ℕ\ninst✝¹ : CommSemiring R\nr : R\nhr : r ≠ 0\nhnm : n ≤ m\ninst✝ : Nontrivial R\ni : Fin n\nb✝ : ℕ\nf✝ : Fin n →₀ ℕ\na✝¹ : i ∉ f✝.support\na✝ : b✝ ≠ 0\nih : ⇑(ofLex (supDegree (⇑toLex) (esymmAlgHomMonomial (Fin m) f✝ r))) = (accumulate n m) ⇑f✝\nthis : ↑i < m\n⊢... | rwa [Ne, ← leadingCoeff_eq_zero toLex.injective, leadingCoeff_esymmAlgHomMonomial _ hnm] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_tacticRwa___1 | Lean.Parser.Tactic.tacticRwa__ |
Mathlib.RingTheory.MvPolynomial.Symmetric.FundamentalTheorem | {
"line": 241,
"column": 6
} | {
"line": 241,
"column": 94
} | [
{
"pp": "case add_single.hp\nR : Type u_3\nn m : ℕ\ninst✝¹ : CommSemiring R\nr : R\nhr : r ≠ 0\nhnm : n ≤ m\ninst✝ : Nontrivial R\ni : Fin n\nb✝ : ℕ\nf✝ : Fin n →₀ ℕ\na✝¹ : i ∉ f✝.support\na✝ : b✝ ≠ 0\nih : ⇑(ofLex (supDegree (⇑toLex) (esymmAlgHomMonomial (Fin m) f✝ r))) = (accumulate n m) ⇑f✝\nthis : ↑i < m\n⊢... | rwa [Ne, ← leadingCoeff_eq_zero toLex.injective, leadingCoeff_esymmAlgHomMonomial _ hnm] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.RingTheory.MvPolynomial.Symmetric.FundamentalTheorem | {
"line": 241,
"column": 6
} | {
"line": 241,
"column": 94
} | [
{
"pp": "case add_single.hp\nR : Type u_3\nn m : ℕ\ninst✝¹ : CommSemiring R\nr : R\nhr : r ≠ 0\nhnm : n ≤ m\ninst✝ : Nontrivial R\ni : Fin n\nb✝ : ℕ\nf✝ : Fin n →₀ ℕ\na✝¹ : i ∉ f✝.support\na✝ : b✝ ≠ 0\nih : ⇑(ofLex (supDegree (⇑toLex) (esymmAlgHomMonomial (Fin m) f✝ r))) = (accumulate n m) ⇑f✝\nthis : ↑i < m\n⊢... | rwa [Ne, ← leadingCoeff_eq_zero toLex.injective, leadingCoeff_esymmAlgHomMonomial _ hnm] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.RingTheory.MvPowerSeries.Expand | {
"line": 39,
"column": 18
} | {
"line": 39,
"column": 34
} | [
{
"pp": "σ : Type u_1\nR : Type u_3\ninst✝ : CommRing R\np : ℕ\nhp : p ≠ 0\nr : R\n| (expand p hp) (C r)",
"usedConstants": [
"MvPowerSeries.expand",
"MulOne.toOne",
"HMul.hMul",
"congrArg",
"CommSemiring.toSemiring",
"AlgHom",
"AlgHom.funLike",
"MvPowerSeries... | ← mul_one (C r), | Lean.Elab.Tactic.Conv.evalRewrite | null |
Mathlib.RingTheory.MvPowerSeries.Expand | {
"line": 56,
"column": 2
} | {
"line": 57,
"column": 27
} | [
{
"pp": "σ : Type u_1\nR : Type u_3\ninst✝ : CommRing R\n⊢ expand 1 ⋯ = AlgHom.id R (MvPowerSeries σ R)",
"usedConstants": [
"MvPowerSeries.expand",
"Nat.instMulZeroClass",
"Nat.instOne",
"congrArg",
"CommSemiring.toSemiring",
"AlgHom",
"AlgHom.funLike",
"AlgH... | ext1 i
simp [expand, subst_self] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.RingTheory.MvPowerSeries.Expand | {
"line": 56,
"column": 2
} | {
"line": 57,
"column": 27
} | [
{
"pp": "σ : Type u_1\nR : Type u_3\ninst✝ : CommRing R\n⊢ expand 1 ⋯ = AlgHom.id R (MvPowerSeries σ R)",
"usedConstants": [
"MvPowerSeries.expand",
"Nat.instMulZeroClass",
"Nat.instOne",
"congrArg",
"CommSemiring.toSemiring",
"AlgHom",
"AlgHom.funLike",
"AlgH... | ext1 i
simp [expand, subst_self] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.RingTheory.MvPowerSeries.Expand | {
"line": 155,
"column": 2
} | {
"line": 155,
"column": 41
} | [
{
"pp": "σ : Type u_1\nR : Type u_3\ninst✝ : CommRing R\np : ℕ\nhp : p ≠ 0\nφ : MvPowerSeries σ R\nd n : σ →₀ ℕ\nhn₁ : n ∈ Function.support φ\nhn₂ : (fun x ↦ p • x) n = d\n⊢ d ∈ Function.support ((expand p hp) φ)",
"usedConstants": [
"MvPowerSeries.expand",
"Eq.mpr",
"Nat.instMulZeroClass"... | simp only [← hn₂, Function.mem_support] | Lean.Elab.Tactic.evalSimp | Lean.Parser.Tactic.simp |
Mathlib.RingTheory.MvPolynomial.Symmetric.NewtonIdentities | {
"line": 109,
"column": 4
} | {
"line": 109,
"column": 77
} | [
{
"pp": "case inl\nσ : Type u_1\ninst✝¹ : DecidableEq σ\ninst✝ : Fintype σ\nk : ℕ\nt : Finset σ × σ\nh1 : t.2 ∈ t.1\nh : #t.1 ≤ k\n⊢ #(t.1.erase t.2, t.2).1 ≤ k ∧ (#(t.1.erase t.2, t.2).1 = k → (t.1.erase t.2, t.2).2 ∈ (t.1.erase t.2, t.2).1)",
"usedConstants": [
"Eq.mpr",
"Nat.instOrderedSub",
... | simp only [card_erase_of_mem h1, tsub_le_iff_right, mem_erase, ne_eq, h1] | Lean.Elab.Tactic.evalSimp | Lean.Parser.Tactic.simp |
Mathlib.RingTheory.MvPowerSeries.Expand | {
"line": 233,
"column": 51
} | {
"line": 245,
"column": 73
} | [
{
"pp": "σ : Type u_1\nR : Type u_3\ninst✝¹ : CommRing R\np : ℕ\nhp : p ≠ 0\ninst✝ : ExpChar R p\nf : MvPowerSeries σ R\n⊢ (map (frobenius R p)) ((expand p hp) f) = f ^ p",
"usedConstants": [
"MvPowerSeries.expand",
"Iff.mpr",
"zero_le",
"Finsupp.instAddZeroClass",
"MvPowerSeri... | by
classical
rw [eq_iff_frequently_trunc'_eq, Filter.frequently_atTop]
intro n
use (p • n)
refine ⟨le_self_nsmul zero_le hp, ?_⟩
· have : (((trunc' R (p • n) f).expand p).map (frobenius R p)).toMvPowerSeries =
MvPowerSeries.map (frobenius R p) ((trunc' R (p • n) f).expand p) := by
simp only [MvP... | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.RingTheory.LaurentSeries | {
"line": 614,
"column": 2
} | {
"line": 614,
"column": 26
} | [
{
"pp": "case refine_1\nK : Type u_2\ninst✝ : Field K\nf : K⸨X⸩\nh : ∀ n < 0, f.coeff n = 0\n⊢ (ofPowerSeries ℤ K) (PowerSeries.mk fun n ↦ f.coeff ↑n) = f",
"usedConstants": [
"Int.instIsStrictOrderedRing",
"HahnSeries.instNonAssocSemiring",
"HahnSeries.ext",
"RingHom",
"Semila... | on_goal 1 => ext (_ | n) | Batteries.Tactic.«_aux_Batteries_Tactic_PermuteGoals___elabRules_Batteries_Tactic_tacticOn_goal-_=>__1» | Batteries.Tactic.«tacticOn_goal-_=>_» |
Mathlib.RingTheory.Perfection | {
"line": 159,
"column": 50
} | {
"line": 159,
"column": 65
} | [
{
"pp": "M✝ : Type u_1\ninst✝³ : CommMonoid M✝\np✝ p : ℕ\nM : Type u_2\ninst✝² : CommMonoid M\ninst✝¹ : PerfectRing M p\nN : Type u_3\ninst✝ : CommMonoid N\nf : M →* N\nr : M\nn : ℕ\n⊢ f ((powMulEquiv M p ^ n * powMulEquiv M p).symm r ^ p) = (fun n ↦ f ((powMulEquiv M (p ^ n)).symm r)) n",
"usedConstants": ... | MulAut.mul_def, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.RingTheory.Perfection | {
"line": 179,
"column": 61
} | {
"line": 179,
"column": 98
} | [
{
"pp": "M✝ : Type u_1\ninst✝² : CommMonoid M✝\np✝ p : ℕ\nM : Type u_2\nN : Type u_3\ninst✝¹ : CommMonoid M\ninst✝ : CommMonoid N\nφ : M →* N\nf : Perfection M p\nn : ℕ\n⊢ (fun n ↦ φ ((coeffMonoidHom M p n) f)) (n + 1) ^ p = (fun n ↦ φ ((coeffMonoidHom M p n) f)) n",
"usedConstants": [
"Eq.mpr",
... | rw [← map_pow, coeffMonoidHom_pow_p'] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.RingTheory.Perfection | {
"line": 179,
"column": 61
} | {
"line": 179,
"column": 98
} | [
{
"pp": "M✝ : Type u_1\ninst✝² : CommMonoid M✝\np✝ p : ℕ\nM : Type u_2\nN : Type u_3\ninst✝¹ : CommMonoid M\ninst✝ : CommMonoid N\nφ : M →* N\nf : Perfection M p\nn : ℕ\n⊢ (fun n ↦ φ ((coeffMonoidHom M p n) f)) (n + 1) ^ p = (fun n ↦ φ ((coeffMonoidHom M p n) f)) n",
"usedConstants": [
"Eq.mpr",
... | rw [← map_pow, coeffMonoidHom_pow_p'] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.RingTheory.Perfection | {
"line": 179,
"column": 61
} | {
"line": 179,
"column": 98
} | [
{
"pp": "M✝ : Type u_1\ninst✝² : CommMonoid M✝\np✝ p : ℕ\nM : Type u_2\nN : Type u_3\ninst✝¹ : CommMonoid M\ninst✝ : CommMonoid N\nφ : M →* N\nf : Perfection M p\nn : ℕ\n⊢ (fun n ↦ φ ((coeffMonoidHom M p n) f)) (n + 1) ^ p = (fun n ↦ φ ((coeffMonoidHom M p n) f)) n",
"usedConstants": [
"Eq.mpr",
... | rw [← map_pow, coeffMonoidHom_pow_p'] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.RingTheory.Perfection | {
"line": 571,
"column": 6
} | {
"line": 571,
"column": 23
} | [
{
"pp": "K : Type u₁\ninst✝² : Field K\nv : Valuation K ℝ≥0\nO : Type u₂\ninst✝¹ : CommRing O\ninst✝ : Algebra O K\nhv : v.Integers O\np : ℕ\nr : O\nhx0 : (Ideal.Quotient.mk (Ideal.span {↑p})) r ≠ 0\ns : O\nhy0 : (Ideal.Quotient.mk (Ideal.span {↑p})) s ≠ 0\nhxy0 : (Ideal.Quotient.mk (Ideal.span {↑p})) (r * s) ≠... | preVal_mk hv hx0, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.RingTheory.Perfection | {
"line": 584,
"column": 6
} | {
"line": 584,
"column": 23
} | [
{
"pp": "case neg\nK : Type u₁\ninst✝² : Field K\nv : Valuation K ℝ≥0\nO : Type u₂\ninst✝¹ : CommRing O\ninst✝ : Algebra O K\nhv : v.Integers O\np : ℕ\nr : O\nhx0 : (Ideal.Quotient.mk (Ideal.span {↑p})) r ≠ 0\ns : O\nhy0 : (Ideal.Quotient.mk (Ideal.span {↑p})) s ≠ 0\nhxy0 : ¬(Ideal.Quotient.mk (Ideal.span {↑p})... | preVal_mk hv hx0, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.RingTheory.WittVector.Basic | {
"line": 78,
"column": 14
} | {
"line": 78,
"column": 94
} | [
{
"pp": "case h\np : ℕ\nα : Type u_3\nβ : Type u_4\nf : α → β\nhf : Surjective f\nx : 𝕎 β\nn : ℕ\n⊢ (mapFun f (mk p fun n ↦ Classical.choose ⋯)).coeff n = x.coeff n",
"usedConstants": [
"congrArg",
"WittVector.mk",
"Classical.choose_spec",
"Nat",
"True",
"eq_self",
... | simp only [mapFun, coeff_mk, comp_apply, Classical.choose_spec (hf (x.coeff n))] | Lean.Elab.Tactic.evalSimp | Lean.Parser.Tactic.simp |
Mathlib.RingTheory.WittVector.Verschiebung | {
"line": 179,
"column": 6
} | {
"line": 184,
"column": 55
} | [] | _ = ghostComponent (n + 1) (verschiebung <| mk p x) := by
apply eval₂Hom_congr (RingHom.ext_int _ _) _ rfl
funext k
simp only [← aeval_verschiebungPoly]
exact eval₂Hom_congr (RingHom.ext_int _ _) rfl rfl
_ = _ := by rw [ghostComponent_verschiebung]; rfl | Lean.Elab.Tactic._aux_Mathlib_Tactic_Widget_Calc___elabRules_Lean_calcTactic_1 | Lean.calcSteps |
Mathlib.RingTheory.WittVector.Frobenius | {
"line": 233,
"column": 4
} | {
"line": 233,
"column": 58
} | [
{
"pp": "p : ℕ\nR : Type u_1\nhp : Fact (Nat.Prime p)\ninst✝ : CommRing R\n⊢ failed to pretty print expression (use 'set_option pp.rawOnError true' for raw representation)",
"usedConstants": [
"Eq.mpr",
"WittVector.instOne",
"RingHom.instRingHomClass",
"CommRing",
"_private.Mat... | simp only [Function.comp_apply, map_one, forall_const] | Lean.Elab.Tactic.evalSimp | Lean.Parser.Tactic.simp |
Mathlib.RingTheory.Morita.Matrix | {
"line": 93,
"column": 43
} | {
"line": 93,
"column": 70
} | [
{
"pp": "R : Type u\nι : Type v\ninst✝² : Ring R\ninst✝¹ : Fintype ι\ninst✝ : DecidableEq ι\nM : ModuleCat (Matrix ι ι R)\nthis : Module R ↑M := Module.compHom (↑M) (Matrix.scalar ι)\nr : R\nm : Matrix ι ι R\nx : ↑M\n⊢ (r • m) • x = ((Matrix.diagonal fun x ↦ r) * m) • x",
"usedConstants": [
"Eq.mpr",
... | Matrix.smul_eq_diagonal_mul | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.RingTheory.Polynomial.Dickson | {
"line": 148,
"column": 58
} | {
"line": 148,
"column": 78
} | [
{
"pp": "R : Type u_1\ninst✝ : CommRing R\nn : ℕ\n⊢ X * dickson 1 1 (n + 1) - 1 * dickson 1 1 n = Chebyshev.C R (↑n + 2)",
"usedConstants": [
"Eq.mpr",
"Polynomial.instOne",
"HMul.hMul",
"AddMonoid.toAddSemigroup",
"congrArg",
"CommSemiring.toSemiring",
"Nat.instAtL... | Chebyshev.C_add_two, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.RingTheory.Polynomial.Dickson | {
"line": 256,
"column": 12
} | {
"line": 256,
"column": 31
} | [
{
"pp": "p : ℕ\ninst✝ : Fact (Nat.Prime p)\nK : Type\nw✝¹ : Field K\nw✝ : CharP K p\nH : Set.univ.Infinite\nh : {x | ∃ y, x = y + y⁻¹ ∧ y ≠ 0}.Finite\nx : K\nx✝ : x ∈ {x | ∃ y, x = y + y⁻¹ ∧ y ≠ 0}\nφ : K[X] := ⋯\nhφ : φ ≠ 0\ny : K\nhy : ¬y = 0\n⊢ x = y + y⁻¹ ↔ y ^ 2 - x * y + 1 = 0",
"usedConstants": [
... | ← mul_left_inj' hy, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.RingTheory.Polynomial.Eisenstein.Distinguished | {
"line": 45,
"column": 2
} | {
"line": 45,
"column": 32
} | [
{
"pp": "case pos\nR : Type u_1\ninst✝ : CommRing R\nf : R[X]\nI : Ideal R\ndistinguish : f.IsDistinguishedAt I\ni : ℕ\nne : i = f.natDegree\n⊢ (map (Ideal.Quotient.mk I) f).coeff i = (X ^ f.natDegree).coeff i",
"usedConstants": [
"NonAssocSemiring.toAddCommMonoidWithOne",
"RingHom.instRingHomCl... | · simp [ne, distinguish.monic] | Lean.Elab.Tactic.evalTacticCDot | Lean.cdot |
Mathlib.RingTheory.Polynomial.Hermite.Basic | {
"line": 198,
"column": 2
} | {
"line": 198,
"column": 61
} | [
{
"pp": "case neg\nn k : ℕ\nh : ¬Even (n + k)\n⊢ (hermite n).coeff k = 0",
"usedConstants": [
"Odd",
"Nat.not_even_iff_odd",
"instHAdd",
"HAdd.hAdd",
"Nat",
"Even",
"Polynomial.coeff_hermite_of_odd_add",
"Iff.mp",
"instAddNat",
"Nat.instSemiring",
... | · exact coeff_hermite_of_odd_add (Nat.not_even_iff_odd.1 h) | Lean.Elab.Tactic.evalTacticCDot | Lean.cdot |
Mathlib.RingTheory.Polynomial.Opposites | {
"line": 95,
"column": 2
} | {
"line": 96,
"column": 44
} | [
{
"pp": "case neg\nR : Type u_1\ninst✝ : Semiring R\np : R[X]ᵐᵒᵖ\np0 : ¬p = 0\n⊢ ((opRingEquiv R) p).natDegree = (unop p).natDegree",
"usedConstants": [
"Iff.mpr",
"False",
"eq_false",
"Finset.max'.congr_simp",
"congrArg",
"RingEquiv.instEquivLike",
"Finset",
... | · simp only [p0, natDegree_eq_support_max', Ne, EmbeddingLike.map_eq_zero_iff, not_false_iff,
support_opRingEquiv, unop_eq_zero_iff] | Lean.Elab.Tactic.evalTacticCDot | Lean.cdot |
Mathlib.RingTheory.PowerSeries.Expand | {
"line": 40,
"column": 18
} | {
"line": 40,
"column": 34
} | [
{
"pp": "R : Type u_2\ninst✝ : CommRing R\np : ℕ\nhp : p ≠ 0\nr : R\n| (expand p hp) (C r)",
"usedConstants": [
"MulOne.toOne",
"HMul.hMul",
"congrArg",
"CommSemiring.toSemiring",
"AlgHom",
"AlgHom.funLike",
"RingHom",
"Algebra.id",
"MulOne.toMul",
... | ← mul_one (C r), | Lean.Elab.Tactic.Conv.evalRewrite | null |
Mathlib.RingTheory.PolynomialLaw.Basic | {
"line": 385,
"column": 2
} | {
"line": 416,
"column": 19
} | [
{
"pp": "R : Type u\ninst✝⁶ : CommSemiring R\nM : Type u_1\ninst✝⁵ : AddCommMonoid M\ninst✝⁴ : Module R M\nN : Type u_2\ninst✝³ : AddCommMonoid N\ninst✝² : Module R N\nS : Type v\ninst✝¹ : CommSemiring S\ninst✝ : Algebra R S\nf : M →ₚₗ[R] N\n⊢ Function.FactorsThrough (toFunLifted S f) (π R M S)",
"usedConst... | rintro ⟨s, p⟩ ⟨s', p'⟩ h
simp only [toFunLifted]
set u := rTensor M (φ R s).rangeRestrict.toLinearMap p with hu
have uFG : Subalgebra.FG (R := R) (φ R s).range := by
rw [← Algebra.map_top]
exact Subalgebra.FG.map _ Algebra.FiniteType.out
set u' := rTensor M (φ R s').rangeRestrict.toLinearMap p' with hu'... | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.RingTheory.PolynomialLaw.Basic | {
"line": 385,
"column": 2
} | {
"line": 416,
"column": 19
} | [
{
"pp": "R : Type u\ninst✝⁶ : CommSemiring R\nM : Type u_1\ninst✝⁵ : AddCommMonoid M\ninst✝⁴ : Module R M\nN : Type u_2\ninst✝³ : AddCommMonoid N\ninst✝² : Module R N\nS : Type v\ninst✝¹ : CommSemiring S\ninst✝ : Algebra R S\nf : M →ₚₗ[R] N\n⊢ Function.FactorsThrough (toFunLifted S f) (π R M S)",
"usedConst... | rintro ⟨s, p⟩ ⟨s', p'⟩ h
simp only [toFunLifted]
set u := rTensor M (φ R s).rangeRestrict.toLinearMap p with hu
have uFG : Subalgebra.FG (R := R) (φ R s).range := by
rw [← Algebra.map_top]
exact Subalgebra.FG.map _ Algebra.FiniteType.out
set u' := rTensor M (φ R s').rangeRestrict.toLinearMap p' with hu'... | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.RingTheory.Radical.NatInt | {
"line": 41,
"column": 39
} | {
"line": 45,
"column": 30
} | [
{
"pp": "⊢ primeFactors = Nat.primeFactors",
"usedConstants": [
"UniqueFactorizationMonoid.normalizedFactors",
"Multiset.toFinset",
"Eq.mpr",
"instNormalizedGCDMonoidNat",
"NormalizationMonoid.ofUniqueUnits",
"congrArg",
"Nat.unique_units",
"Lean.Meta.instFast... | by
ext n : 1
rw [primeFactors, Nat.factors_eq, Nat.primeFactors]
-- this convert is necessary because of the different DecidableEq instances
convert! List.toFinset_coe _ | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.RingTheory.SimpleModule.Isotypic | {
"line": 119,
"column": 23
} | {
"line": 119,
"column": 77
} | [
{
"pp": "R : Type u_2\nM : Type u\nS : Type u_4\ninst✝⁴ : Ring R\ninst✝³ : AddCommGroup M\ninst✝² : AddCommGroup S\ninst✝¹ : Module R M\ninst✝ : Module R S\nN : Submodule R M\n⊢ IsIsotypicOfType R (↥N) S ↔ ∀ (x : { a // a ≤ N }) [IsSimpleModule R ↥↑x], Nonempty (↥↑x ≃ₗ[R] S)",
"usedConstants": [
"Eq.m... | ← (Submodule.MapSubtype.orderIso N).forall_congr_right | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.RingTheory.SimpleModule.Isotypic | {
"line": 127,
"column": 23
} | {
"line": 127,
"column": 77
} | [
{
"pp": "R : Type u_2\nM : Type u\ninst✝² : Ring R\ninst✝¹ : AddCommGroup M\ninst✝ : Module R M\nN : Submodule R M\n⊢ IsIsotypic R ↥N ↔ ∀ (x : { a // a ≤ N }) [IsSimpleModule R ↥↑x], IsIsotypicOfType R ↥N ↥↑x",
"usedConstants": [
"Eq.mpr",
"Submodule",
"Submodule.MapSubtype.orderIso",
... | ← (Submodule.MapSubtype.orderIso N).forall_congr_right | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.RingTheory.SimpleModule.Isotypic | {
"line": 419,
"column": 74
} | {
"line": 419,
"column": 90
} | [
{
"pp": "R : Type u_2\nM : Type u\ninst✝³ : Ring R\ninst✝² : AddCommGroup M\ninst✝¹ : Module R M\ninst✝ : IsSemisimpleModule R M\nm : Submodule R M\nh : m.IsFullyInvariant\nS : Submodule R M\nle : S ≤ m\nx✝¹ : IsSimpleModule R ↥S\nS' : Submodule R M\nx✝ : S' ∈ {m | Nonempty (↥m ≃ₗ[R] ↥S)}\ne : ↥S' ≃ₗ[R] ↥S\np :... | S'.range_subtype | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.RingTheory.Spectrum.Prime.IsOpenComapC | {
"line": 69,
"column": 2
} | {
"line": 73,
"column": 47
} | [
{
"pp": "R : Type u_1\ninst✝ : CommRing R\n⊢ IsOpenMap (PrimeSpectrum.comap C)",
"usedConstants": [
"Eq.mpr",
"Polynomial.C",
"Set.compl_iInter",
"PrimeSpectrum.zeroLocus",
"compl_compl",
"congrArg",
"CommSemiring.toSemiring",
"Set.iInter",
"Compl.compl"... | rintro U ⟨s, z⟩
rw [← compl_compl U, ← z, ← iUnion_of_singleton_coe s, zeroLocus_iUnion, compl_iInter,
image_iUnion]
simp_rw [← imageOfDf_eq_comap_C_compl_zeroLocus]
exact isOpen_iUnion fun f => isOpen_imageOfDf | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.RingTheory.Spectrum.Prime.IsOpenComapC | {
"line": 69,
"column": 2
} | {
"line": 73,
"column": 47
} | [
{
"pp": "R : Type u_1\ninst✝ : CommRing R\n⊢ IsOpenMap (PrimeSpectrum.comap C)",
"usedConstants": [
"Eq.mpr",
"Polynomial.C",
"Set.compl_iInter",
"PrimeSpectrum.zeroLocus",
"compl_compl",
"congrArg",
"CommSemiring.toSemiring",
"Set.iInter",
"Compl.compl"... | rintro U ⟨s, z⟩
rw [← compl_compl U, ← z, ← iUnion_of_singleton_coe s, zeroLocus_iUnion, compl_iInter,
image_iUnion]
simp_rw [← imageOfDf_eq_comap_C_compl_zeroLocus]
exact isOpen_iUnion fun f => isOpen_imageOfDf | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.RingTheory.WittVector.DiscreteValuationRing | {
"line": 151,
"column": 4
} | {
"line": 153,
"column": 25
} | [
{
"pp": "p : ℕ\nhp : Fact (Nat.Prime p)\nk : Type u_1\ninst✝² : Field k\ninst✝¹ : CharP k p\ninst✝ : PerfectRing k p\n⊢ IsDiscreteValuationRing.HasUnitMulPowIrreducibleFactorization (𝕎 k)",
"usedConstants": [
"Units.val",
"HMul.hMul",
"WittVector.instNatCast",
"Monoid.toMulOneClass"... | refine ⟨p, irreducible p, fun {x} hx => ?_⟩
obtain ⟨n, b, hb⟩ := exists_eq_pow_p_mul' x hx
exact ⟨n, b, hb.symm⟩ | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.RingTheory.WittVector.DiscreteValuationRing | {
"line": 151,
"column": 4
} | {
"line": 153,
"column": 25
} | [
{
"pp": "p : ℕ\nhp : Fact (Nat.Prime p)\nk : Type u_1\ninst✝² : Field k\ninst✝¹ : CharP k p\ninst✝ : PerfectRing k p\n⊢ IsDiscreteValuationRing.HasUnitMulPowIrreducibleFactorization (𝕎 k)",
"usedConstants": [
"Units.val",
"HMul.hMul",
"WittVector.instNatCast",
"Monoid.toMulOneClass"... | refine ⟨p, irreducible p, fun {x} hx => ?_⟩
obtain ⟨n, b, hb⟩ := exists_eq_pow_p_mul' x hx
exact ⟨n, b, hb.symm⟩ | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.RingTheory.WittVector.MulCoeff | {
"line": 143,
"column": 6
} | {
"line": 143,
"column": 19
} | [
{
"pp": "p n : ℕ\nmvpz : ↑p ^ (n + 1) = C (↑p ^ (n + 1))\n⊢ wittPolyProd p (n + 1) =\n -(↑p ^ (n + 1) * X (0, n + 1)) * (↑p ^ (n + 1) * X (1, n + 1)) +\n ↑p ^ (n + 1) * X (0, n + 1) * (rename (Prod.mk 1)) (wittPolynomial p ℤ (n + 1)) +\n ↑p ^ (n + 1) * X (1, n + 1) * (rename (Prod.mk 0)) (wit... | wittPolyProd, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.RingTheory.WittVector.MulCoeff | {
"line": 251,
"column": 2
} | {
"line": 251,
"column": 12
} | [
{
"pp": "case h\np : ℕ\nhp : Fact (Nat.Prime p)\nk : Type u_1\ninst✝¹ : CommRing k\ninst✝ : CharP k p\nn : ℕ\nf₀ : (↑↑(univ ×ˢ range (n + 1)) → k) → k\nhf₀ : ∀ (x : Fin 2 × ℕ → k), f₀ (x ∘ Subtype.val) = (aeval x) (polyOfInterest p n)\nf : TruncatedWittVector p (n + 1) k → TruncatedWittVector p (n + 1) k → k :=... | rw [← hf₀] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.SetTheory.Cardinal.Cofinality.Club | {
"line": 144,
"column": 6
} | {
"line": 145,
"column": 51
} | [
{
"pp": "case inr.refine_2.inr\nα : Type v\ninst✝¹ : LinearOrder α\ninst✝ : WellFoundedLT α\nf : α → α\nhα : cof α ≠ ℵ₀\nhf : IsNormal f\nh✝ : Nonempty α\na : α\nh : NoMaxOrder α\n⊢ BddAbove (Set.range fun n ↦ f^[n] a)",
"usedConstants": [
"Cardinal",
"PartialOrder.toPreorder",
"Preorder.t... | refine .of_not_isCofinal fun h ↦ (cof_le h).not_gt
((aleph0_le_cof.lt_of_ne' hα).trans_le' ?_) | Lean.Elab.Tactic.evalRefine | Lean.Parser.Tactic.refine |
Mathlib.RingTheory.Smooth.Quotient | {
"line": 224,
"column": 55
} | {
"line": 227,
"column": 92
} | [
{
"pp": "R : Type u_1\ninst✝³ : CommRing R\nS : Type u_2\ninst✝² : CommRing S\nR' : Type u_3\nS' : Type u_4\ninst✝¹ : CommRing R'\ninst✝ : CommRing S'\nf : R →+* S\nflat : f.Flat\nqR : R →+* R'\nqS : S →+* S'\ng : R' →+* S'\nsurjR : Function.Surjective ⇑qR\nsurjS : Function.Surjective ⇑qS\ncomm : qS.comp f = g.... | by
algebraize [f, qR, qS, g, qS.comp f]
let _ : IsScalarTower R R' S' := IsScalarTower.of_algebraMap_eq' comm
exact Algebra.FormallySmooth.of_surjective_of_ker_eq_map_of_flat surjR surjS eqmap sq0 ‹_› | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.SetTheory.Descriptive.Tree | {
"line": 32,
"column": 32
} | {
"line": 32,
"column": 53
} | [
{
"pp": "A : Type u_1\nS : Set (Set (List A))\nhS : S ⊆ {T | ∀ ⦃x : List A⦄ ⦃a : A⦄, x ++ [a] ∈ T → x ∈ T}\nx : List A\na : A\nh : x ++ [a] ∈ sInf S\nT : Set (List A)\nhT : T ∈ S\n⊢ x ∈ T",
"usedConstants": []
}
] | exact hS hT <| h T hT | Lean.Elab.Tactic.evalExact | Lean.Parser.Tactic.exact |
Mathlib.SetTheory.Lists | {
"line": 189,
"column": 4
} | {
"line": 189,
"column": 44
} | [
{
"pp": "α : Type u_1\nl₁ l₂ : Lists' α true\nH : ∀ (a : Lists α), a ∈ l₁.toList → a ∈ l₂\n⊢ l₁ ⊆ l₂",
"usedConstants": [
"Lists'.toList",
"Lists'.recOfList",
"Lists",
"Membership.mem",
"Lists'.instMembershipLists",
"HasSubset.Subset",
"Bool.true",
"List",
... | induction l₁ using recOfList with | _ l₁ | _private.Lean.Elab.Tactic.Induction.0.Lean.Elab.Tactic.evalInduction | Lean.Parser.Tactic.induction |
Mathlib.SetTheory.Ordinal.Topology | {
"line": 150,
"column": 2
} | {
"line": 152,
"column": 46
} | [
{
"pp": "s : Set Ordinal.{u}\nhs : ¬BddAbove s\nHs : StrictMono (enumOrd s)\n⊢ IsNormal (enumOrd s) ↔ IsClosed s",
"usedConstants": [
"Iff.mpr",
"Ordinal.instLinearOrder",
"Preorder.toLT",
"StrictMono",
"iSup",
"PartialOrder.toPreorder",
"Preorder.toLE",
"Memb... | refine
⟨fun h => isClosed_iff_iSup.2 fun {ι} hι f hf => ?_, fun h =>
isNormal_iff.2 ⟨Hs, fun a ha o H => ?_⟩⟩ | Lean.Elab.Tactic.evalRefine | Lean.Parser.Tactic.refine |
Mathlib.SetTheory.Ordinal.Veblen | {
"line": 173,
"column": 2
} | {
"line": 174,
"column": 13
} | [
{
"pp": "case inr\nf : Ordinal.{u} → Ordinal.{u}\no a : Ordinal.{u}\nhf : IsNormal f\nhp : 0 < f 0\nH : ∀ (b : Ordinal.{u}), 0 < veblenWith f 0 b\nh : 0 < o\n⊢ 0 < veblenWith f o a",
"usedConstants": [
"Eq.mpr",
"Preorder.toLT",
"Ordinal.partialOrder",
"congrArg",
"PartialOrder... | · rw [← veblenWith_veblenWith_of_lt hf h]
exact H _ | Lean.Elab.Tactic.evalTacticCDot | Lean.cdot |
Mathlib.SetTheory.Ordinal.Notation | {
"line": 336,
"column": 21
} | {
"line": 336,
"column": 41
} | [
{
"pp": "e : ONote\nn : ℕ+\na : ONote\nh : (e.oadd n a).NF\n⊢ ω ^ 1 ∣ (e.oadd n a).repr → e.repr ≠ 0 ∧ ω ^ 1 ∣ a.repr",
"usedConstants": [
"Eq.mpr",
"Dvd.dvd",
"Ordinal.omega0",
"Ordinal.partialOrder",
"congrArg",
"instIsBotZeroClass",
"ONote.oadd",
"AddMonoid... | ← one_le_iff_ne_zero | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.SetTheory.Ordinal.CantorNormalForm | {
"line": 365,
"column": 8
} | {
"line": 365,
"column": 31
} | [
{
"pp": "case single_add\nb : Ordinal.{u_1}\nhb : 1 < b\ne x : Ordinal.{u_1}\nf : Ordinal.{u_1} →₀ Ordinal.{u_1}\nhf' : ∀ c ∈ f.support, c < e\nhx : x ≠ 0\nIH : (∀ (e : Ordinal.{u_1}), f e < b) → coeff b (eval b f) = f\nhf : ∀ (e_1 : Ordinal.{u_1}), (single e x + f) e_1 < b\nIH' : ∀ (e' : Ordinal.{u_1}), f e' <... | eval_single_add' _ hf', | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.SetTheory.ZFC.Basic | {
"line": 441,
"column": 4
} | {
"line": 441,
"column": 70
} | [
{
"pp": "case h\nα β : Type u\nA : α → PSet.{u}\nB : β → PSet.{u}\nαβ : ∀ (a : α), ∃ b, (A a).Equiv (B b)\na : (PSet.mk α A).Type\nc✝ : ((PSet.mk α A).Func a).Type\nb : β\nγ : Type u\nΓ : γ → PSet.{u}\nA_ih✝¹ : ∀ (a_1 : γ), A a = Γ a_1 → ∃ b, ((⋃₀ PSet.mk α A).Func ⟨a, c✝⟩).Equiv ((⋃₀ PSet.mk β B).Func b)\nea :... | change PSet.Equiv ((A a).Func c) ((B b).Func (Eq.ndrec d eb.symm)) | Lean.Elab.Tactic.evalChange | Lean.Parser.Tactic.change |
Mathlib.SetTheory.Ordinal.Notation | {
"line": 450,
"column": 47
} | {
"line": 464,
"column": 14
} | [
{
"pp": "e₁ : ONote\nn₁ : ℕ+\na₁ e₂ : ONote\nn₂ : ℕ+\na₂ : ONote\nb : Ordinal.{0}\nh₁ : (e₁.oadd n₁ a₁).NFBelow b\nh₂ : (e₂.oadd n₂ a₂).NF\n⊢ (e₁.oadd n₁ a₁ - e₂.oadd n₂ a₂).NFBelow b",
"usedConstants": [
"PNat.val",
"Ordering.gt",
"ONote.NF",
"Eq.mpr",
"Preorder.toLT",
"... | by
have h' := sub_nfBelow h₁.snd h₂.snd
simp only [HSub.hSub, Sub.sub, sub] at h' ⊢
have := @cmp_compares _ _ h₁.fst h₂.fst
cases h : cmp e₁ e₂
· apply NFBelow.zero
· rw [Nat.sub_eq]
simp only [h, Ordering.compares_eq] at this
subst e₂
cases (n₁ : ℕ) - n₂
· by_cases en : ... | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.SetTheory.ZFC.Basic | {
"line": 757,
"column": 8
} | {
"line": 757,
"column": 13
} | [
{
"pp": "f : ZFSet.{u} → ZFSet.{u}\ninst✝ : Definable₁ f\nx z : ZFSet.{u}\nzx : z ∈ x\ny : ZFSet.{u}\nyx : (fun w ↦ z.pair w ∈ map f x) y\nw : ZFSet.{u}\nleft✝ : w ∈ x\nwe : w.pair (f w) = z.pair y\nwz : w = z\nfy : f w = y\n⊢ y = f z",
"usedConstants": [
"Eq.mpr",
"congrArg",
"ZFSet",
... | ← fy, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.SetTheory.Ordinal.Notation | {
"line": 636,
"column": 25
} | {
"line": 636,
"column": 54
} | [
{
"pp": "o' : ONote\nm : ℕ\nx✝ : NF 0\np : split' 0 = (o', m)\n⊢ split 0 = (scale 1 o', m)",
"usedConstants": [
"ONote.instZero",
"Prod.mk",
"instOfNatNat",
"ONote.split",
"ONote.instOne",
"Prod.mk.noConfusion",
"Nat",
"ONote.scale",
"eq_of_heq",
"... | injection p; substs o' m; rfl | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.SetTheory.Ordinal.Notation | {
"line": 636,
"column": 25
} | {
"line": 636,
"column": 54
} | [
{
"pp": "o' : ONote\nm : ℕ\nx✝ : NF 0\np : split' 0 = (o', m)\n⊢ split 0 = (scale 1 o', m)",
"usedConstants": [
"ONote.instZero",
"Prod.mk",
"instOfNatNat",
"ONote.split",
"ONote.instOne",
"Prod.mk.noConfusion",
"Nat",
"ONote.scale",
"eq_of_heq",
"... | injection p; substs o' m; rfl | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.SetTheory.ZFC.Rank | {
"line": 217,
"column": 2
} | {
"line": 217,
"column": 64
} | [
{
"pp": "case a\nα : Type u_1\ninst✝ : Small.{u, u_1} α\nf : α → ZFSet.{u}\n⊢ ⨆ i, (f i).rank ≤ (⋃ (i : α), f i).rank",
"usedConstants": [
"Ordinal.iSup_le",
"ZFSet.rank_mono",
"ZFSet.rank",
"ZFSet.iUnion",
"ZFSet.subset_iUnion"
]
}
] | · exact Ordinal.iSup_le fun i => rank_mono (subset_iUnion f i) | Lean.Elab.Tactic.evalTacticCDot | Lean.cdot |
Mathlib.Tactic.Algebra.Lemmas | {
"line": 91,
"column": 2
} | {
"line": 91,
"column": 27
} | [
{
"pp": "n : ℕ\nR : Type u_3\nA : Type u_4\ninst✝³ : CommSemiring R\ninst✝² : CommSemiring A\ninst✝¹ : Algebra R A\ninst✝ : n.AtLeastTwo\na : A\n⊢ OfNat.ofNat n • a = OfNat.ofNat n * a",
"usedConstants": [
"NonAssocSemiring.toAddCommMonoidWithOne",
"instHSMul",
"HMul.hMul",
"CommSemi... | simp_rw [← nat_rawCast_2] | Mathlib.Tactic._aux_Mathlib_Tactic_SimpRw___elabRules_Mathlib_Tactic_tacticSimp_rw____1 | Mathlib.Tactic.tacticSimp_rw___ |
Mathlib.SetTheory.ZFC.Ordinal | {
"line": 292,
"column": 14
} | {
"line": 292,
"column": 26
} | [
{
"pp": "o : Ordinal.{u_1}\nx : PSet.{u_1}\n⊢ (x ∈ PSet.mk o.ToType fun a ↦ (↑a.toOrd).toPSet) ↔ ∃ a < o, x.Equiv a.toPSet",
"usedConstants": [
"Eq.mpr",
"Preorder.toLT",
"Ordinal.ToType.toOrd",
"PSet.instMembership",
"Ordinal.partialOrder",
"congrArg",
"PartialOrde... | PSet.mem_def | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.SetTheory.Ordinal.Notation | {
"line": 836,
"column": 8
} | {
"line": 836,
"column": 63
} | [
{
"pp": "case succ.refine_1.a.hbc.refine_2\na0 a' : ONote\nN0 : a0.NF\nNa' : a'.NF\nm : ℕ\nd : ω ∣ a'.repr\ne0✝ : a0.repr ≠ 0\nh : a'.repr + ↑m < ω ^ a0.repr\nn : ℕ+\nNo : (a0.oadd n a').NF\nk : ℕ\nR' : Ordinal.{0} := (opowAux 0 a0 (a0.oadd n a' * ↑m) (k + 1) m).repr\nR : Ordinal.{0} := (opowAux 0 a0 (a0.oadd n... | exact mul_lt_omega0_opow rr0 this (natCast_lt_omega0 _) | Lean.Elab.Tactic.evalExact | Lean.Parser.Tactic.exact |
Mathlib.SetTheory.Ordinal.Notation | {
"line": 836,
"column": 8
} | {
"line": 836,
"column": 63
} | [
{
"pp": "case succ.refine_1.a.hbc.refine_2\na0 a' : ONote\nN0 : a0.NF\nNa' : a'.NF\nm : ℕ\nd : ω ∣ a'.repr\ne0✝ : a0.repr ≠ 0\nh : a'.repr + ↑m < ω ^ a0.repr\nn : ℕ+\nNo : (a0.oadd n a').NF\nk : ℕ\nR' : Ordinal.{0} := (opowAux 0 a0 (a0.oadd n a' * ↑m) (k + 1) m).repr\nR : Ordinal.{0} := (opowAux 0 a0 (a0.oadd n... | exact mul_lt_omega0_opow rr0 this (natCast_lt_omega0 _) | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.SetTheory.Ordinal.Notation | {
"line": 836,
"column": 8
} | {
"line": 836,
"column": 63
} | [
{
"pp": "case succ.refine_1.a.hbc.refine_2\na0 a' : ONote\nN0 : a0.NF\nNa' : a'.NF\nm : ℕ\nd : ω ∣ a'.repr\ne0✝ : a0.repr ≠ 0\nh : a'.repr + ↑m < ω ^ a0.repr\nn : ℕ+\nNo : (a0.oadd n a').NF\nk : ℕ\nR' : Ordinal.{0} := (opowAux 0 a0 (a0.oadd n a' * ↑m) (k + 1) m).repr\nR : Ordinal.{0} := (opowAux 0 a0 (a0.oadd n... | exact mul_lt_omega0_opow rr0 this (natCast_lt_omega0 _) | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Tactic.ComputeAsymptotics.Multiseries.Defs | {
"line": 361,
"column": 2
} | {
"line": 362,
"column": 19
} | [
{
"pp": "basis_hd : ℝ → ℝ\nbasis_tl : List (ℝ → ℝ)\nms : MultiseriesExpansion (basis_hd :: basis_tl)\ns : Multiseries basis_hd basis_tl\nf : ℝ → ℝ\n⊢ ms = mk s f ↔ ms.seq = s ∧ ms.toFun = f",
"usedConstants": [
"Eq.mpr",
"Real",
"ComputeAsymptotics.MultiseriesExpansion.mk_eq_mk_iff",
... | conv => lhs; lhs; rw [eq_mk ms]
rw [mk_eq_mk_iff] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Tactic.ComputeAsymptotics.Multiseries.Defs | {
"line": 361,
"column": 2
} | {
"line": 362,
"column": 19
} | [
{
"pp": "basis_hd : ℝ → ℝ\nbasis_tl : List (ℝ → ℝ)\nms : MultiseriesExpansion (basis_hd :: basis_tl)\ns : Multiseries basis_hd basis_tl\nf : ℝ → ℝ\n⊢ ms = mk s f ↔ ms.seq = s ∧ ms.toFun = f",
"usedConstants": [
"Eq.mpr",
"Real",
"ComputeAsymptotics.MultiseriesExpansion.mk_eq_mk_iff",
... | conv => lhs; lhs; rw [eq_mk ms]
rw [mk_eq_mk_iff] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Tactic.NormNum.IsSquare | {
"line": 76,
"column": 2
} | {
"line": 82,
"column": 9
} | [
{
"pp": "a : ℚ\nn d : ℕ\nhn : ¬IsSquare n\nhnd : n.Coprime d\nha : IsNNRat a n d\n⊢ ¬IsSquare a",
"usedConstants": [
"Nat.gcd",
"Int.cast",
"Eq.mpr",
"Nat.Coprime",
"NonAssocSemiring.toAddCommMonoidWithOne",
"Int.cast_natCast",
"False",
"Rat.instMul",
"R... | rw [ha.to_eq rfl rfl, Rat.isSquare_iff, ← Int.cast_natCast n, ← Int.cast_natCast d,
Rat.num_div_eq_of_coprime]
· simp [hn]
· contrapose! hnd
have : n ≠ 1 := by rintro rfl; simp at hn
simp_all
· simpa | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Tactic.NormNum.IsSquare | {
"line": 76,
"column": 2
} | {
"line": 82,
"column": 9
} | [
{
"pp": "a : ℚ\nn d : ℕ\nhn : ¬IsSquare n\nhnd : n.Coprime d\nha : IsNNRat a n d\n⊢ ¬IsSquare a",
"usedConstants": [
"Nat.gcd",
"Int.cast",
"Eq.mpr",
"Nat.Coprime",
"NonAssocSemiring.toAddCommMonoidWithOne",
"Int.cast_natCast",
"False",
"Rat.instMul",
"R... | rw [ha.to_eq rfl rfl, Rat.isSquare_iff, ← Int.cast_natCast n, ← Int.cast_natCast d,
Rat.num_div_eq_of_coprime]
· simp [hn]
· contrapose! hnd
have : n ≠ 1 := by rintro rfl; simp at hn
simp_all
· simpa | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Tactic.NormNum.IsSquare | {
"line": 99,
"column": 50
} | {
"line": 99,
"column": 95
} | [
{
"pp": "a : ℚ\nn d : ℕ\nhn : n ≠ 0\nhd : d ≠ 0\nha : IsRat a (Int.negOfNat n) d\nq : ℚ\nhq : -(↑n / ↑d) = q * q\n⊢ 0 < ↑n / ↑d",
"usedConstants": [
"Eq.mpr",
"GroupWithZero.toMonoidWithZero",
"NonAssocSemiring.toAddCommMonoidWithOne",
"Preorder.toLT",
"MulZeroClass.toMul",
... | apply div_pos <;> simpa [Nat.pos_iff_ne_zero] | Lean.Parser.Tactic.«_aux_Init_Tactics___macroRules_Lean_Parser_Tactic_tactic_<;>__1» | Lean.Parser.Tactic.«tactic_<;>_» |
Mathlib.Tactic.NormNum.PowMod | {
"line": 54,
"column": 16
} | {
"line": 54,
"column": 96
} | [
{
"pp": "a b m c : ℕ\nh1 : (a.pow b).mod m = c\n⊢ (a.pow (2 * b)).mod m = (c.mul c).mod m",
"usedConstants": [
"instPowNat",
"Eq.mpr",
"HMul.hMul",
"Monoid.toMulOneClass",
"congrArg",
"Nat.instMonoid",
"two_mul",
"pow_add",
"Nat.mul_mod",
"id",
... | simp only [two_mul, Nat.pow_eq, pow_add, ← h1, Nat.mul_eq]; exact Nat.mul_mod .. | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Tactic.NormNum.PowMod | {
"line": 54,
"column": 16
} | {
"line": 54,
"column": 96
} | [
{
"pp": "a b m c : ℕ\nh1 : (a.pow b).mod m = c\n⊢ (a.pow (2 * b)).mod m = (c.mul c).mod m",
"usedConstants": [
"instPowNat",
"Eq.mpr",
"HMul.hMul",
"Monoid.toMulOneClass",
"congrArg",
"Nat.instMonoid",
"two_mul",
"pow_add",
"Nat.mul_mod",
"id",
... | simp only [two_mul, Nat.pow_eq, pow_add, ← h1, Nat.mul_eq]; exact Nat.mul_mod .. | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Topology.CWComplex.Classical.Subcomplex | {
"line": 57,
"column": 4
} | {
"line": 57,
"column": 36
} | [
{
"pp": "case a\nX : Type u_1\nt : TopologicalSpace X\nC D : Set X\ninst✝¹ : T2Space X\ninst✝ : RelCWComplex C D\nE : Subcomplex C\n⊢ D ∪ ⋃ n, ⋃ j, closedCell n ↑j ⊆ ↑E",
"usedConstants": [
"Membership.mem",
"Set.Elem",
"Topology.RelCWComplex.Subcomplex.I",
"Set.union_subset",
... | apply union_subset E.base_subset | Lean.Elab.Tactic.evalApply | Lean.Parser.Tactic.apply |
Mathlib.Topology.CWComplex.Classical.Subcomplex | {
"line": 103,
"column": 4
} | {
"line": 103,
"column": 17
} | [
{
"pp": "case h\nX : Type u_1\nt : TopologicalSpace X\nC D : Set X\ninst✝¹ : T2Space X\ninst✝ : RelCWComplex C D\nE : Subcomplex C\nn : ℕ\ni : ↑(E.I n)\nJ : (m : ℕ) → Finset (cell C m)\nx : X\nhx : x ∈ ↑(map n ↑i) '' sphere 0 1\nh : x ∉ D\nm : ℕ\nhmn : m < n\nj : cell C m\nhj : j ∈ J m\nhxj : x ∈ openCell m j\n... | by_contra hj' | Batteries.Tactic._aux_Batteries_Tactic_Init___macroRules_Batteries_Tactic_byContra_1 | Batteries.Tactic.byContra |
Mathlib.Topology.Category.Profinite.Nobeling.Span | {
"line": 122,
"column": 2
} | {
"line": 126,
"column": 23
} | [
{
"pp": "I : Type u\nC : Set (I → Bool)\ninst✝ : LinearOrder I\ns : Finset I\nx y : ↑(π C fun x ↦ x ∈ s)\na : I\nha : ↑y a = true\nhx : ↑x a = false\n⊢ 1 - e (π C fun x ↦ x ∈ s) a ∈ factors C s x",
"usedConstants": [
"Profinite.NobelingProof.factors._proof_2",
"Eq.mpr",
"Profinite.Nobeling... | simp only [factors, List.mem_map, Finset.mem_sort]
use a
simp only [hx]
rcases y with ⟨_, z, hz, rfl⟩
aesop (add simp Proj) | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Topology.Category.Profinite.Nobeling.Span | {
"line": 122,
"column": 2
} | {
"line": 126,
"column": 23
} | [
{
"pp": "I : Type u\nC : Set (I → Bool)\ninst✝ : LinearOrder I\ns : Finset I\nx y : ↑(π C fun x ↦ x ∈ s)\na : I\nha : ↑y a = true\nhx : ↑x a = false\n⊢ 1 - e (π C fun x ↦ x ∈ s) a ∈ factors C s x",
"usedConstants": [
"Profinite.NobelingProof.factors._proof_2",
"Eq.mpr",
"Profinite.Nobeling... | simp only [factors, List.mem_map, Finset.mem_sort]
use a
simp only [hx]
rcases y with ⟨_, z, hz, rfl⟩
aesop (add simp Proj) | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Topology.Category.Profinite.Nobeling.Span | {
"line": 135,
"column": 19
} | {
"line": 135,
"column": 36
} | [
{
"pp": "case a.false\nI : Type u\nC : Set (I → Bool)\ninst✝ : LinearOrder I\ns : Finset I\nx y : ↑(π C fun x ↦ x ∈ s)\nh : y ≠ x\na : I\nha : ¬↑y a = false\nhx : ↑x a = false\n⊢ ∃ a ∈ factors C s x, (LocallyConstant.evalMonoidHom y) a = 0",
"usedConstants": [
"LinearOrder.toDecidableEq",
"Bool.... | Bool.not_eq_false | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Topology.Category.Profinite.Nobeling.Span | {
"line": 242,
"column": 2
} | {
"line": 248,
"column": 44
} | [
{
"pp": "I : Type u\nC : Set (I → Bool)\ninst✝¹ : LinearOrder I\ninst✝ : WellFoundedLT I\nhC : IsClosed C\n⊢ ⊤ ≤ Submodule.span ℤ (Set.range (eval C))",
"usedConstants": [
"Int.instAddCommGroup",
"Eq.mpr",
"Int.instAddCommMonoid",
"Submodule",
"RingHomSurjective.ids",
"Pr... | rw [span_iff_products]
intro f _
obtain ⟨K, f', rfl⟩ : ∃ K f', f = πJ C K f' := fin_comap_jointlySurjective C hC f
refine Submodule.span_mono ?_ <| Submodule.apply_mem_span_image_of_mem_span (πJ C K) <|
spanFin C K (Submodule.mem_top : f' ∈ ⊤)
rintro l ⟨y, ⟨m, rfl⟩, rfl⟩
exact ⟨m.val, eval_eq_πJ C K m.val... | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Topology.Category.Profinite.Nobeling.Span | {
"line": 242,
"column": 2
} | {
"line": 248,
"column": 44
} | [
{
"pp": "I : Type u\nC : Set (I → Bool)\ninst✝¹ : LinearOrder I\ninst✝ : WellFoundedLT I\nhC : IsClosed C\n⊢ ⊤ ≤ Submodule.span ℤ (Set.range (eval C))",
"usedConstants": [
"Int.instAddCommGroup",
"Eq.mpr",
"Int.instAddCommMonoid",
"Submodule",
"RingHomSurjective.ids",
"Pr... | rw [span_iff_products]
intro f _
obtain ⟨K, f', rfl⟩ : ∃ K f', f = πJ C K f' := fin_comap_jointlySurjective C hC f
refine Submodule.span_mono ?_ <| Submodule.apply_mem_span_image_of_mem_span (πJ C K) <|
spanFin C K (Submodule.mem_top : f' ∈ ⊤)
rintro l ⟨y, ⟨m, rfl⟩, rfl⟩
exact ⟨m.val, eval_eq_πJ C K m.val... | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Topology.CWComplex.Classical.Basic | {
"line": 695,
"column": 13
} | {
"line": 715,
"column": 84
} | [
{
"pp": "X : Type u_1\nt : TopologicalSpace X\nC✝ D✝ : Set X\ninst✝¹ : T2Space X\nC D : Set X\ninst✝ : RelCWComplex C D\nE : Set X\nI : (n : ℕ) → Set (cell C n)\nclosedCell_subset : ∀ (n : ℕ) (i : ↑(I n)), closedCell n ↑i ⊆ E\nunion : D ∪ ⋃ n, ⋃ j, openCell n ↑j = E\n⊢ IsClosed[t] E",
"usedConstants": [
... | by
have hEC : (E : Set X) ⊆ C := by
simp_rw [← union, ← union_iUnion_openCell_eq_complex (C := C)]
exact union_subset_union_right D
(iUnion_mono fun n ↦ iUnion_subset fun i ↦ subset_iUnion _ (i : cell C n))
apply isClosed_of_disjoint_openCell_or_isClosed_inter_closedCell hEC
· have : D ⊆... | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Topology.CWComplex.Classical.Basic | {
"line": 915,
"column": 47
} | {
"line": 915,
"column": 64
} | [
{
"pp": "X : Type u_1\nt : TopologicalSpace X\nC D : Set X\ninst✝¹ : T2Space X\ninst✝ : RelCWComplex C D\n⊢ D ∪ ⋃ n, ⋃ j, openCell n j ⊆ ⋃ i, ↑(skeletonLT C ↑i)",
"usedConstants": [
"Eq.mpr",
"_private.Mathlib.Topology.CWComplex.Classical.Basic.0.Topology.RelCWComplex.iUnion_skeletonLT_eq_comple... | union_subset_iff, | Mathlib.Tactic._aux_Mathlib_Tactic_SimpRw___elabRules_Mathlib_Tactic_tacticSimp_rw____1 | null |
Mathlib.Topology.CWComplex.Classical.Basic | {
"line": 922,
"column": 47
} | {
"line": 922,
"column": 64
} | [
{
"pp": "X : Type u_1\nt : TopologicalSpace X\nC D : Set X\ninst✝¹ : T2Space X\ninst✝ : RelCWComplex C D\n⊢ D ∪ ⋃ n, ⋃ j, openCell n j ⊆ ⋃ i, ↑(skeleton C ↑i)",
"usedConstants": [
"Eq.mpr",
"ENat.instNatCast",
"Topology.RelCWComplex.openCell",
"Set.instUnion",
"id",
"HasS... | union_subset_iff, | Mathlib.Tactic._aux_Mathlib_Tactic_SimpRw___elabRules_Mathlib_Tactic_tacticSimp_rw____1 | null |
Mathlib.Topology.Category.Profinite.Nobeling.Successor | {
"line": 295,
"column": 93
} | {
"line": 317,
"column": 48
} | [
{
"pp": "I : Type u\nC : Set (I → Bool)\ninst✝¹ : LinearOrder I\ninst✝ : WellFoundedLT I\no : Ordinal.{u}\nhsC : contained C (Order.succ o)\nho : o < Ordinal.type fun x1 x2 ↦ x1 < x2\n⊢ GoodProducts C = GoodProducts (π C fun x ↦ ord I x < o) ∪ MaxProducts C ho",
"usedConstants": [
"Int.instAddCommGrou... | by
ext l
simp only [GoodProducts, MaxProducts, Set.mem_union, Set.mem_setOf_eq]
refine ⟨fun h ↦ ?_, fun h ↦ ?_⟩
· by_cases hh : term I ho ∈ l.val
· exact Or.inr ⟨h, hh⟩
· left
intro he
apply h
have h' := Products.prop_of_isGood_of_contained C _ h hsC
simp only [Order.lt_succ_iff]... | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Topology.Compactness.CompactSystem | {
"line": 55,
"column": 27
} | {
"line": 58,
"column": 15
} | [
{
"pp": "α : Type u_1\nS : Set (Set α)\nhp : IsCompactSystem S\nC : ℕ → Set α\nhC : ∀ (i : ℕ), C i ∈ S\nh_nonempty : ∀ (n : ℕ), (dissipate C n).Nonempty\n⊢ (⋂ i, C i).Nonempty",
"usedConstants": [
"Mathlib.Tactic.Push.not_forall_eq",
"Set.dissipate",
"Eq.mpr",
"congrArg",
"Set.... | by
revert h_nonempty
contrapose!
exact hp C hC | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Topology.Category.Profinite.Nobeling.Successor | {
"line": 566,
"column": 2
} | {
"line": 566,
"column": 23
} | [
{
"pp": "I : Type u\nC : Set (I → Bool)\ninst✝¹ : LinearOrder I\ninst✝ : WellFoundedLT I\no : Ordinal.{u}\nhC : IsClosed C\nhsC : contained C (Order.succ o)\nho : o < Ordinal.type fun x1 x2 ↦ x1 < x2\nl : ↑(MaxProducts C ho)\nh₁ : ⊤ ≤ Submodule.span ℤ (Set.range (eval (π C fun x ↦ ord I x < o)))\nthis : Inhabit... | obtain ⟨w, hc⟩ := hn' | _private.Lean.Elab.Tactic.RCases.0.Lean.Elab.Tactic.RCases.evalObtain | Lean.Parser.Tactic.obtain |
Mathlib.Topology.Compactness.CountablyCompact | {
"line": 145,
"column": 4
} | {
"line": 145,
"column": 29
} | [
{
"pp": "E : Type u_2\ninst✝ : TopologicalSpace E\nA : Set E\nh : ∀ (U : ℕ → Set E), (∀ (i : ℕ), IsOpen[inst✝] (U i)) → A ⊆ ⋃ i, U i → ∃ t, A ⊆ ⋃ i ∈ t, U i\nx : ℕ → E\nhx : ∀ᶠ (n : ℕ) in atTop, x n ∈ A\nV : ℕ → Set E := fun n ↦ (closure[inst✝] (x '' Ici n))ᶜ\nhVmono : Monotone V\nhac : ∀ a ∈ A, ∃ x_1, a ∉ clos... | let m := max N (t.sup id) | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_tacticLet___1 | Lean.Parser.Tactic.tacticLet__ |
Mathlib.Topology.ContinuousMap.SecondCountableSpace | {
"line": 65,
"column": 4
} | {
"line": 65,
"column": 90
} | [
{
"pp": "case a\nX : Type u_1\nY : Type u_2\ninst✝¹ : TopologicalSpace X\ninst✝ : TopologicalSpace Y\nS : Set (Set X)\nT : Set (Set Y)\nhS₁ : ∀ K ∈ S, IsCompact K\nhT : IsTopologicalBasis T\nhS₂ : ∀ (f : C(X, Y)) (x : X), ∀ V ∈ T, f x ∈ V → ∃ K ∈ S, K ∈ 𝓝 x ∧ MapsTo (⇑f) K V\nf : C(X, Y)\nK : Set X\nhK : IsCom... | exact ⟨hst.mono_left (subset_sUnion_of_mem hL), mem_image2_of_mem (hsS hL) ⟨htf, htT⟩⟩ | Lean.Elab.Tactic.evalExact | Lean.Parser.Tactic.exact |
Mathlib.Topology.ContinuousMap.SecondCountableSpace | {
"line": 95,
"column": 4
} | {
"line": 95,
"column": 23
} | [
{
"pp": "case h.refine_2\nX : Type u_1\nY : Type u_2\ninst✝⁴ : TopologicalSpace X\ninst✝³ : TopologicalSpace Y\ninst✝² : SecondCountableTopology X\ninst✝¹ : LocallyCompactSpace X\ninst✝ : SecondCountableTopology Y\nthis : ∀ (U : ↑(countableBasis X)), LocallyCompactSpace ↑↑U\nK : (U : ↑(countableBasis X)) → Comp... | intro f V hVo x hxV | Lean.Elab.Tactic.evalIntro | Lean.Parser.Tactic.intro |
Mathlib.Topology.Homotopy.HSpaces | {
"line": 98,
"column": 4
} | {
"line": 98,
"column": 96
} | [
{
"pp": "X : Type u\nY : Type v\ninst✝³ : TopologicalSpace X\ninst✝² : TopologicalSpace Y\ninst✝¹ : HSpace X\ninst✝ : HSpace Y\n⊢ ({ toFun := fun p ↦ (hmul (p.1.1, p.2.1), hmul (p.1.2, p.2.2)), continuous_toFun := ⋯ }.comp\n ((ContinuousMap.id (X × Y)).prodMk (const (X × Y) (e, e)))).HomotopyRel\n (Co... | let G : I × X × Y → X × Y := fun p => (HSpace.hmulE (p.1, p.2.1), HSpace.hmulE (p.1, p.2.2)) | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_tacticLet___1 | Lean.Parser.Tactic.tacticLet__ |
Mathlib.Topology.Instances.CantorSet | {
"line": 86,
"column": 4
} | {
"line": 86,
"column": 49
} | [
{
"pp": "case succ\nn : ℕ\nih : 0 ∈ preCantorSet n\n⊢ 0 ∈ preCantorSet (n + 1)",
"usedConstants": [
"GroupWithZero.toMonoidWithZero",
"Real",
"instHDiv",
"Real.instZero",
"congrArg",
"preCantorSet._proof_2",
"Real.instDivInvMonoid",
"zero_div",
"Division... | exact Or.inl ⟨0, ih, by simp only [zero_div]⟩ | Lean.Elab.Tactic.evalExact | Lean.Parser.Tactic.exact |
Mathlib.Topology.Instances.CantorSet | {
"line": 86,
"column": 4
} | {
"line": 86,
"column": 49
} | [
{
"pp": "case succ\nn : ℕ\nih : 0 ∈ preCantorSet n\n⊢ 0 ∈ preCantorSet (n + 1)",
"usedConstants": [
"GroupWithZero.toMonoidWithZero",
"Real",
"instHDiv",
"Real.instZero",
"congrArg",
"preCantorSet._proof_2",
"Real.instDivInvMonoid",
"zero_div",
"Division... | exact Or.inl ⟨0, ih, by simp only [zero_div]⟩ | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Topology.Instances.CantorSet | {
"line": 86,
"column": 4
} | {
"line": 86,
"column": 49
} | [
{
"pp": "case succ\nn : ℕ\nih : 0 ∈ preCantorSet n\n⊢ 0 ∈ preCantorSet (n + 1)",
"usedConstants": [
"GroupWithZero.toMonoidWithZero",
"Real",
"instHDiv",
"Real.instZero",
"congrArg",
"preCantorSet._proof_2",
"Real.instDivInvMonoid",
"zero_div",
"Division... | exact Or.inl ⟨0, ih, by simp only [zero_div]⟩ | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Topology.EMetricSpace.PairReduction | {
"line": 259,
"column": 6
} | {
"line": 259,
"column": 83
} | [
{
"pp": "case pos\nT : Type u_1\ninst✝¹ : PseudoEMetricSpace T\na c : ℝ≥0∞\nJ : Finset T\ninst✝ : DecidableEq T\nhJ : J.Nonempty\ni : ℕ\nih : (logSizeBallSeq J hJ a c i).point ∈ J\nh : (logSizeBallSeq J hJ a c (i + 1)).finset.Nonempty\n⊢ (logSizeBallSeq J hJ a c (i + 1)).point ∈ J",
"usedConstants": [
... | refine Finset.mem_of_subset ?_ (point_mem_finset_logSizeBallSeq hJ (i + 1) h) | Lean.Elab.Tactic.evalRefine | Lean.Parser.Tactic.refine |
Mathlib.Topology.Instances.CantorSet | {
"line": 328,
"column": 4
} | {
"line": 328,
"column": 37
} | [
{
"pp": "x : ℝ\nhx : x ∈ cantorSet\n⊢ (ofDigits fun i ↦ bif (cantorToBinary x).get i then 2 else 0) = x",
"usedConstants": [
"ofDigits_cantorToTernary"
]
}
] | exact ofDigits_cantorToTernary hx | Lean.Elab.Tactic.evalExact | Lean.Parser.Tactic.exact |
Mathlib.Topology.IsClosedRestrict | {
"line": 71,
"column": 68
} | {
"line": 73,
"column": 78
} | [
{
"pp": "ι : Type u_1\nα : ι → Type u_2\ns : Set ((i : ι) → α i)\nS : Set ι\np : ↑(Sᶜ.restrict '' s) × ((i : ↑S) → α ↑i)\n⊢ reorderRestrictProd S s p ∈ Sᶜ.restrict ⁻¹' Sᶜ.restrict '' s",
"usedConstants": [
"Compl.compl",
"Membership.mem",
"Set.Elem",
"Topology.reorderRestrictProd",
... | by
obtain ⟨y, hy_mem_s, hy_eq⟩ := p.1.2
exact ⟨y, hy_mem_s, hy_eq.trans (restrict_compl_reorderRestrictProd p).symm⟩ | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Topology.EMetricSpace.PairReduction | {
"line": 432,
"column": 12
} | {
"line": 432,
"column": 24
} | [
{
"pp": "T : Type u_1\ninst✝² : PseudoEMetricSpace T\na c : ℝ≥0∞\nJ : Finset T\ninst✝¹ : DecidableEq T\nE : Type u_2\ninst✝ : PseudoEMetricSpace E\nha : 1 < a\nf : T → E\nhJ : J.Nonempty\ns : T\nhs : s ∈ J\nt : T\nht : t ∈ J\nhst : edist ⟨s, hs⟩ ⟨t, ht⟩ ≤ c\nP : ℕ → Prop := fun l ↦ s ∈ (logSizeBallSeq J hJ a c ... | tsub_le_self | Mathlib.Tactic.evalGRewriteSeq | null |
Mathlib.Topology.List | {
"line": 106,
"column": 4
} | {
"line": 106,
"column": 80
} | [
{
"pp": "α : Type u_1\ninst✝ : TopologicalSpace α\nβ : Type u_3\nf : List α → β\nr : List α → Filter β\nh_nil : Tendsto f (pure []) (r [])\nh_cons : ∀ (l : List α) (a : α), Tendsto f (𝓝 l) (r l) → Tendsto (fun p ↦ f (p.1 :: p.2)) (𝓝 a ×ˢ 𝓝 l) (r (a :: l))\na : α\nl : List α\n⊢ Tendsto f (𝓝 (a :: l)) (r (a :... | rw [tendsto_cons_iff]; exact h_cons l a (@tendsto_nhds _ _ _ h_nil h_cons l) | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.