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.RingTheory.Polynomial.Content | {
"line": 153,
"column": 2
} | {
"line": 154,
"column": 12
} | [
{
"pp": "case mp\nR : Type u_1\ninst✝¹ : CommRing R\ninst✝ : NormalizedGCDMonoid R\np : R[X]\nh : ∀ x ∈ p.support, p.coeff x = 0\n⊢ p = 0",
"usedConstants": [
"False",
"eq_false",
"Classical.not_not._simp_1",
"Polynomial.ext",
"congrArg",
"CommSemiring.toSemiring",
... | · ext n
simp_all | Lean.Elab.Tactic.evalTacticCDot | Lean.cdot |
Mathlib.RingTheory.Polynomial.Content | {
"line": 196,
"column": 2
} | {
"line": 197,
"column": 39
} | [
{
"pp": "case mp\nR : Type u_1\ninst✝¹ : CommRing R\ninst✝ : NormalizedGCDMonoid R\np : R[X]\nr : R\n⊢ r ∣ p.content → ∀ (i : ℕ), r ∣ p.coeff i",
"usedConstants": [
"Dvd.dvd",
"CommRing.toNonUnitalCommRing",
"CommSemiring.toSemiring",
"semigroupDvd",
"SemigroupWithZero.toSemigr... | · intro h i
apply h.trans (content_dvd_coeff _) | Lean.Elab.Tactic.evalTacticCDot | Lean.cdot |
Mathlib.Algebra.Polynomial.Roots | {
"line": 235,
"column": 88
} | {
"line": 236,
"column": 24
} | [
{
"pp": "R : Type u\ninst✝¹ : CommRing R\ninst✝ : IsDomain R\nL : List R[X]\nhd : R[X]\ntl : List R[X]\nih : 0 ∉ tl → tl.prod.roots = (↑tl).bind roots\nH : ¬0 = hd ∧ 0 ∉ tl\n⊢ hd.roots + tl.prod.roots = (↑(hd :: tl)).bind roots",
"usedConstants": [
"Eq.mpr",
"MulOne.toOne",
"Polynomial.roo... | ←
Multiset.cons_coe, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Algebra.Polynomial.FieldDivision | {
"line": 222,
"column": 34
} | {
"line": 222,
"column": 53
} | [
{
"pp": "R : Type u\nS : Type v\nk : Type y\nA : Type z\na b : R\nn : ℕ\ninst✝² : CommRing R\ninst✝¹ : NoZeroDivisors R\ninst✝ : NormalizationMonoid R\nu : R[X]ˣ\nw : Rˣ\nh2 : C ↑w = ↑u\n⊢ C ↑w * C ↑(normUnit ↑w) = ↑1",
"usedConstants": [
"Units.val",
"Eq.mpr",
"Polynomial.C",
"MulOn... | normUnit_coe_units, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Algebra.Polynomial.Roots | {
"line": 371,
"column": 48
} | {
"line": 373,
"column": 55
} | [
{
"pp": "R : Type u\ninst✝¹ : CommRing R\ninst✝ : IsDomain R\nn : ℕ\nh : 0 < n\na x : R\n⊢ x ∈ nthRootsFinset n a ↔ x ^ n = a",
"usedConstants": [
"Multiset.toFinset",
"Eq.mpr",
"congrArg",
"CommSemiring.toSemiring",
"Finset",
"Iff.rfl",
"Classical.propDecidable",
... | by
classical
rw [nthRootsFinset_def, mem_toFinset, mem_nthRoots h] | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Algebra.Polynomial.Roots | {
"line": 452,
"column": 2
} | {
"line": 452,
"column": 46
} | [
{
"pp": "S : Type v\nT : Type w\ninst✝⁵ : CommRing T\ninst✝⁴ : IsDomain T\ninst✝³ : CommRing S\ninst✝² : IsDomain S\ninst✝¹ : Algebra T S\ninst✝ : Module.IsTorsionFree T S\np : T[X]\na : S\n⊢ a ∈ p.aroots S ↔ p ≠ 0 ∧ (aeval a) p = 0",
"usedConstants": [
"Polynomial.mem_aroots'",
"Eq.mpr",
... | rw [mem_aroots', Polynomial.map_ne_zero_iff] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.RingTheory.Polynomial.UniqueFactorization | {
"line": 144,
"column": 8
} | {
"line": 144,
"column": 37
} | [
{
"pp": "σ : Type v\nD : Type u\ninst✝¹ : CommRing D\ninst✝ : UniqueFactorizationMonoid D\nd : ℕ\ns : Finset σ\na' : MvPolynomial (↥s) D\nha : (rename Subtype.val) a' ≠ 0\nw : Multiset (MvPolynomial (↥s) D)\nh : ∀ b ∈ w, Prime b\nu : (MvPolynomial (↥s) D)ˣ\nhw : w.prod * ↑u = a'\n⊢ (rename Subtype.val) w.prod *... | AlgHom.toRingHom_toMonoidHom, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.RingTheory.Algebraic.Basic | {
"line": 62,
"column": 9
} | {
"line": 62,
"column": 41
} | [
{
"pp": "R : Type u\nA : Type v\ninst✝² : CommRing R\ninst✝¹ : Ring A\ninst✝ : Algebra R A\nr : A\nf : R[X]\nhf : f.natDegree ≠ 0\nhf' : f.leadingCoeff ∈ R⁰\np : R[X]\nh1 : p ≠ 0\nh2 : (aeval ((aeval r) f)) p = 0\nh : (p.comp f).coeff (p.natDegree * f.natDegree) = 0\n⊢ p = 0",
"usedConstants": [
"NonU... | coeff_comp_degree_mul_degree hf, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.RingTheory.Algebraic.Basic | {
"line": 409,
"column": 30
} | {
"line": 409,
"column": 62
} | [
{
"pp": "R : Type u_3\nS : Type u_4\nA : Type u_5\ninst✝⁶ : CommRing R\ninst✝⁵ : CommRing S\ninst✝⁴ : Ring A\ninst✝³ : Algebra R S\ninst✝² : Algebra S A\ninst✝¹ : Algebra R A\ninst✝ : IsScalarTower R S A\nhinj : Function.Injective ⇑(algebraMap R S)\nx : A\nA_alg : IsAlgebraic R x\np : R[X]\nhp₁ : p ≠ 0\nhp₂ : (... | degree_map_eq_of_injective hinj, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Data.Real.Basic | {
"line": 362,
"column": 4
} | {
"line": 362,
"column": 31
} | [
{
"pp": "x : ℝ\n⊢ ∀ (a b : ℝ), a ≤ b → ∀ (c : ℝ), a + c ≤ b + c",
"usedConstants": [
"Eq.mpr",
"Real.partialOrder",
"Real",
"Preorder.toLT",
"_private.Mathlib.Data.Real.Basic.0.Real.instIsOrderedAddMonoid._simp_1",
"PartialOrder.toPreorder",
"Preorder.toLE",
"... | simp only [le_iff_eq_or_lt] | Lean.Elab.Tactic.evalSimp | Lean.Parser.Tactic.simp |
Mathlib.Data.Real.Basic | {
"line": 512,
"column": 8
} | {
"line": 512,
"column": 29
} | [
{
"pp": "x : ℝ\nq : ℚ≥0\n⊢ ↑q = ↑q.num / ↑q.den",
"usedConstants": [
"Semiring.toNatCast",
"Real.instNNRatCast",
"Eq.mpr",
"Real",
"instHDiv",
"CauSeq.Completion.instNNRatCast",
"abs",
"congrArg",
"Real.instDivInvMonoid",
"IsAbsoluteValue.abs_isAbs... | ← ofCauchy_nnratCast, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Algebra.Order.CauSeq.Basic | {
"line": 432,
"column": 9
} | {
"line": 432,
"column": 29
} | [
{
"pp": "α : Type u_1\nβ : Type u_2\ninst✝⁴ : Field α\ninst✝³ : LinearOrder α\ninst✝² : IsStrictOrderedRing α\ninst✝¹ : Ring β\nabv : β → α\ninst✝ : IsAbsoluteValue abv\nf g : CauSeq β abv\nh : f ≈ g\nε : α\nε0 : 0 < ε\nx✝ : ℕ\nH : ∀ j ≥ x✝, abv (↑(f - g) j) < ε / 2 ∧ ∀ k ≥ j, abv (↑f k - ↑f j) < ε / 2\nj : ℕ\n... | sub_add_sub_cancel', | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Data.Real.Archimedean | {
"line": 331,
"column": 4
} | {
"line": 331,
"column": 78
} | [
{
"pp": "case refine_1\nf : CauSeq ℝ abs\ns : Set ℝ := {x | const abs x < f}\nlb : ∃ x, x ∈ s\nub' : ∀ (x : ℝ), f < const abs x → ∀ y ∈ s, y ≤ x\nub : ∃ x, ∀ y ∈ s, y ≤ x\nε : ℝ\nε0 : ε > 0\ni : ℕ\nih : ∀ j ≥ i, ε ≤ ↑(const abs (sSup s) - f) j\nj : ℕ\nij : j ≥ i\n⊢ ε / 2 ≤ ↑(const abs (sSup s - ε / 2) - f) j",
... | rw [sub_apply, const_apply, sub_right_comm, le_sub_iff_add_le, add_halves] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.Data.NNReal.Defs | {
"line": 701,
"column": 26
} | {
"line": 703,
"column": 74
} | [
{
"pp": "a b : ℝ≥0\nha : 0 < a\nhb : b < 1\n⊢ ∃ n, b ^ n < a",
"usedConstants": [
"Iff.mpr",
"Real",
"Preorder.toLT",
"Real.instArchimedean",
"Real.instZero",
"congrArg",
"NNReal.coe_lt_coe._simp_1",
"PartialOrder.toPreorder",
"Real.instLT",
"Preor... | by
simpa only [← coe_pow, NNReal.coe_lt_coe] using
exists_pow_lt_of_lt_one (NNReal.coe_pos.2 ha) (NNReal.coe_lt_coe.2 hb) | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Algebra.Order.Group.Pointwise.CompleteLattice | {
"line": 96,
"column": 2
} | {
"line": 97,
"column": 42
} | [
{
"pp": "M : Type u_1\ninst✝³ : CompleteLattice M\ninst✝² : Group M\ninst✝¹ : MulLeftMono M\ninst✝ : MulRightMono M\ns : Set M\n⊢ sSup s⁻¹ = (sInf s)⁻¹",
"usedConstants": [
"Eq.mpr",
"iInf",
"DivInvOneMonoid.toInvOneClass",
"congrArg",
"iSup",
"OrderIso.inv",
"Invol... | rw [← image_inv_eq_inv, sSup_image]
exact ((OrderIso.inv M).map_sInf _).symm | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Algebra.Order.Group.Pointwise.CompleteLattice | {
"line": 96,
"column": 2
} | {
"line": 97,
"column": 42
} | [
{
"pp": "M : Type u_1\ninst✝³ : CompleteLattice M\ninst✝² : Group M\ninst✝¹ : MulLeftMono M\ninst✝ : MulRightMono M\ns : Set M\n⊢ sSup s⁻¹ = (sInf s)⁻¹",
"usedConstants": [
"Eq.mpr",
"iInf",
"DivInvOneMonoid.toInvOneClass",
"congrArg",
"iSup",
"OrderIso.inv",
"Invol... | rw [← image_inv_eq_inv, sSup_image]
exact ((OrderIso.inv M).map_sInf _).symm | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Data.Real.Archimedean | {
"line": 407,
"column": 40
} | {
"line": 411,
"column": 28
} | [
{
"pp": "b : ℝ\nhb : 0 < b\n⊢ ∃ n, 0 < n ∧ (↑n)⁻¹ < b",
"usedConstants": [
"Real.instIsOrderedRing",
"Eq.mpr",
"GroupWithZero.toMonoidWithZero",
"NonAssocSemiring.toAddCommMonoidWithOne",
"Real.partialOrder",
"Real",
"Preorder.toLT",
"NonUnitalCommRing.toNonUn... | by
refine (exists_nat_gt b⁻¹).imp fun k hk ↦ ?_
have := (inv_pos_of_pos hb).trans hk
refine ⟨Nat.cast_pos.mp this, ?_⟩
rwa [inv_lt_comm₀ this hb] | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Algebra.Order.CauSeq.Basic | {
"line": 806,
"column": 2
} | {
"line": 814,
"column": 24
} | [
{
"pp": "α : Type u_1\ninst✝² : Field α\ninst✝¹ : LinearOrder α\ninst✝ : IsStrictOrderedRing α\na b : CauSeq α abs\nh : b ≤ a\n⊢ a ⊓ b ≈ b",
"usedConstants": [
"AddGroup.toSubtractionMonoid",
"CauSeq.instLTAbs._proof_1",
"Eq.mpr",
"CauSeq.instLTAbs",
"Preorder.toLT",
"Non... | obtain ⟨ε, ε0 : _ < _, i, h⟩ | h := h
· intro _ _
refine ⟨i, fun j hj => ?_⟩
dsimp
rw [← min_sub_sub_right]
rwa [sub_self, min_eq_right, abs_zero]
exact ε0.le.trans (h _ hj)
· refine Setoid.trans (inf_equiv_inf (Setoid.symm h) (Setoid.refl _)) ?_
rw [CauSeq.inf_idem] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Algebra.Order.CauSeq.Basic | {
"line": 806,
"column": 2
} | {
"line": 814,
"column": 24
} | [
{
"pp": "α : Type u_1\ninst✝² : Field α\ninst✝¹ : LinearOrder α\ninst✝ : IsStrictOrderedRing α\na b : CauSeq α abs\nh : b ≤ a\n⊢ a ⊓ b ≈ b",
"usedConstants": [
"AddGroup.toSubtractionMonoid",
"CauSeq.instLTAbs._proof_1",
"Eq.mpr",
"CauSeq.instLTAbs",
"Preorder.toLT",
"Non... | obtain ⟨ε, ε0 : _ < _, i, h⟩ | h := h
· intro _ _
refine ⟨i, fun j hj => ?_⟩
dsimp
rw [← min_sub_sub_right]
rwa [sub_self, min_eq_right, abs_zero]
exact ε0.le.trans (h _ hj)
· refine Setoid.trans (inf_equiv_inf (Setoid.symm h) (Setoid.refl _)) ?_
rw [CauSeq.inf_idem] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Data.ENNReal.Operations | {
"line": 511,
"column": 76
} | {
"line": 511,
"column": 90
} | [
{
"pp": "x y : ℝ≥0\n⊢ ofNNReal '' uIoo x y = uIoo ↑x ↑y",
"usedConstants": [
"ENNReal.ofNNReal",
"Lattice.toSemilatticeSup",
"congrArg",
"PartialOrder.toPreorder",
"SemilatticeInf.toPartialOrder",
"SemilatticeSup.toMax",
"DistribLattice.toLattice",
"NNReal",
... | by simp [uIoo] | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Data.ENNReal.Operations | {
"line": 651,
"column": 46
} | {
"line": 651,
"column": 61
} | [
{
"pp": "ι : Sort u_1\na : ℝ≥0∞\ninst✝ : Nonempty ι\nf : ι → ℝ≥0∞\nha : a ≠ ∞\ni : ι\n⊢ a + f i ≤ a + ⨆ i, f i",
"usedConstants": [
"le_refl",
"ENNReal.instAddCommMonoid",
"CommSemiring.toSemiring",
"iSup",
"CompletelyDistribLattice.toCompleteLattice",
"PartialOrder.toPre... | grw [← le_iSup] | Mathlib.Tactic._aux_Mathlib_Tactic_GRewrite_Elab___macroRules_Mathlib_Tactic_grwSeq_1 | Mathlib.Tactic.grwSeq |
Mathlib.Data.ENNReal.Operations | {
"line": 651,
"column": 46
} | {
"line": 651,
"column": 61
} | [
{
"pp": "ι : Sort u_1\na : ℝ≥0∞\ninst✝ : Nonempty ι\nf : ι → ℝ≥0∞\nha : a ≠ ∞\ni : ι\n⊢ a + f i ≤ a + ⨆ i, f i",
"usedConstants": [
"le_refl",
"ENNReal.instAddCommMonoid",
"CommSemiring.toSemiring",
"iSup",
"CompletelyDistribLattice.toCompleteLattice",
"PartialOrder.toPre... | grw [← le_iSup] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Data.ENNReal.Operations | {
"line": 651,
"column": 46
} | {
"line": 651,
"column": 61
} | [
{
"pp": "ι : Sort u_1\na : ℝ≥0∞\ninst✝ : Nonempty ι\nf : ι → ℝ≥0∞\nha : a ≠ ∞\ni : ι\n⊢ a + f i ≤ a + ⨆ i, f i",
"usedConstants": [
"le_refl",
"ENNReal.instAddCommMonoid",
"CommSemiring.toSemiring",
"iSup",
"CompletelyDistribLattice.toCompleteLattice",
"PartialOrder.toPre... | grw [← le_iSup] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Data.Sign.Defs | {
"line": 310,
"column": 49
} | {
"line": 315,
"column": 43
} | [
{
"pp": "α : Type u_1\ninst✝¹ : Zero α\ninst✝ : LinearOrder α\na : α\n⊢ sign a = 0 ↔ a = 0",
"usedConstants": [
"SignType.ctorIdx",
"False",
"Preorder.toLT",
"SignType.instOne",
"congrArg",
"HEq.refl",
"False.elim",
"PartialOrder.toPreorder",
"SignType.i... | by
refine ⟨fun h => ?_, fun h => h.symm ▸ sign_zero⟩
rw [sign_apply] at h
split_ifs at h with h_1 h_2
cases h
exact (le_of_not_gt h_1).eq_of_not_lt h_2 | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Data.EReal.Basic | {
"line": 197,
"column": 29
} | {
"line": 197,
"column": 44
} | [
{
"pp": "x : EReal\n⊢ x * 1 = x",
"usedConstants": [
"Eq.mpr",
"HMul.hMul",
"congrArg",
"EReal",
"id",
"EReal.mul_comm",
"One.toOfNat1",
"OfNat.ofNat",
"Eq",
"instOneEReal",
"EReal.instMul",
"instHMul"
]
}
] | EReal.mul_comm, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Data.EReal.Basic | {
"line": 199,
"column": 30
} | {
"line": 199,
"column": 45
} | [
{
"pp": "x : EReal\n⊢ x * 0 = 0",
"usedConstants": [
"Eq.mpr",
"HMul.hMul",
"congrArg",
"EReal",
"id",
"instZeroEReal",
"EReal.mul_comm",
"Zero.toOfNat0",
"OfNat.ofNat",
"Eq",
"EReal.instMul",
"instHMul"
]
}
] | EReal.mul_comm, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Data.Nat.Cast.Order.Field | {
"line": 36,
"column": 29
} | {
"line": 36,
"column": 42
} | [
{
"pp": "case zero\nα : Type u_1\ninst✝² : Semifield α\ninst✝¹ : LinearOrder α\ninst✝ : IsStrictOrderedRing α\nm : ℕ\n⊢ ↑(m / 0) ≤ 0",
"usedConstants": [
"Eq.mpr",
"GroupWithZero.toMonoidWithZero",
"NonAssocSemiring.toAddCommMonoidWithOne",
"instHDiv",
"congrArg",
"Partia... | Nat.div_zero, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Data.EReal.Basic | {
"line": 676,
"column": 39
} | {
"line": 676,
"column": 54
} | [
{
"pp": "x : ℝ≥0\n⊢ ⊤ * ↑↑x = ↑↑x * ↑∞",
"usedConstants": [
"Eq.mpr",
"ENNReal.ofNNReal",
"HMul.hMul",
"congrArg",
"EReal",
"instTopEReal",
"id",
"ENNReal.toEReal",
"EReal.mul_comm",
"ENNReal",
"instTopENNReal",
"Top.top",
"Eq",
... | EReal.mul_comm, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Data.ENNReal.Inv | {
"line": 266,
"column": 2
} | {
"line": 267,
"column": 43
} | [
{
"pp": "c a b : ℝ≥0∞\nhc : c ≠ 0\nhc' : c ≠ ∞\n⊢ a * c / (b * c) = a / b",
"usedConstants": [
"Eq.mpr",
"MulOne.toOne",
"DivInvMonoid.toInv",
"instHDiv",
"HMul.hMul",
"mul_mul_mul_comm",
"Monoid.toMulOneClass",
"CommSemiring.toNonUnitalCommSemiring",
"c... | rw [div_eq_mul_inv, div_eq_mul_inv, ENNReal.mul_inv (Or.inr hc') (Or.inr hc), mul_mul_mul_comm,
ENNReal.mul_inv_cancel hc hc', mul_one] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.Data.ENNReal.Inv | {
"line": 266,
"column": 2
} | {
"line": 267,
"column": 43
} | [
{
"pp": "c a b : ℝ≥0∞\nhc : c ≠ 0\nhc' : c ≠ ∞\n⊢ a * c / (b * c) = a / b",
"usedConstants": [
"Eq.mpr",
"MulOne.toOne",
"DivInvMonoid.toInv",
"instHDiv",
"HMul.hMul",
"mul_mul_mul_comm",
"Monoid.toMulOneClass",
"CommSemiring.toNonUnitalCommSemiring",
"c... | rw [div_eq_mul_inv, div_eq_mul_inv, ENNReal.mul_inv (Or.inr hc') (Or.inr hc), mul_mul_mul_comm,
ENNReal.mul_inv_cancel hc hc', mul_one] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Data.ENNReal.Inv | {
"line": 266,
"column": 2
} | {
"line": 267,
"column": 43
} | [
{
"pp": "c a b : ℝ≥0∞\nhc : c ≠ 0\nhc' : c ≠ ∞\n⊢ a * c / (b * c) = a / b",
"usedConstants": [
"Eq.mpr",
"MulOne.toOne",
"DivInvMonoid.toInv",
"instHDiv",
"HMul.hMul",
"mul_mul_mul_comm",
"Monoid.toMulOneClass",
"CommSemiring.toNonUnitalCommSemiring",
"c... | rw [div_eq_mul_inv, div_eq_mul_inv, ENNReal.mul_inv (Or.inr hc') (Or.inr hc), mul_mul_mul_comm,
ENNReal.mul_inv_cancel hc hc', mul_one] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Data.ENNReal.Inv | {
"line": 293,
"column": 49
} | {
"line": 294,
"column": 54
} | [
{
"pp": "a b : ℝ≥0∞\n⊢ a < b⁻¹ ↔ b < a⁻¹",
"usedConstants": [
"Preorder.toLT",
"congrArg",
"PartialOrder.toPreorder",
"Eq.mp",
"Iff",
"Inv.inv",
"ENNReal.instInvolutiveInv",
"inv_inv",
"LT.lt",
"ENNReal",
"ENNReal.instPartialOrder",
"EN... | by
simpa only [inv_inv] using @ENNReal.inv_lt_inv a⁻¹ b | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Data.ENNReal.Inv | {
"line": 650,
"column": 4
} | {
"line": 650,
"column": 54
} | [
{
"pp": "a b : ℝ≥0∞\nha : a ≠ 0\nhb : b ≠ ∞\nn : ℕ\nhn : b / a < ↑n\n⊢ b < ↑n * a",
"usedConstants": [
"Eq.mpr",
"Preorder.toLT",
"instHDiv",
"HMul.hMul",
"congrArg",
"CommSemiring.toSemiring",
"PartialOrder.toPreorder",
"instAddCommMonoidWithOneENNReal",
... | rwa [← ENNReal.div_lt_iff (Or.inl ha) (Or.inr hb)] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_tacticRwa___1 | Lean.Parser.Tactic.tacticRwa__ |
Mathlib.Data.ENNReal.Inv | {
"line": 650,
"column": 4
} | {
"line": 650,
"column": 54
} | [
{
"pp": "a b : ℝ≥0∞\nha : a ≠ 0\nhb : b ≠ ∞\nn : ℕ\nhn : b / a < ↑n\n⊢ b < ↑n * a",
"usedConstants": [
"Eq.mpr",
"Preorder.toLT",
"instHDiv",
"HMul.hMul",
"congrArg",
"CommSemiring.toSemiring",
"PartialOrder.toPreorder",
"instAddCommMonoidWithOneENNReal",
... | rwa [← ENNReal.div_lt_iff (Or.inl ha) (Or.inr hb)] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Data.ENNReal.Inv | {
"line": 650,
"column": 4
} | {
"line": 650,
"column": 54
} | [
{
"pp": "a b : ℝ≥0∞\nha : a ≠ 0\nhb : b ≠ ∞\nn : ℕ\nhn : b / a < ↑n\n⊢ b < ↑n * a",
"usedConstants": [
"Eq.mpr",
"Preorder.toLT",
"instHDiv",
"HMul.hMul",
"congrArg",
"CommSemiring.toSemiring",
"PartialOrder.toPreorder",
"instAddCommMonoidWithOneENNReal",
... | rwa [← ENNReal.div_lt_iff (Or.inl ha) (Or.inr hb)] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Data.EReal.Inv | {
"line": 103,
"column": 67
} | {
"line": 111,
"column": 62
} | [
{
"pp": "x y : EReal\n⊢ sign (x * y) = sign x * sign y",
"usedConstants": [
"CommMonoidWithZero.toCommMonoid",
"Iff.mpr",
"Eq.mpr",
"GroupWithZero.toMonoidWithZero",
"MulOne.toOne",
"Real",
"SignType.instHasDistribNeg",
"Preorder.toLT",
"HMul.hMul",
... | by
induction x, y using induction₂_symm_neg with
| top_zero => simp only [mul_zero, sign_zero]
| top_top => rfl
| symm h => rwa [mul_comm, EReal.mul_comm]
| coe_coe => simp only [← coe_mul, sign_coe, _root_.sign_mul]
| top_pos _ h =>
rw [top_mul_coe_of_pos h, sign_top, one_mul, sign_pos (EReal.coe_pos.2... | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Data.EReal.Inv | {
"line": 119,
"column": 6
} | {
"line": 119,
"column": 21
} | [
{
"pp": "x : EReal\n⊢ ↑x.abs * ↑(sign x) = x",
"usedConstants": [
"SignType.cast",
"Eq.mpr",
"EReal.abs",
"HMul.hMul",
"congrArg",
"PartialOrder.toPreorder",
"SignType.instLinearOrder",
"EReal.instNeg",
"EReal",
"SemilatticeInf.toPartialOrder",
... | EReal.mul_comm, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Data.ENNReal.Inv | {
"line": 746,
"column": 4
} | {
"line": 746,
"column": 71
} | [
{
"pp": "x : ℝ≥0∞\nhx : 1 ≤ x\na b : ℕ\nh : Int.ofNat a ≤ Int.negSucc b\n⊢ Int.negSucc b < Int.ofNat a",
"usedConstants": [
"PartialOrder.toPreorder",
"SemilatticeInf.toPartialOrder",
"Int.negSucc_lt_zero",
"Int.ofNat",
"Int",
"instOfNat",
"instLatticeInt",
"I... | exact lt_of_lt_of_le (Int.negSucc_lt_zero _) (Int.natCast_nonneg _) | Lean.Elab.Tactic.evalExact | Lean.Parser.Tactic.exact |
Mathlib.Data.EReal.Operations | {
"line": 577,
"column": 6
} | {
"line": 577,
"column": 21
} | [
{
"pp": "x : ℝ≥0∞\nhx : x ≠ 0\n⊢ ↑x * ⊤ = ⊤",
"usedConstants": [
"Eq.mpr",
"HMul.hMul",
"congrArg",
"EReal",
"instTopEReal",
"id",
"ENNReal.toEReal",
"EReal.mul_comm",
"Top.top",
"Eq",
"EReal.instMul",
"instHMul"
]
}
] | EReal.mul_comm, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Data.EReal.Inv | {
"line": 255,
"column": 6
} | {
"line": 258,
"column": 28
} | [
{
"pp": "case coe.inr.inr\na : ℝ\na_pos : 0 < a\n⊢ ↑(sign ↑a) * (↑(↑a).abs)⁻¹ = (↑a)⁻¹",
"usedConstants": [
"AddGroup.toSubtractionMonoid",
"SignType.cast",
"Eq.mpr",
"EReal.abs",
"MulOne.toOne",
"SignType.coe_one",
"Real",
"Inv",
"HMul.hMul",
"ERe... | rw [sign_coe, _root_.sign_pos a_pos, SignType.coe_one, one_mul]
simp only [abs_def a, coe_ennreal_ofReal, abs_nonneg, max_eq_left]
congr
exact abs_of_pos a_pos | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Data.EReal.Inv | {
"line": 255,
"column": 6
} | {
"line": 258,
"column": 28
} | [
{
"pp": "case coe.inr.inr\na : ℝ\na_pos : 0 < a\n⊢ ↑(sign ↑a) * (↑(↑a).abs)⁻¹ = (↑a)⁻¹",
"usedConstants": [
"AddGroup.toSubtractionMonoid",
"SignType.cast",
"Eq.mpr",
"EReal.abs",
"MulOne.toOne",
"SignType.coe_one",
"Real",
"Inv",
"HMul.hMul",
"ERe... | rw [sign_coe, _root_.sign_pos a_pos, SignType.coe_one, one_mul]
simp only [abs_def a, coe_ennreal_ofReal, abs_nonneg, max_eq_left]
congr
exact abs_of_pos a_pos | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Data.EReal.Operations | {
"line": 746,
"column": 53
} | {
"line": 746,
"column": 68
} | [
{
"pp": "a b : EReal\n⊢ -a = ⊥ ∧ b < 0 ∨ -a < 0 ∧ b = ⊥ ∨ -a = ⊤ ∧ 0 < b ∨ 0 < -a ∧ b = ⊤ ↔\n a = ⊥ ∧ 0 < b ∨ 0 < a ∧ b = ⊥ ∨ a = ⊤ ∧ b < 0 ∨ a < 0 ∧ b = ⊤",
"usedConstants": [
"Eq.mpr",
"Preorder.toLT",
"congrArg",
"PartialOrder.toPreorder",
"EReal.instNeg",
"EReal",
... | neg_eq_bot_iff, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Data.EReal.Operations | {
"line": 775,
"column": 6
} | {
"line": 775,
"column": 21
} | [
{
"pp": "x y : EReal\nhy : 0 ≤ y\n⊢ (x * y).toENNReal = x.toENNReal * y.toENNReal",
"usedConstants": [
"Eq.mpr",
"HMul.hMul",
"congrArg",
"CommSemiring.toSemiring",
"EReal.toENNReal",
"EReal",
"id",
"ENNReal.instCommSemiring",
"Distrib.toMul",
"ERe... | EReal.mul_comm, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Order.Filter.Bases.Finite | {
"line": 51,
"column": 2
} | {
"line": 51,
"column": 94
} | [
{
"pp": "α : Type u_1\ns : Set (Set α)\n⊢ generate s = generate (sInter '' {t | t.Finite ∧ t ⊆ s})",
"usedConstants": [
"Eq.mpr",
"congrArg",
"setOf",
"Set.Finite",
"id",
"Filter.IsBasis.filter",
"HasSubset.Subset",
"Filter.HasBasis.isBasis",
"FilterBasi... | rw [← FilterBasis.ofSets_sets, FilterBasis.generate, ← (hasBasis_generate s).filter_eq]; rfl | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Order.Filter.Bases.Finite | {
"line": 51,
"column": 2
} | {
"line": 51,
"column": 94
} | [
{
"pp": "α : Type u_1\ns : Set (Set α)\n⊢ generate s = generate (sInter '' {t | t.Finite ∧ t ⊆ s})",
"usedConstants": [
"Eq.mpr",
"congrArg",
"setOf",
"Set.Finite",
"id",
"Filter.IsBasis.filter",
"HasSubset.Subset",
"Filter.HasBasis.isBasis",
"FilterBasi... | rw [← FilterBasis.ofSets_sets, FilterBasis.generate, ← (hasBasis_generate s).filter_eq]; rfl | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Order.Filter.Finite | {
"line": 305,
"column": 2
} | {
"line": 305,
"column": 43
} | [
{
"pp": "α : Type u\nl : Filter α\nι : Type u_2\ns : Set ι\nhs : s.Finite\nf g : ι → Set α\nhle : ∀ i ∈ s, f i ≤ᶠ[l] g i\nthis : Finite ↑s\n⊢ ⋃ i ∈ s, f i ≤ᶠ[l] ⋃ i ∈ s, g i",
"usedConstants": [
"Eq.mpr",
"congrArg",
"Prop.le",
"Membership.mem",
"Set.Elem",
"id",
"S... | rw [biUnion_eq_iUnion, biUnion_eq_iUnion] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.Order.Filter.AtTopBot.Prod | {
"line": 84,
"column": 2
} | {
"line": 84,
"column": 33
} | [
{
"pp": "α : Type u_3\nγ : Type u_5\ninst✝¹ : Preorder α\ninst✝ : Preorder γ\nf g : α → γ\nhf : Tendsto f atTop atTop\nhg : Tendsto g atTop atTop\n⊢ Tendsto (Prod.map f g) (atTop ×ˢ atTop) atTop",
"usedConstants": [
"Filter.Tendsto.prod_map_prod_atTop",
"Filter.atTop"
]
}
] | exact hf.prod_map_prod_atTop hg | Lean.Elab.Tactic.evalExact | Lean.Parser.Tactic.exact |
Mathlib.Order.Filter.AtTopBot.CountablyGenerated | {
"line": 82,
"column": 4
} | {
"line": 84,
"column": 15
} | [
{
"pp": "case refine_1\nα : Type u_3\ninst✝³ : Preorder α\ninst✝² : Nonempty α\ninst✝¹ : IsDirectedOrder α\ninst✝ : atTop.IsCountablyGenerated\nys : ℕ → α\nh : Tendsto ys atTop atTop\nc : α → α → α\nhleft : ∀ (a b : α), a ≤ c a b\nhright : ∀ (a b : α), b ≤ c a b\nxs : ℕ → α := fun n ↦ List.foldl (fun x n ↦ c x ... | refine monotone_nat_of_le_succ fun n ↦ ?_
rw [hsucc]
apply hleft | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Order.Filter.AtTopBot.CountablyGenerated | {
"line": 82,
"column": 4
} | {
"line": 84,
"column": 15
} | [
{
"pp": "case refine_1\nα : Type u_3\ninst✝³ : Preorder α\ninst✝² : Nonempty α\ninst✝¹ : IsDirectedOrder α\ninst✝ : atTop.IsCountablyGenerated\nys : ℕ → α\nh : Tendsto ys atTop atTop\nc : α → α → α\nhleft : ∀ (a b : α), a ≤ c a b\nhright : ∀ (a b : α), b ≤ c a b\nxs : ℕ → α := fun n ↦ List.foldl (fun x n ↦ c x ... | refine monotone_nat_of_le_succ fun n ↦ ?_
rw [hsucc]
apply hleft | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Order.Filter.Cofinite | {
"line": 211,
"column": 6
} | {
"line": 211,
"column": 30
} | [
{
"pp": "p : ℕ → Prop\n⊢ (∃ᶠ (n : ℕ) in atTop, p n) ↔ {n | p n}.Infinite",
"usedConstants": [
"Eq.mpr",
"congrArg",
"setOf",
"id",
"Filter.Frequently",
"Filter.atTop",
"Iff",
"Nat.instPreorder",
"Nat",
"Filter.cofinite",
"Nat.cofinite_eq_atTo... | ← Nat.cofinite_eq_atTop, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Order.Filter.Cofinite | {
"line": 218,
"column": 37
} | {
"line": 230,
"column": 53
} | [
{
"pp": "α : Type u_4\nβ : Type u_5\ninst✝ : LinearOrder β\ns : Set α\nhs : s.Nonempty\nf : α → β\nhf : Tendsto f cofinite atTop\n⊢ ∃ a₀ ∈ s, ∀ a ∈ s, f a₀ ≤ f a",
"usedConstants": [
"Mathlib.Tactic.Push.not_exists._simp_1",
"Mathlib.Tactic.Push.not_and_eq",
"Preorder.toLT",
"Set.Fin... | by
by_cases! all_top : ∃ y ∈ s, ∃ x, f y < x
· -- the set of points `{y | f y < x}` is nonempty and finite, so we take `min` over this set
rcases all_top with ⟨y, hys, x, hx⟩
have : { y | ¬x ≤ f y }.Finite := Filter.eventually_cofinite.mp (tendsto_atTop.1 hf x)
simp only [not_le] at this
obtain ⟨a₀,... | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Order.LiminfLimsup | {
"line": 1029,
"column": 13
} | {
"line": 1029,
"column": 23
} | [
{
"pp": "case pos\nα : Type u_1\nι : Type u_4\nι' : Type u_5\ninst✝² : ConditionallyCompleteLinearOrder α\nv : Filter ι\np : ι' → Prop\ns : ι' → Set ι\ninst✝¹ : Countable (Subtype p)\ninst✝ : Nonempty (Subtype p)\nhv : v.HasBasis p s\nf : ι → α\nH : ¬∃ j, s ↑j = ∅\nH' : ∀ (j : Subtype p), ¬BddBelow (range fun i... | if_pos H', | Mathlib.Tactic._aux_Mathlib_Tactic_SimpRw___elabRules_Mathlib_Tactic_tacticSimp_rw____1 | null |
Mathlib.Order.LiminfLimsup | {
"line": 1096,
"column": 2
} | {
"line": 1096,
"column": 22
} | [
{
"pp": "α : Type u_1\nβ : Type u_2\nγ : Type u_6\ninst✝¹ : ConditionallyCompleteLattice β\ninst✝ : ConditionallyCompleteLattice γ\nf : Filter α\nu : α → β\ng : β ≃o γ\nhu : IsBoundedUnder (fun x1 x2 ↦ x1 ≤ x2) f u\nhu_co : IsCoboundedUnder (fun x1 x2 ↦ x1 ≤ x2) f u\nhgu : IsBoundedUnder (fun x1 x2 ↦ x1 ≤ x2) f... | refine g.monotone ?_ | Lean.Elab.Tactic.evalRefine | Lean.Parser.Tactic.refine |
Mathlib.Topology.Closure | {
"line": 337,
"column": 33
} | {
"line": 337,
"column": 40
} | [
{
"pp": "X : Type u\ninst✝ : TopologicalSpace X\ns t : Set X\nh : Disjoint (closure s) (closure t)\nfull : interior sᶜ ∪ interior tᶜ = univ\n⊢ interior (s ∪ t) ∩ univ ⊆ interior s ∪ interior t",
"usedConstants": [
"Eq.mpr",
"congrArg",
"Compl.compl",
"Set.univ",
"Set.instUnion"... | ← full, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Topology.Continuous | {
"line": 103,
"column": 59
} | {
"line": 103,
"column": 84
} | [
{
"pp": "X : Type u_1\nY : Type u_2\ninst✝¹ : TopologicalSpace X\ninst✝ : TopologicalSpace Y\nf : X → Y\nh : ∀ (s : Set Y), f ⁻¹' interior s ⊆ interior (f ⁻¹' s)\ns : Set Y\nhs : IsOpen s\n⊢ f ⁻¹' s ⊆ interior (f ⁻¹' s)",
"usedConstants": [
"Eq.mpr",
"congrArg",
"Set.instIsTransSubset",
... | grw [← h, hs.interior_eq] | Mathlib.Tactic._aux_Mathlib_Tactic_GRewrite_Elab___macroRules_Mathlib_Tactic_grwSeq_1 | Mathlib.Tactic.grwSeq |
Mathlib.Topology.Continuous | {
"line": 103,
"column": 59
} | {
"line": 103,
"column": 84
} | [
{
"pp": "X : Type u_1\nY : Type u_2\ninst✝¹ : TopologicalSpace X\ninst✝ : TopologicalSpace Y\nf : X → Y\nh : ∀ (s : Set Y), f ⁻¹' interior s ⊆ interior (f ⁻¹' s)\ns : Set Y\nhs : IsOpen s\n⊢ f ⁻¹' s ⊆ interior (f ⁻¹' s)",
"usedConstants": [
"Eq.mpr",
"congrArg",
"Set.instIsTransSubset",
... | grw [← h, hs.interior_eq] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Topology.Continuous | {
"line": 103,
"column": 59
} | {
"line": 103,
"column": 84
} | [
{
"pp": "X : Type u_1\nY : Type u_2\ninst✝¹ : TopologicalSpace X\ninst✝ : TopologicalSpace Y\nf : X → Y\nh : ∀ (s : Set Y), f ⁻¹' interior s ⊆ interior (f ⁻¹' s)\ns : Set Y\nhs : IsOpen s\n⊢ f ⁻¹' s ⊆ interior (f ⁻¹' s)",
"usedConstants": [
"Eq.mpr",
"congrArg",
"Set.instIsTransSubset",
... | grw [← h, hs.interior_eq] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Topology.NhdsSet | {
"line": 139,
"column": 55
} | {
"line": 139,
"column": 78
} | [
{
"pp": "X : Type u_1\ninst✝ : TopologicalSpace X\n⊢ 𝓝ˢ univ = ⊤",
"usedConstants": [
"Eq.mpr",
"congrArg",
"Set.univ",
"id",
"isOpen_univ",
"Filter.principal",
"Filter.instTop",
"Top.top",
"IsOpen.nhdsSet_eq",
"nhdsSet",
"Eq",
"Filter... | isOpen_univ.nhdsSet_eq, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Topology.Maps.Basic | {
"line": 314,
"column": 2
} | {
"line": 315,
"column": 24
} | [
{
"pp": "X : Type u_1\nY : Type u_2\nf : X → Y\ninst✝¹ : TopologicalSpace X\ninst✝ : TopologicalSpace Y\nhf : IsOpenMap f\n⊢ IsOpen (range f)",
"usedConstants": [
"Eq.mpr",
"Set.image_univ",
"congrArg",
"Set.univ",
"id",
"isOpen_univ",
"Set.image",
"IsOpen",
... | rw [← image_univ]
exact hf _ isOpen_univ | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Topology.Maps.Basic | {
"line": 314,
"column": 2
} | {
"line": 315,
"column": 24
} | [
{
"pp": "X : Type u_1\nY : Type u_2\nf : X → Y\ninst✝¹ : TopologicalSpace X\ninst✝ : TopologicalSpace Y\nhf : IsOpenMap f\n⊢ IsOpen (range f)",
"usedConstants": [
"Eq.mpr",
"Set.image_univ",
"congrArg",
"Set.univ",
"id",
"isOpen_univ",
"Set.image",
"IsOpen",
... | rw [← image_univ]
exact hf _ isOpen_univ | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Topology.NhdsWithin | {
"line": 188,
"column": 2
} | {
"line": 188,
"column": 67
} | [
{
"pp": "α : Type u_1\ninst✝ : TopologicalSpace α\na : α\ns t u : Set α\nh₀ : a ∈ s\nh₁ : IsOpen s\nh₂ : t ∩ s = u ∩ s\n⊢ 𝓝[t] a = 𝓝[u] a",
"usedConstants": [
"Eq.mpr",
"congrArg",
"nhdsWithin",
"id",
"Set.instInter",
"Inter.inter",
"nhdsWithin_restrict",
"E... | rw [nhdsWithin_restrict t h₀ h₁, nhdsWithin_restrict u h₀ h₁, h₂] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.Topology.NhdsWithin | {
"line": 188,
"column": 2
} | {
"line": 188,
"column": 67
} | [
{
"pp": "α : Type u_1\ninst✝ : TopologicalSpace α\na : α\ns t u : Set α\nh₀ : a ∈ s\nh₁ : IsOpen s\nh₂ : t ∩ s = u ∩ s\n⊢ 𝓝[t] a = 𝓝[u] a",
"usedConstants": [
"Eq.mpr",
"congrArg",
"nhdsWithin",
"id",
"Set.instInter",
"Inter.inter",
"nhdsWithin_restrict",
"E... | rw [nhdsWithin_restrict t h₀ h₁, nhdsWithin_restrict u h₀ h₁, h₂] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Topology.NhdsWithin | {
"line": 188,
"column": 2
} | {
"line": 188,
"column": 67
} | [
{
"pp": "α : Type u_1\ninst✝ : TopologicalSpace α\na : α\ns t u : Set α\nh₀ : a ∈ s\nh₁ : IsOpen s\nh₂ : t ∩ s = u ∩ s\n⊢ 𝓝[t] a = 𝓝[u] a",
"usedConstants": [
"Eq.mpr",
"congrArg",
"nhdsWithin",
"id",
"Set.instInter",
"Inter.inter",
"nhdsWithin_restrict",
"E... | rw [nhdsWithin_restrict t h₀ h₁, nhdsWithin_restrict u h₀ h₁, h₂] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Topology.Constructions.SumProd | {
"line": 246,
"column": 43
} | {
"line": 247,
"column": 81
} | [
{
"pp": "X : Type u\nY : Type v\ninst✝¹ : TopologicalSpace X\ninst✝ : TopologicalSpace Y\nx : X\ny : Y\ns : Set X\nt : Set Y\n⊢ 𝓝[s ×ˢ t] (x, y) = 𝓝[s] x ×ˢ 𝓝[t] y",
"usedConstants": [
"Set.instSProd",
"SProd.sprod",
"congrArg",
"nhdsWithin",
"instTopologicalSpaceProd",
... | by
simp only [nhdsWithin, nhds_prod_eq, ← prod_inf_prod, prod_principal_principal] | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Topology.Constructions.SumProd | {
"line": 288,
"column": 97
} | {
"line": 289,
"column": 45
} | [
{
"pp": "Y : Type v\nZ : Type u_2\ninst✝¹ : TopologicalSpace Y\ninst✝ : TopologicalSpace Z\nX : Type u_5\nseq : X → Y × Z\nf : Filter X\np : Y × Z\n⊢ Tendsto seq f (𝓝 p) ↔ Tendsto (fun n ↦ (seq n).1) f (𝓝 p.1) ∧ Tendsto (fun n ↦ (seq n).2) f (𝓝 p.2)",
"usedConstants": [
"Eq.mpr",
"SProd.sprod... | by
rw [nhds_prod_eq, Filter.tendsto_prod_iff'] | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Topology.NhdsWithin | {
"line": 513,
"column": 66
} | {
"line": 514,
"column": 61
} | [
{
"pp": "α : Type u_1\nβ : Type u_2\ninst✝ : TopologicalSpace α\ns : Set α\na : α\nh : a ∈ s\nf : α → β\nl : Filter β\n⊢ Tendsto f (𝓝[s] a) l ↔ Tendsto (s.restrict f) (𝓝 ⟨a, h⟩) l",
"usedConstants": [
"Eq.mpr",
"congrArg",
"Filter.map",
"nhdsWithin",
"Iff.rfl",
"nhdsWit... | by
rw [nhdsWithin_eq_map_subtype_coe h, tendsto_map'_iff]; rfl | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Topology.Constructions.SumProd | {
"line": 434,
"column": 2
} | {
"line": 436,
"column": 5
} | [
{
"pp": "Y : Type v\nW : Type u_1\ninst✝¹ : TopologicalSpace Y\ninst✝ : TopologicalSpace W\nX : Type u_5\nZ : Type u_6\nf : X → Y\ng : Z → W\n⊢ instTopologicalSpaceProd = induced (fun p ↦ (f p.1, g p.2)) instTopologicalSpaceProd",
"usedConstants": [
"Eq.mpr",
"induced_inf",
"congrArg",
... | delta instTopologicalSpaceProd
simp_rw [induced_inf, induced_compose]
rfl | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Topology.Constructions.SumProd | {
"line": 434,
"column": 2
} | {
"line": 436,
"column": 5
} | [
{
"pp": "Y : Type v\nW : Type u_1\ninst✝¹ : TopologicalSpace Y\ninst✝ : TopologicalSpace W\nX : Type u_5\nZ : Type u_6\nf : X → Y\ng : Z → W\n⊢ instTopologicalSpaceProd = induced (fun p ↦ (f p.1, g p.2)) instTopologicalSpaceProd",
"usedConstants": [
"Eq.mpr",
"induced_inf",
"congrArg",
... | delta instTopologicalSpaceProd
simp_rw [induced_inf, induced_compose]
rfl | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Topology.Constructions.SumProd | {
"line": 465,
"column": 2
} | {
"line": 465,
"column": 76
} | [
{
"pp": "X : Type u\nY : Type v\ninst✝¹ : TopologicalSpace X\ninst✝ : TopologicalSpace Y\nx : X × Y\n⊢ map Prod.snd (𝓝[Prod.fst ⁻¹' {x.1}] x) = 𝓝 x.2",
"usedConstants": [
"Filter.instMembership",
"Filter.map",
"Filter.instCompleteLatticeFilter",
"nhdsWithin",
"instTopological... | refine le_antisymm (continuousAt_snd.mono_left inf_le_left) fun s hs => ?_ | Lean.Elab.Tactic.evalRefine | Lean.Parser.Tactic.refine |
Mathlib.Topology.NhdsWithin | {
"line": 572,
"column": 2
} | {
"line": 572,
"column": 82
} | [
{
"pp": "α : Type u_1\ninst✝ : TopologicalSpace α\ns t : Set α\n⊢ 𝓟 (s ∩ t) ≤ 𝓝ˢ[t] s",
"usedConstants": [
"Filter.instMembership",
"Eq.mpr",
"and_true",
"Set.inter_subset_right._simp_1",
"congrArg",
"Filter.inf_principal",
"Filter.instCompleteLatticeFilter",
... | simpa [nhdsSetWithin] using inf_le_of_left_le (b := 𝓟 t) <| principal_le_nhdsSet | Lean.Elab.Tactic.Simpa.evalSimpa | Lean.Parser.Tactic.simpa |
Mathlib.Topology.NhdsWithin | {
"line": 572,
"column": 2
} | {
"line": 572,
"column": 82
} | [
{
"pp": "α : Type u_1\ninst✝ : TopologicalSpace α\ns t : Set α\n⊢ 𝓟 (s ∩ t) ≤ 𝓝ˢ[t] s",
"usedConstants": [
"Filter.instMembership",
"Eq.mpr",
"and_true",
"Set.inter_subset_right._simp_1",
"congrArg",
"Filter.inf_principal",
"Filter.instCompleteLatticeFilter",
... | simpa [nhdsSetWithin] using inf_le_of_left_le (b := 𝓟 t) <| principal_le_nhdsSet | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Topology.NhdsWithin | {
"line": 572,
"column": 2
} | {
"line": 572,
"column": 82
} | [
{
"pp": "α : Type u_1\ninst✝ : TopologicalSpace α\ns t : Set α\n⊢ 𝓟 (s ∩ t) ≤ 𝓝ˢ[t] s",
"usedConstants": [
"Filter.instMembership",
"Eq.mpr",
"and_true",
"Set.inter_subset_right._simp_1",
"congrArg",
"Filter.inf_principal",
"Filter.instCompleteLatticeFilter",
... | simpa [nhdsSetWithin] using inf_le_of_left_le (b := 𝓟 t) <| principal_le_nhdsSet | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Topology.Constructions | {
"line": 1007,
"column": 2
} | {
"line": 1007,
"column": 22
} | [
{
"pp": "ι : Type u_5\nA : ι → Type u_6\nT : (i : ι) → TopologicalSpace (A i)\ns : Set ((a : ι) → A a)\n⊢ IsOpen s ↔ ∀ f ∈ s, ∃ I u, (∀ a ∈ I, IsOpen (u a) ∧ f a ∈ u a) ∧ (↑I).pi u ⊆ s",
"usedConstants": [
"Eq.mpr",
"Pi.topologicalSpace",
"congrArg",
"Finset",
"PartialOrder.toP... | rw [isOpen_iff_nhds] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.Topology.Constructions | {
"line": 1008,
"column": 2
} | {
"line": 1008,
"column": 67
} | [
{
"pp": "ι : Type u_5\nA : ι → Type u_6\nT : (i : ι) → TopologicalSpace (A i)\ns : Set ((a : ι) → A a)\n⊢ (∀ x ∈ s, 𝓝 x ≤ 𝓟 s) ↔ ∀ f ∈ s, ∃ I u, (∀ a ∈ I, IsOpen (u a) ∧ f a ∈ u a) ∧ (↑I).pi u ⊆ s",
"usedConstants": [
"Filter.instMembership",
"Eq.mpr",
"_private.Mathlib.Topology.Construc... | simp_rw [le_principal_iff, nhds_pi, Filter.mem_pi', mem_nhds_iff] | Mathlib.Tactic._aux_Mathlib_Tactic_SimpRw___elabRules_Mathlib_Tactic_tacticSimp_rw____1 | Mathlib.Tactic.tacticSimp_rw___ |
Mathlib.Topology.Constructions | {
"line": 1027,
"column": 6
} | {
"line": 1027,
"column": 24
} | [
{
"pp": "case refine_2.refine_2\nι : Type u_5\nA : ι → Type u_6\nT : (i : ι) → TopologicalSpace (A i)\ns : Set ((a : ι) → A a)\na : (a : ι) → A a\nx✝ : a ∈ s\nI : Finset ι\nt : (a : ι) → Set (A a)\nh1 : ∀ a_1 ∈ I, IsOpen (t a_1) ∧ a a_1 ∈ t a_1\nh2 : (↑I).pi t ⊆ s\n⊢ ((↑I).pi fun a ↦ if a ∈ I then t a else univ... | rw [← univ_pi_ite] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.Topology.Constructions | {
"line": 1034,
"column": 2
} | {
"line": 1034,
"column": 22
} | [
{
"pp": "case intro\nι : Type u_5\nA : ι → Type u_6\nT : (i : ι) → TopologicalSpace (A i)\ninst✝ : Finite ι\ns : Set ((a : ι) → A a)\nval✝ : Fintype ι\n⊢ IsOpen s ↔ ∀ f ∈ s, ∃ u, (∀ (a : ι), IsOpen (u a) ∧ f a ∈ u a) ∧ univ.pi u ⊆ s",
"usedConstants": [
"Eq.mpr",
"Pi.topologicalSpace",
"co... | rw [isOpen_iff_nhds] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.Topology.Constructions | {
"line": 1035,
"column": 2
} | {
"line": 1035,
"column": 67
} | [
{
"pp": "case intro\nι : Type u_5\nA : ι → Type u_6\nT : (i : ι) → TopologicalSpace (A i)\ninst✝ : Finite ι\ns : Set ((a : ι) → A a)\nval✝ : Fintype ι\n⊢ (∀ x ∈ s, 𝓝 x ≤ 𝓟 s) ↔ ∀ f ∈ s, ∃ u, (∀ (a : ι), IsOpen (u a) ∧ f a ∈ u a) ∧ univ.pi u ⊆ s",
"usedConstants": [
"Filter.instMembership",
"Eq... | simp_rw [le_principal_iff, nhds_pi, Filter.mem_pi', mem_nhds_iff] | Mathlib.Tactic._aux_Mathlib_Tactic_SimpRw___elabRules_Mathlib_Tactic_tacticSimp_rw____1 | Mathlib.Tactic.tacticSimp_rw___ |
Mathlib.Topology.Constructions.SumProd | {
"line": 822,
"column": 2
} | {
"line": 826,
"column": 62
} | [
{
"pp": "case mpr\nX : Type u\nY : Type v\nZ : Type u_2\ninst✝² : TopologicalSpace X\ninst✝¹ : TopologicalSpace Y\ninst✝ : TopologicalSpace Z\nf : X ⊕ Y → Z\n⊢ ((IsClosedMap fun a ↦ f (inl a)) ∧ IsClosedMap fun b ↦ f (inr b)) → IsClosedMap f",
"usedConstants": [
"Set.ext",
"Eq.mpr",
"congr... | · rintro h Z hZ
rw [isClosed_sum_iff] at hZ
convert (h.1 _ hZ.1).union (h.2 _ hZ.2)
ext
simp only [mem_image, Sum.exists, mem_union, mem_preimage] | Lean.Elab.Tactic.evalTacticCDot | Lean.cdot |
Mathlib.Topology.Constructions | {
"line": 1222,
"column": 2
} | {
"line": 1222,
"column": 33
} | [
{
"pp": "X : Type u\nι : Type u_5\nσ : ι → Type u_7\ninst✝¹ : (i : ι) → TopologicalSpace (σ i)\ninst✝ : TopologicalSpace X\nf : Sigma σ → X\n⊢ Continuous f ↔ ∀ (i : ι), Continuous fun a ↦ f ⟨i, a⟩",
"usedConstants": [
"Continuous",
"id",
"instTopologicalSpaceSigma",
"Iff",
"Sig... | delta instTopologicalSpaceSigma | Lean.Elab.Tactic.evalDelta | Lean.Parser.Tactic.delta |
Mathlib.Topology.Bases | {
"line": 90,
"column": 4
} | {
"line": 91,
"column": 69
} | [
{
"pp": "case refine_3\nα : Type u\ns : Set (Set α)\nthis : TopologicalSpace α := generateFrom s\n⊢ ∀ s_1 ∈ (fun f ↦ ⋂₀ f) '' {f | f.Finite ∧ f ⊆ s}, IsOpen s_1",
"usedConstants": [
"TopologicalSpace.GenerateOpen.basic",
"setOf",
"Set.Finite",
"Membership.mem",
"HasSubset.Subse... | rintro _ ⟨t, ⟨hft, htb⟩, rfl⟩
exact hft.isOpen_sInter fun s hs ↦ GenerateOpen.basic _ <| htb hs | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Topology.Bases | {
"line": 90,
"column": 4
} | {
"line": 91,
"column": 69
} | [
{
"pp": "case refine_3\nα : Type u\ns : Set (Set α)\nthis : TopologicalSpace α := generateFrom s\n⊢ ∀ s_1 ∈ (fun f ↦ ⋂₀ f) '' {f | f.Finite ∧ f ⊆ s}, IsOpen s_1",
"usedConstants": [
"TopologicalSpace.GenerateOpen.basic",
"setOf",
"Set.Finite",
"Membership.mem",
"HasSubset.Subse... | rintro _ ⟨t, ⟨hft, htb⟩, rfl⟩
exact hft.isOpen_sInter fun s hs ↦ GenerateOpen.basic _ <| htb hs | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Topology.Constructions | {
"line": 1337,
"column": 2
} | {
"line": 1337,
"column": 53
} | [
{
"pp": "X : Type u\ninst✝ : TopologicalSpace X\ns : Set X\nt : Set ↑s\nht : IsOpen t\nhs : IsOpen s\n⊢ IsOpen (Subtype.val '' t)",
"usedConstants": [
"Membership.mem",
"Exists",
"Set.Elem",
"And",
"TopologicalSpace.induced",
"Set.preimage",
"Iff.mp",
"IsOpen"... | rcases isOpen_induced_iff.mp ht with ⟨s', hs', rfl⟩ | _private.Lean.Elab.Tactic.RCases.0.Lean.Elab.Tactic.RCases.evalRCases | Lean.Parser.Tactic.rcases |
Mathlib.Order.Filter.Ultrafilter.Basic | {
"line": 34,
"column": 2
} | {
"line": 36,
"column": 72
} | [
{
"pp": "α : Type u\nf : Ultrafilter α\ns : Set (Set α)\nhs : s.Finite\n⊢ ⋃₀ s ∈ f ↔ ∃ t ∈ s, t ∈ f",
"usedConstants": [
"Ultrafilter.union_mem_iff._simp_1",
"False",
"Set.mem_empty_iff_false._simp_1",
"congrArg",
"exists_const._simp_1",
"Set.sUnion_insert",
"Set.sU... | induction s, hs using Set.Finite.induction_on with
| empty => simp
| insert _ _ his => simp [union_mem_iff, his, or_and_right, exists_or] | _private.Lean.Elab.Tactic.Induction.0.Lean.Elab.Tactic.evalInduction | Lean.Parser.Tactic.induction |
Mathlib.Order.Filter.Ultrafilter.Basic | {
"line": 34,
"column": 2
} | {
"line": 36,
"column": 72
} | [
{
"pp": "α : Type u\nf : Ultrafilter α\ns : Set (Set α)\nhs : s.Finite\n⊢ ⋃₀ s ∈ f ↔ ∃ t ∈ s, t ∈ f",
"usedConstants": [
"Ultrafilter.union_mem_iff._simp_1",
"False",
"Set.mem_empty_iff_false._simp_1",
"congrArg",
"exists_const._simp_1",
"Set.sUnion_insert",
"Set.sU... | induction s, hs using Set.Finite.induction_on with
| empty => simp
| insert _ _ his => simp [union_mem_iff, his, or_and_right, exists_or] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Order.Filter.Ultrafilter.Basic | {
"line": 34,
"column": 2
} | {
"line": 36,
"column": 72
} | [
{
"pp": "α : Type u\nf : Ultrafilter α\ns : Set (Set α)\nhs : s.Finite\n⊢ ⋃₀ s ∈ f ↔ ∃ t ∈ s, t ∈ f",
"usedConstants": [
"Ultrafilter.union_mem_iff._simp_1",
"False",
"Set.mem_empty_iff_false._simp_1",
"congrArg",
"exists_const._simp_1",
"Set.sUnion_insert",
"Set.sU... | induction s, hs using Set.Finite.induction_on with
| empty => simp
| insert _ _ his => simp [union_mem_iff, his, or_and_right, exists_or] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Order.Filter.SmallSets | {
"line": 114,
"column": 39
} | {
"line": 114,
"column": 55
} | [
{
"pp": "α : Type u_4\nι : Sort u_5\np : ι → Prop\nl : Filter α\ns : ι → Set α\nq : Set α → Prop\nhl : l.HasBasis p s\nhq : ∀ ⦃s t : Set α⦄, s ⊆ t → q s → q t\n⊢ (∀ t ∈ l, q t) ↔ ∀ (i : ι), p i → q (s i)",
"usedConstants": [
"Filter.instMembership",
"Eq.mpr",
"congrArg",
"Membership.... | hl.forall_iff hq | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Topology.LocallyFinite | {
"line": 81,
"column": 2
} | {
"line": 88,
"column": 78
} | [
{
"pp": "ι : Type u_1\nX : Type u_4\ninst✝ : TopologicalSpace X\nf : ι → Set X\nhf : LocallyFinite f\na : X\nU : Set X\nhaU : U ∈ 𝓝 a\nhfin : {i | (f i ∩ U).Nonempty}.Finite\n⊢ 𝓝[⋃ i, f i] a ≤ ⨆ i, 𝓝[f i] a",
"usedConstants": [
"Eq.mpr",
"Filter.instSupSet",
"nhdsWithin_biUnion",
... | calc
𝓝[⋃ i, f i] a = 𝓝[⋃ i, f i ∩ U] a := by
rw [← iUnion_inter, ← nhdsWithin_inter_of_mem' (nhdsWithin_le_nhds haU)]
_ = 𝓝[⋃ i ∈ {j | (f j ∩ U).Nonempty}, (f i ∩ U)] a := by
simp only [mem_setOf_eq, iUnion_nonempty_self]
_ = ⨆ i ∈ {j | (f j ∩ U).Nonempty}, 𝓝[f i ∩ U] a := nhdsWithin_biUnion... | Lean.Elab.Tactic._aux_Mathlib_Tactic_Widget_Calc___elabRules_Lean_calcTactic_1 | Lean.calcTactic |
Mathlib.Topology.GDelta.Basic | {
"line": 180,
"column": 2
} | {
"line": 183,
"column": 74
} | [
{
"pp": "X : Type u_1\ninst✝ : TopologicalSpace X\ns : Set X\nho : IsGδ s\nhd : Dense s\n⊢ s ∈ residual X",
"usedConstants": [
"Filter.instMembership",
"Iff.mpr",
"countableInterFilter_residual",
"residual",
"Membership.mem",
"Dense",
"Dense.mono",
"Set.sInter... | rcases ho with ⟨T, To, Tct, rfl⟩
exact
(countable_sInter_mem Tct).mpr fun t tT =>
residual_of_dense_open (To t tT) (hd.mono (sInter_subset_of_mem tT)) | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Topology.GDelta.Basic | {
"line": 180,
"column": 2
} | {
"line": 183,
"column": 74
} | [
{
"pp": "X : Type u_1\ninst✝ : TopologicalSpace X\ns : Set X\nho : IsGδ s\nhd : Dense s\n⊢ s ∈ residual X",
"usedConstants": [
"Filter.instMembership",
"Iff.mpr",
"countableInterFilter_residual",
"residual",
"Membership.mem",
"Dense",
"Dense.mono",
"Set.sInter... | rcases ho with ⟨T, To, Tct, rfl⟩
exact
(countable_sInter_mem Tct).mpr fun t tT =>
residual_of_dense_open (To t tT) (hd.mono (sInter_subset_of_mem tT)) | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Order.Filter.CountableInter | {
"line": 243,
"column": 93
} | {
"line": 247,
"column": 10
} | [
{
"pp": "ι : Sort u_1\nα✝ : Type u_2\nβ✝ : Type u_3\nl✝ : Filter α✝\ninst✝² : CountableInterFilter l✝\nα : Type u_4\nβ : Type u_5\nl : Filter α\nm : Filter β\ninst✝¹ : CountableInterFilter l\ninst✝ : CountableInterFilter m\n⊢ ∀ (S : Set (Set (α × β))), S.Countable → (∀ s ∈ S, s ∈ l.curry m) → ⋂₀ S ∈ l.curry m",... | by
intro S Sct hS
simp_rw [mem_curry_iff, mem_sInter, eventually_countable_ball (p := fun _ _ _ => (_, _) ∈ _) Sct,
eventually_countable_ball (p := fun _ _ _ => ∀ᶠ (_ : β) in m, _) Sct, ← mem_curry_iff]
exact hS | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Topology.Maps.OpenQuotient | {
"line": 126,
"column": 2
} | {
"line": 136,
"column": 45
} | [
{
"pp": "case a.h.a.mp\nA : Type u_4\nB : Type u_5\nC : Type u_6\nD : Type u_7\ninst✝² : TopologicalSpace A\ninst✝¹ : TopologicalSpace B\ninst✝ : TopologicalSpace D\nf : A → B\ng : C → D\np : A → C\nq : B → D\nh : g ∘ p = q ∘ f\nhf : IsInducing f\nhp : Surjective p\nhq : IsOpenQuotientMap q\nhg : Injective g\nH... | · rintro ⟨V, hV, e⟩
refine ⟨V, hq.continuous.1 _ (hq.isOpenMap _ hV), ?_⟩
ext x
obtain ⟨x, rfl⟩ := hp x
constructor
· rintro ⟨y, hy, e'⟩
obtain ⟨y, rfl⟩ := H ⟨_, ⟨x, rfl⟩, (e'.trans (congr_fun h x)).symm⟩
rw [← hg ((congr_fun h y).trans e')]
exact e.le hy
· intro H
exact ... | Lean.Elab.Tactic.evalTacticCDot | Lean.cdot |
Mathlib.Topology.Compactness.Compact | {
"line": 1211,
"column": 8
} | {
"line": 1214,
"column": 17
} | [
{
"pp": "case neg\nX : Type u\ninst✝¹ : TopologicalSpace X\ninst✝ : CompactSpace X\nS : Set X\nhS : IsClosed S\nhne : S.Nonempty\nopens : Set (Set X) := {U | Sᶜ ⊆ U ∧ IsOpen U ∧ Uᶜ.Nonempty}\nc : Set (Set X)\nhc : c ⊆ opens\nhz : IsChain (fun x1 x2 ↦ x1 ⊆ x2) c\nhcne : ¬c.Nonempty\n⊢ ∃ ub ∈ opens, ∀ s ∈ c, s ⊆ ... | use Sᶜ
refine ⟨⟨Set.Subset.refl _, isOpen_compl_iff.mpr hS, ?_⟩, fun U Uc => (hcne ⟨U, Uc⟩).elim⟩
rw [compl_compl]
exact hne | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Topology.Compactness.Compact | {
"line": 1211,
"column": 8
} | {
"line": 1214,
"column": 17
} | [
{
"pp": "case neg\nX : Type u\ninst✝¹ : TopologicalSpace X\ninst✝ : CompactSpace X\nS : Set X\nhS : IsClosed S\nhne : S.Nonempty\nopens : Set (Set X) := {U | Sᶜ ⊆ U ∧ IsOpen U ∧ Uᶜ.Nonempty}\nc : Set (Set X)\nhc : c ⊆ opens\nhz : IsChain (fun x1 x2 ↦ x1 ⊆ x2) c\nhcne : ¬c.Nonempty\n⊢ ∃ ub ∈ opens, ∀ s ∈ c, s ⊆ ... | use Sᶜ
refine ⟨⟨Set.Subset.refl _, isOpen_compl_iff.mpr hS, ?_⟩, fun U Uc => (hcne ⟨U, Uc⟩).elim⟩
rw [compl_compl]
exact hne | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Topology.Inseparable | {
"line": 631,
"column": 77
} | {
"line": 634,
"column": 50
} | [
{
"pp": "X : Type u_1\ninst✝ : TopologicalSpace X\ns : Set X\nhs : IsClosed s\n⊢ mk ⁻¹' (mk '' s) = s",
"usedConstants": [
"Set.Subset.antisymm",
"SeparationQuotient.mk_eq_mk",
"Membership.mem",
"Inseparable.mem_closed_iff",
"And.casesOn",
"And",
"Exists.casesOn",
... | by
refine Subset.antisymm ?_ (subset_preimage_image _ _)
rintro x ⟨y, hys, hxy⟩
exact ((mk_eq_mk.1 hxy).mem_closed_iff hs).1 hys | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Topology.Separation.Hausdorff | {
"line": 697,
"column": 21
} | {
"line": 697,
"column": 55
} | [
{
"pp": "X : Type u_1\ninst✝¹ : TopologicalSpace X\ninst✝ : T2Space X\nS : Set X\n⊢ S.Nonempty ∧ IsPreirreducible S ↔ ∃ x, S = {x}",
"usedConstants": [
"IsPreirreducible",
"Eq.mpr",
"congrArg",
"Exists",
"Set.instSingletonSet",
"id",
"And",
"Iff",
"Set.N... | isPreirreducible_iff_subsingleton, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Topology.Algebra.InfiniteSum.Defs | {
"line": 192,
"column": 2
} | {
"line": 192,
"column": 88
} | [
{
"pp": "case neg\nα : Type u_1\nβ : Type u_2\ninst✝¹ : CommMonoid α\ninst✝ : TopologicalSpace α\nL : SummationFilter β\nhL : ¬L.NeBot\nf : β → α\nthis : L.LeAtTop\nhf : ¬(mulSupport f).Finite\n⊢ (if L.HasSupport ∧ (mulSupport fun b ↦ f b).Finite then ∏ᶠ (b : β), f b\n else if HasProd (fun b ↦ f b) 1 L then ... | · rwa [if_neg (by tauto), if_pos (hasProd_bot hL _ _), finprod_of_infinite_mulSupport] | Lean.Elab.Tactic.evalTacticCDot | Lean.cdot |
Mathlib.Topology.Separation.Basic | {
"line": 181,
"column": 2
} | {
"line": 181,
"column": 80
} | [
{
"pp": "case inr\nX : Type u_1\ninst✝¹ : TopologicalSpace X\ninst✝ : T0Space X\ns : Set X\nhs : IsOpen s\nhmin : ∀ t ⊆ s, t.Nonempty → IsOpen t → t = s\nx : X\nhx : x ∈ s\ny : X\nhy : y ∈ s\nhxy : ¬x = y\nU : Set X\nhUo : IsOpen U\nhU : Xor' (x ∈ U) (y ∈ U)\nthis :\n ∀ {X : Type u_1} [inst : TopologicalSpace ... | · exact this hs hmin y hy x hx (Ne.symm hxy) U hUo hU.symm (hU.resolve_left h) | Lean.Elab.Tactic.evalTacticCDot | Lean.cdot |
Mathlib.Topology.Separation.Basic | {
"line": 593,
"column": 51
} | {
"line": 598,
"column": 63
} | [
{
"pp": "X : Type u_1\ninst✝¹ : TopologicalSpace X\ninst✝ : T1Space X\nx y : X\ns t : Set X\nhu : t ⊆ insert y s\n⊢ insert x s ∈ 𝓝[t] x",
"usedConstants": [
"Filter.instMembership",
"Eq.mpr",
"congrArg",
"nhdsWithin",
"Membership.mem",
"id",
"Insert.insert",
... | by
rcases eq_or_ne x y with (rfl | h)
· exact mem_of_superset self_mem_nhdsWithin hu
refine nhdsWithin_mono x hu ?_
rw [nhdsWithin_insert_of_ne h]
exact mem_of_superset self_mem_nhdsWithin (subset_insert x s) | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Topology.Separation.Basic | {
"line": 693,
"column": 2
} | {
"line": 693,
"column": 47
} | [
{
"pp": "X : Type u_1\ninst✝ : TopologicalSpace X\ns : Set X\na : X\np : X → Prop\nhs : IsOpen s\n⊢ (∀ᶠ (y : X) in 𝓝[s] a, ∀ᶠ (x : X) in 𝓝 y, p x) ↔ ∀ᶠ (x : X) in 𝓝[s] a, p x",
"usedConstants": [
"Eq.mpr",
"congrArg",
"nhdsWithin",
"Filter.Eventually",
"nhds",
"id",
... | nth_rw 2 [← eventually_eventually_nhdsWithin] | Mathlib.Tactic._aux_Mathlib_Tactic_NthRewrite___macroRules_Mathlib_Tactic_tacticNth_rw______1 | Mathlib.Tactic.tacticNth_rw_____ |
Mathlib.Topology.Separation.Basic | {
"line": 738,
"column": 68
} | {
"line": 740,
"column": 65
} | [
{
"pp": "X : Type u_1\nY : Type u_2\ninst✝² : TopologicalSpace X\ninst✝¹ : TopologicalSpace Y\ninst✝ : T1Space Y\nf : X → Y\ns : Set X\nc : Y\nh : ∀ x ∈ closure s, ContinuousWithinAt f s x\nht : EqOn f (fun x ↦ c) s\n⊢ EqOn f (fun x ↦ c) (closure s)",
"usedConstants": [
"ContinuousWithinAt.eq_const_of... | by
intro x hx
apply ContinuousWithinAt.eq_const_of_mem_closure (h x hx) hx ht | [anonymous] | Lean.Parser.Term.byTactic |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.