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.SetTheory.ZFC.Rank | {
"line": 221,
"column": 37
} | {
"line": 221,
"column": 45
} | [
{
"pp": "case h\nx✝ x : ZFSet.{u}\nih : ∀ y ∈ x, lift.{u + 1, u} y.rank = IsWellFounded.rank (fun x1 x2 ↦ x1 ∈ x2) y\n⊢ lift.{u + 1, u} x.rank = IsWellFounded.rank (fun x1 x2 ↦ x1 ∈ x2) x",
"usedConstants": []
}
] | | _ x ih
=> | _private.Lean.Elab.Tactic.Induction.0.Lean.Elab.Tactic.evalInduction | null |
Mathlib.SetTheory.ZFC.VonNeumann | {
"line": 67,
"column": 4
} | {
"line": 67,
"column": 46
} | [
{
"pp": "case mp\no : Ordinal.{u_1}\nx : ZFSet.{u_1}\nhx : x ⊆ V_ o\ny : ZFSet.{u_1}\nhy : y ∈ x\nz : ZFSet.{u_1}\na : Ordinal.{u_1}\nha : a < o\nhz : z ⊆ V_ a\n⊢ z.rank < o",
"usedConstants": [
"Ordinal.partialOrder",
"ZFSet",
"PartialOrder.toPreorder",
"Preorder.toLE",
"HasSu... | exact (subset_vonNeumann.1 hz).trans_lt ha | Lean.Elab.Tactic.evalExact | Lean.Parser.Tactic.exact |
Mathlib.SetTheory.ZFC.Ordinal | {
"line": 87,
"column": 2
} | {
"line": 88,
"column": 31
} | [
{
"pp": "x : ZFSet.{u}\nh : x.IsTransitive\ny : ZFSet.{u}\nhy : y ∈ x.powerset\nz : ZFSet.{u}\nhz : z ∈ y\n⊢ z ∈ x.powerset",
"usedConstants": [
"Eq.mpr",
"congrArg",
"ZFSet",
"ZFSet.IsTransitive.subset_of_mem",
"ZFSet.mem_powerset",
"Membership.mem",
"Eq.mp",
... | rw [mem_powerset] at hy ⊢
exact h.subset_of_mem (hy hz) | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.SetTheory.ZFC.Ordinal | {
"line": 87,
"column": 2
} | {
"line": 88,
"column": 31
} | [
{
"pp": "x : ZFSet.{u}\nh : x.IsTransitive\ny : ZFSet.{u}\nhy : y ∈ x.powerset\nz : ZFSet.{u}\nhz : z ∈ y\n⊢ z ∈ x.powerset",
"usedConstants": [
"Eq.mpr",
"congrArg",
"ZFSet",
"ZFSet.IsTransitive.subset_of_mem",
"ZFSet.mem_powerset",
"Membership.mem",
"Eq.mp",
... | rw [mem_powerset] at hy ⊢
exact h.subset_of_mem (hy hz) | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.SetTheory.Ordinal.Notation | {
"line": 867,
"column": 25
} | {
"line": 867,
"column": 54
} | [
{
"pp": "a0 a' : ONote\nN0 : a0.NF\nNa' : a'.NF\nd : ω ∣ a'.repr\ne0 : a0.repr ≠ 0\nn : ℕ+\nNo : (a0.oadd n a').NF\nk : ℕ\nω0 : Ordinal.{0} := ω ^ a0.repr\nα' : Ordinal.{0} := ω0 * ↑↑n + a'.repr\nα0 : 0 < α'\nω00 : 0 < ω0 ^ ↑k\nh : a'.repr + ↑0 < ω ^ a0.repr\nR' : Ordinal.{0} := (opowAux 0 a0 (a0.oadd n a' * ↑0... | cases k <;> simp [R, opowAux] | Lean.Parser.Tactic.«_aux_Init_Tactics___macroRules_Lean_Parser_Tactic_tactic_<;>__1» | Lean.Parser.Tactic.«tactic_<;>_» |
Mathlib.Tactic.ComputeAsymptotics.Multiseries.Basis | {
"line": 146,
"column": 2
} | {
"line": 146,
"column": 47
} | [
{
"pp": "hd : ℝ → ℝ\ntl : Basis\nh : WellFormedBasis (hd :: tl)\nf : ℝ → ℝ\nhf : f ∈ tl\n⊢ (Real.log ∘ f) =o[atTop] (Real.log ∘ hd)",
"usedConstants": [
"Real",
"Tactic.ComputeAsymptotics.WellFormedBasis.eq_1",
"List.Pairwise",
"congrArg",
"Function.comp",
"Membership.mem... | rw [WellFormedBasis, List.pairwise_cons] at h | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.Tactic.ComputeAsymptotics.Multiseries.Monomial.Basic | {
"line": 129,
"column": 53
} | {
"line": 141,
"column": 36
} | [
{
"pp": "m : UnitMonomial\nbasis : Basis\nh_basis : WellFormedBasis basis\n⊢ m.inv.toFun basis =ᶠ[atTop] (m.toFun basis)⁻¹",
"usedConstants": [
"Eq.mpr",
"Real.instPow",
"List.zipWith",
"Real",
"DivInvMonoid.toInv",
"InvOneClass.toOne",
"HMul.hMul",
"DivisionC... | by
eta_expand
simp only [toFun, inv, Pi.inv_apply]
induction m generalizing basis with
| nil => simp
| cons exp exps ih =>
cases basis with
| nil => simp
| cons basis_hd basis_tl =>
apply ((h_basis.head_eventually_pos).and (ih (h_basis.tail))).mono
intro x ⟨h_pos, ih⟩
simp only [... | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Tactic.LinearCombinationPrime | {
"line": 135,
"column": 29
} | {
"line": 135,
"column": 66
} | [
{
"pp": "α : Type u_1\na a' b b' : α\ninst✝¹ : Ring α\ninst✝ : NoZeroDivisors α\nn : ℕ\np : a - b = 0\nH : (a' - b') ^ n - (a - b) = 0\n⊢ a' - b' = 0",
"usedConstants": [
"AddGroup.toSubtractionMonoid",
"AddGroupWithOne.toAddGroup",
"HSub.hSub",
"SubtractionMonoid.toSubNegZeroMonoid"... | apply eq_zero_of_pow_eq_zero (n := n) | Lean.Elab.Tactic.evalApply | Lean.Parser.Tactic.apply |
Mathlib.Tactic.ModCases | {
"line": 46,
"column": 10
} | {
"line": 46,
"column": 20
} | [
{
"pp": "case refine_2\np : Sort u_1\na : ℤ\nn : ℕ\nhn : Nat.ble 1 n = true\nH : OnModCases n a 0 p\nthis : 0 < ↑n\nnonneg : 0 ≤ a % ↑n\n⊢ a ≡ ↑(a % ↑n).toNat [ZMOD ↑n]",
"usedConstants": [
"Eq.mpr",
"congrArg",
"id",
"instHMod",
"Int",
"Int.ModEq.eq_1",
"Nat.cast",... | Int.ModEq, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Tactic.ModCases | {
"line": 46,
"column": 49
} | {
"line": 46,
"column": 58
} | [
{
"pp": "case refine_2\np : Sort u_1\na : ℤ\nn : ℕ\nhn : Nat.ble 1 n = true\nH : OnModCases n a 0 p\nthis : 0 < ↑n\nnonneg : 0 ≤ a % ↑n\n⊢ a % ↑n = a % ↑n % ↑n",
"usedConstants": [
"Eq.mpr",
"congrArg",
"id",
"instHMod",
"Int",
"Nat.cast",
"HMod.hMod",
"Int.em... | emod_emod | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Tactic.NormNum.IsSquare | {
"line": 70,
"column": 2
} | {
"line": 70,
"column": 25
} | [
{
"pp": "a : ℚ\nd : ℕ\nhd : IsSquare d\nn : ℕ\nha : IsNNRat a (n * n) d\n⊢ IsSquare a",
"usedConstants": []
}
] | rcases hd with ⟨d, rfl⟩ | _private.Lean.Elab.Tactic.RCases.0.Lean.Elab.Tactic.RCases.evalRCases | Lean.Parser.Tactic.rcases |
Mathlib.Tactic.NormNum.IsSquare | {
"line": 99,
"column": 24
} | {
"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⊢ -(↑n / ↑d) < 0",
"usedConstants": [
"AddGroup.toSubtractionMonoid",
"Rat.instOfNat",
"Eq.mpr",
"GroupWithZero.toMonoidWithZero",
"NegZeroClass.toNeg",
"NonA... | by rw [Left.neg_neg_iff]; apply div_pos <;> simpa [Nat.pos_iff_ne_zero] | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Tactic.PNatToNat | {
"line": 64,
"column": 2
} | {
"line": 64,
"column": 72
} | [
{
"pp": "case mk.mk\nval✝¹ : ℕ\nproperty✝¹ : 0 < val✝¹\nval✝ : ℕ\nproperty✝ : 0 < val✝\n⊢ ↑(⟨val✝¹, property✝¹⟩ - ⟨val✝, property✝⟩) = ↑⟨val✝¹, property✝¹⟩ - 1 - ↑⟨val✝, property✝⟩ + 1",
"usedConstants": [
"PNat.val",
"Eq.mpr",
"Preorder.toLT",
"instLinearOrderPNat",
"congrArg"... | simp only [PNat.mk_coe, _root_.PNat.sub_coe, ← _root_.PNat.coe_lt_coe] | Lean.Elab.Tactic.evalSimp | Lean.Parser.Tactic.simp |
Mathlib.Tactic.ReduceModChar | {
"line": 61,
"column": 4
} | {
"line": 61,
"column": 85
} | [
{
"pp": "α : Type u_1\ninst✝ : Semiring α\na✝ : α\na b n : ℕ\nx✝ : CharP α ↑n\nh : a✝ = ↑a\n⊢ a✝ ^ ↑b = ↑((a.pow b).mod n)",
"usedConstants": [
"Nat.pow_eq",
"instPowNat",
"Eq.mpr",
"NonAssocSemiring.toAddCommMonoidWithOne",
"CharP.natCast_eq_natCast_mod",
"Nat.cast_id",
... | rw [h, Nat.cast_id, Nat.pow_eq, ← Nat.cast_pow, CharP.natCast_eq_natCast_mod α n] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.Topology.Algebra.Group.SubmonoidClosure | {
"line": 105,
"column": 2
} | {
"line": 105,
"column": 75
} | [
{
"pp": "G : Type u_1\ninst✝³ : Group G\ninst✝² : TopologicalSpace G\ninst✝¹ : CompactSpace G\ninst✝ : IsTopologicalGroup G\ns : Set G\n⊢ (Subgroup.closure s).topologicalClosure = (Submonoid.closure s).topologicalClosure",
"usedConstants": [
"Subgroup.closure",
"Monoid.toMulOneClass",
"Mul... | refine le_antisymm ?_ (closure_mono <| Subgroup.le_closure_toSubmonoid _) | Lean.Elab.Tactic.evalRefine | Lean.Parser.Tactic.refine |
Mathlib.Topology.Compactness.DeltaGeneratedSpace | {
"line": 53,
"column": 73
} | {
"line": 53,
"column": 85
} | [
{
"pp": "X : Type u_1\ntX : TopologicalSpace X\nu : Set X\n⊢ (∀ (i : (n : ℕ) × C(Fin n → ℝ, X)), IsOpen (⇑i.snd ⁻¹' u)) ↔ ∀ (n : ℕ) (p : C(Fin n → ℝ, X)), IsOpen (⇑p ⁻¹' u)",
"usedConstants": [
"Real",
"Pi.topologicalSpace",
"congrArg",
"ContinuousMap",
"PseudoMetricSpace.toUni... | Sigma.forall | Mathlib.Tactic._aux_Mathlib_Tactic_SimpRw___elabRules_Mathlib_Tactic_tacticSimp_rw____1 | null |
Mathlib.Topology.Category.Profinite.Nobeling.Basic | {
"line": 135,
"column": 4
} | {
"line": 135,
"column": 22
} | [
{
"pp": "case h.refine_2\nI : Type u\nC : Set (I → Bool)\nJ K : I → Prop\ninst✝¹ : (i : I) → Decidable (J i)\ninst✝ : (i : I) → Decidable (K i)\nh : ∀ (i : I), J i → K i\ny : I → Bool\nhy : y ∈ C\n⊢ Proj J y ∈ Proj J ∘ Proj K '' C",
"usedConstants": [
"Function.comp",
"Membership.mem",
"Pr... | refine ⟨y, hy, ?_⟩ | Lean.Elab.Tactic.evalRefine | Lean.Parser.Tactic.refine |
Mathlib.Topology.Category.Profinite.Nobeling.Basic | {
"line": 175,
"column": 4
} | {
"line": 175,
"column": 22
} | [
{
"pp": "I : Type u\nC : Set (I → Bool)\nJ K L : I → Prop\ninst✝² : (i : I) → Decidable (J i)\ninst✝¹ : (i : I) → Decidable (K i)\ninst✝ : (i : I) → Decidable (L i)\ny : I → Bool\nhy : y ∈ C\n⊢ (fun i ↦ ↑⟨Proj J y, ⋯⟩ ↑i) ∈ IndexFunctor.obj C J",
"usedConstants": [
"Pi.topologicalSpace",
"Contin... | refine ⟨y, hy, ?_⟩ | Lean.Elab.Tactic.evalRefine | Lean.Parser.Tactic.refine |
Mathlib.Topology.Category.Profinite.Nobeling.ZeroLimit | {
"line": 67,
"column": 79
} | {
"line": 75,
"column": 5
} | [
{
"pp": "I : Type u_1\ninst✝ : LinearOrder I\n⊢ Submodule.span ℤ (eval {fun x ↦ false} '' {nil}) = ⊤",
"usedConstants": [
"Int.instAddCommGroup",
"Int.cast",
"Eq.mpr",
"Int.instAddCommMonoid",
"Inhabited.default",
"Submodule",
"zsmul_eq_mul",
"LocallyConstant.... | by
rw [Set.image_singleton, eq_top_iff]
intro f _
rw [Submodule.mem_span_singleton]
refine ⟨f default, ?_⟩
simp only [eval, List.map, List.prod_nil, zsmul_eq_mul, mul_one, Products.nil]
ext x
obtain rfl : x = default := by simp only [Set.default_coe_singleton, eq_iff_true_of_subsingleton]
rfl | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Topology.Category.Profinite.Nobeling.ZeroLimit | {
"line": 156,
"column": 2
} | {
"line": 158,
"column": 30
} | [
{
"pp": "case refine_1\nI : Type u\nC : Set (I → Bool)\ninst✝¹ : LinearOrder I\ninst✝ : WellFoundedLT I\no : Ordinal.{u}\na b : ↑(range (π C fun x ↦ ord I x < o))\nhab : (fun x ↦ ⟨(πs C o) ↑x, ⋯⟩) a = (fun x ↦ ⟨(πs C o) ↑x, ⋯⟩) b\n⊢ a = b",
"usedConstants": [
"Int.instAddCommGroup",
"Profinite.N... | · ext1
simp only [Subtype.mk.injEq] at hab
exact injective_πs C o hab | Lean.Elab.Tactic.evalTacticCDot | Lean.cdot |
Mathlib.Topology.CWComplex.Classical.Basic | {
"line": 937,
"column": 2
} | {
"line": 937,
"column": 57
} | [
{
"pp": "X : Type u_1\nt : TopologicalSpace X\nC D : Set X\ninst✝¹ : T2Space X\ninst✝ : RelCWComplex C D\nn : ℕ∞\nx : X\n⊢ (x ∈ D ∨ ∃ m, ∃ (_ : ↑m < n + 1), ∃ j, x ∈ openCell m j) ↔ x ∈ D ∨ ∃ m, ∃ (_ : ↑m ≤ n), ∃ j, x ∈ openCell m j",
"usedConstants": [
"instAddMonoidWithOneENat",
"ENat.instNatC... | suffices ∀ (m : ℕ), m < n + 1 ↔ m ≤ n by simp_rw [this] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_tacticSuffices__1 | Lean.Parser.Tactic.tacticSuffices_ |
Mathlib.Topology.Category.Profinite.Nobeling.Successor | {
"line": 203,
"column": 2
} | {
"line": 203,
"column": 13
} | [
{
"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\ny : LocallyConstant ↑(π C fun x ↦ ord I x < o) ℤ\nx : ↑(C' C ho)\ni : I\n⊢ ord I i < o → ord I i = o → true = ↑x i",
"usedCo... | intro h₁ h₂ | Lean.Elab.Tactic.evalIntro | Lean.Parser.Tactic.intro |
Mathlib.Topology.Category.Profinite.Nobeling.Successor | {
"line": 461,
"column": 12
} | {
"line": 461,
"column": 17
} | [
{
"pp": "case h\nI : 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\ninst✝ : Inhabited I\nl : Products I\nhl : ↑l ≠ []\nhlh : (↑l).head! = term I ho\nhlc : List.IsChain (fun x1 x2 ↦ x1 > x... | CC'₀, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Topology.Category.Profinite.Nobeling.Successor | {
"line": 477,
"column": 4
} | {
"line": 477,
"column": 98
} | [
{
"pp": "case pos\nI : 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\ninst✝ : Inhabited I\nl : Products I\nhl : ↑l ≠ []\nhlh : (↑l).head! = term I ho\nhlc : List.IsChain (fun x1 x2 ↦ x1 >... | push Not at h₁; obtain ⟨i, hi⟩ := h₁; exfalso; rw [← hi' i hi.1] at hi; exact hi.2 (h₃ i hi.1) | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Topology.Category.Profinite.Nobeling.Successor | {
"line": 477,
"column": 4
} | {
"line": 477,
"column": 98
} | [
{
"pp": "case pos\nI : 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\ninst✝ : Inhabited I\nl : Products I\nhl : ↑l ≠ []\nhlh : (↑l).head! = term I ho\nhlc : List.IsChain (fun x1 x2 ↦ x1 >... | push Not at h₁; obtain ⟨i, hi⟩ := h₁; exfalso; rw [← hi' i hi.1] at hi; exact hi.2 (h₃ i hi.1) | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Topology.Compactness.CountablyCompact | {
"line": 247,
"column": 54
} | {
"line": 251,
"column": 50
} | [
{
"pp": "ι : Type u_1\nE : Type u_2\nF : Type u_3\ninst✝³ : TopologicalSpace E\ninst✝² : TopologicalSpace F\nA✝ B : Set E\ninst✝¹ : SequentialSpace E\ninst✝ : CountablyCompactSpace E\nx : ℕ → E\nhx : ∀ (x_1 : E) (x_2 : ℕ → ℕ), StrictMono x_2 → ¬Tendsto (x ∘ x_2) atTop (𝓝 x_1)\nA : Set E := ⋃ i, closure[inst✝³]... | by
by_contra!
obtain ⟨φ, hφ1, hφ2⟩ := Nat.exists_strictMono_subsequence this
refine hx a φ hφ1 (tendsto_atTop_nhds.2 fun U ha hUo => ⟨0, fun n _ => ?_⟩)
simpa using mem_closure_iff.1 (hφ2 n) U hUo ha | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Topology.ContinuousMap.SecondCountableSpace | {
"line": 42,
"column": 10
} | {
"line": 42,
"column": 32
} | [
{
"pp": "X : 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 : IsCompact K\n... | hT.open_eq_sUnion' hU, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Topology.Filter | {
"line": 86,
"column": 2
} | {
"line": 86,
"column": 14
} | [
{
"pp": "ι : Sort u_1\nα : Type u_2\nl : Filter α\np : ι → Prop\ns : ι → Set α\nh : l.HasBasis p s\n⊢ (𝓝 l).HasBasis p fun i ↦ Iic (𝓟 (s i))",
"usedConstants": [
"Eq.mpr",
"congrArg",
"PartialOrder.toPreorder",
"Function.comp",
"nhds",
"id",
"Filter.nhds_eq",
... | rw [nhds_eq] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.Topology.Filter | {
"line": 92,
"column": 2
} | {
"line": 92,
"column": 48
} | [
{
"pp": "X : Type u_4\nl : Filter X\n⊢ ∀ s ∈ l, ∀ᶠ (a : X) in l, s ∈ pure a",
"usedConstants": [
"Pure.pure",
"Filter.instMembership",
"Membership.mem",
"id",
"Filter.Eventually.mono",
"Filter.instPure",
"Filter",
"Set"
]
}
] | exact fun s hs ↦ Eventually.mono hs fun x ↦ id | Lean.Elab.Tactic.evalExact | Lean.Parser.Tactic.exact |
Mathlib.Topology.Homotopy.HSpaces | {
"line": 172,
"column": 2
} | {
"line": 172,
"column": 49
} | [
{
"pp": "t : ↑I\n⊢ ↑(qRight (t, 0)) = if ↑t ≤ 1 / 2 then 2 * ↑t else 1",
"usedConstants": [
"Real.instIsOrderedRing",
"Eq.mpr",
"Set.projIcc.congr_simp",
"Real.partialOrder",
"Real.instLE",
"Real",
"instHDiv",
"HMul.hMul",
"DivisionCommMonoid.toDivisionM... | simp only [qRight, coe_zero, add_zero, div_one] | Lean.Elab.Tactic.evalSimp | Lean.Parser.Tactic.simp |
Mathlib.Topology.Instances.RatLemmas | {
"line": 62,
"column": 2
} | {
"line": 62,
"column": 28
} | [
{
"pp": "H : (cocompact ℚ).IsCountablyGenerated\nx : ℕ → ℚ\nhxc : Tendsto x atTop (cocompact ℚ)\nhx0 : Tendsto x atTop (𝓝 0)\nn : ℕ\nhn : x n ∉ insert 0 (range x)\n⊢ False",
"usedConstants": [
"Rat.instOfNat",
"Rat",
"Membership.mem",
"Nat",
"Exists.intro",
"Set.range",
... | exact hn (Or.inr ⟨n, rfl⟩) | Lean.Elab.Tactic.evalExact | Lean.Parser.Tactic.exact |
Mathlib.Topology.Maps.Proper.UniversallyClosed | {
"line": 104,
"column": 4
} | {
"line": 104,
"column": 48
} | [
{
"pp": "case mpr\nX : Type u\nY : Type v\ninst✝¹ : TopologicalSpace X\ninst✝ : TopologicalSpace Y\nf : X → Y\nH : Continuous f ∧ ∀ (Z : Type u) [inst : TopologicalSpace Z], IsClosedMap (Prod.map f id)\n⊢ IsProperMap f",
"usedConstants": [
"Eq.mpr",
"Continuous",
"congrArg",
"instTop... | rw [isProperMap_iff_isClosedMap_ultrafilter] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.Topology.EMetricSpace.PairReduction | {
"line": 437,
"column": 14
} | {
"line": 437,
"column": 25
} | [
{
"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 := ⋯\nl : ℕ := ⋯\nhsV : s ∈ (logSizeBall... | ← one_mul c | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Topology.MetricSpace.Kuratowski | {
"line": 91,
"column": 4
} | {
"line": 91,
"column": 38
} | [
{
"pp": "case inr\nα : Type u\ninst✝¹ : MetricSpace α\ninst✝ : SeparableSpace α\nbasepoint : α\nh✝ : basepoint ∈ univ\n⊢ ∃ f, Isometry f",
"usedConstants": [
"Inhabited.mk"
]
}
] | haveI : Inhabited α := ⟨basepoint⟩ | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_tacticHaveI___1 | Lean.Parser.Tactic.tacticHaveI__ |
Mathlib.Topology.Sets.VietorisTopology | {
"line": 216,
"column": 18
} | {
"line": 216,
"column": 70
} | [
{
"pp": "case left\nα : Type u_1\nβ : Type u_2\ninst✝¹ : TopologicalSpace α\ninst✝ : TopologicalSpace β\nf : α → β\nhf : Continuous[inst✝¹, inst✝] f\n⊢ ∀ (U : Set β), IsOpen[inst✝] U → IsOpen[TopologicalSpace.vietoris α] {a | a ⊆ f ⁻¹' U}",
"usedConstants": [
"Set.preimage",
"IsOpen.powerset_vie... | exact fun U hU => (hU.preimage hf).powerset_vietoris | Lean.Elab.Tactic.evalExact | Lean.Parser.Tactic.exact |
Mathlib.Topology.Sets.VietorisTopology | {
"line": 216,
"column": 18
} | {
"line": 216,
"column": 70
} | [
{
"pp": "case right\nα : Type u_1\nβ : Type u_2\ninst✝¹ : TopologicalSpace α\ninst✝ : TopologicalSpace β\nf : α → β\nhf : Continuous[inst✝¹, inst✝] f\n⊢ ∀ (F : Set β), IsClosed[inst✝] F → IsClosed[TopologicalSpace.vietoris α] {a | a ⊆ f ⁻¹' F}",
"usedConstants": [
"IsClosed",
"Set.preimage",
... | exact fun U hU => (hU.preimage hf).powerset_vietoris | Lean.Elab.Tactic.evalExact | Lean.Parser.Tactic.exact |
Mathlib.Topology.Sets.VietorisTopology | {
"line": 242,
"column": 2
} | {
"line": 242,
"column": 54
} | [
{
"pp": "α : Type u_1\ninst✝ : TopologicalSpace α\nK : Set α\nhK : IsCompact K\ns : Set (Set α)\nhsK : s ⊆ 𝒫 K\nhs : ∀ L ∈ s, IsCompact L\n⊢ IsCompact {t | t ⊆ K ∧ ∀ L ∈ s, (t ∩ L).Nonempty}",
"usedConstants": [
"isCompact_generateFrom",
"setOf",
"Set.sUnion",
"Set.powerset",
... | refine isCompact_generateFrom rfl fun S hS hKS => ?_ | Lean.Elab.Tactic.evalRefine | Lean.Parser.Tactic.refine |
Mathlib.Topology.MetricSpace.GromovHausdorff | {
"line": 115,
"column": 61
} | {
"line": 115,
"column": 67
} | [
{
"pp": "X : Type u\ninst✝² : MetricSpace X\ninst✝¹ : CompactSpace X\ninst✝ : Nonempty X\np : NonemptyCompacts ↥(lp (fun n ↦ ℝ) ∞)\nΨ : X → ↥(lp (fun n ↦ ℝ) ∞)\nisomΨ : Isometry Ψ\nrangeΨ : range Ψ = ↑p\nf : ↑(range Ψ) ≃ᵢ ↑(range (kuratowskiEmbedding X))\n⊢ (↑(range Ψ) ≃ᵢ ↥{ carrier := range (kuratowskiEmbeddin... | rangeΨ | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Topology.Sets.VietorisTopology | {
"line": 374,
"column": 4
} | {
"line": 374,
"column": 48
} | [
{
"pp": "case refine_2\nα : Type u_1\ninst✝ : TopologicalSpace α\nB : Set (Set α)\nhB : IsTopologicalBasis B\nV : Set α\nu : Set (Set α)\nhV : IsOpen[inst✝] V\nhu : u.Finite\nhuB : u ⊆ B\nhuV : ∀ U ∈ u, U ⊆ V\nK : Compacts α\nhKV : ↑K ⊆ V\nhKu : ∀ U ∈ u, (↑K ∩ U).Nonempty\n⊢ ∃ v ∈ (fun u ↦ {K | ↑K ⊆ ⋃₀ u ∧ ∀ U ... | obtain ⟨w, hwB, hwV⟩ := hB.open_eq_sUnion hV | _private.Lean.Elab.Tactic.RCases.0.Lean.Elab.Tactic.RCases.evalObtain | Lean.Parser.Tactic.obtain |
Mathlib.Topology.Sets.VietorisTopology | {
"line": 500,
"column": 2
} | {
"line": 520,
"column": 48
} | [
{
"pp": "α : Type u_1\nβ : Type u_2\ninst✝² : TopologicalSpace α\ninst✝¹ : TopologicalSpace β\nf : α → β\ninst✝ : RegularSpace α\n⊢ RegularSpace (Compacts α)",
"usedConstants": [
"Filter.instMembership",
"Iff.mpr",
"Set.mem_singleton",
"Set.image_image",
"Eq.mpr",
"_priva... | simp_rw [regularSpace_generateFrom induced_generateFrom_eq, image_union, image_image, powerset,
preimage_setOf_eq, Filter.disjoint_iff]
rintro _ (⟨U, hU, rfl⟩ | ⟨U, hU, rfl⟩) K hK
· obtain ⟨V, W, hV, hW, hKV, hUW, hVW⟩ :=
SeparatedNhds.of_isCompact_isClosed K.isCompact hU.isClosed_compl
(disjoint_... | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Topology.Sets.VietorisTopology | {
"line": 500,
"column": 2
} | {
"line": 520,
"column": 48
} | [
{
"pp": "α : Type u_1\nβ : Type u_2\ninst✝² : TopologicalSpace α\ninst✝¹ : TopologicalSpace β\nf : α → β\ninst✝ : RegularSpace α\n⊢ RegularSpace (Compacts α)",
"usedConstants": [
"Filter.instMembership",
"Iff.mpr",
"Set.mem_singleton",
"Set.image_image",
"Eq.mpr",
"_priva... | simp_rw [regularSpace_generateFrom induced_generateFrom_eq, image_union, image_image, powerset,
preimage_setOf_eq, Filter.disjoint_iff]
rintro _ (⟨U, hU, rfl⟩ | ⟨U, hU, rfl⟩) K hK
· obtain ⟨V, W, hV, hW, hKV, hUW, hVW⟩ :=
SeparatedNhds.of_isCompact_isClosed K.isCompact hU.isClosed_compl
(disjoint_... | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Topology.MetricSpace.HausdorffDimension | {
"line": 152,
"column": 2
} | {
"line": 161,
"column": 37
} | [
{
"pp": "X : Type u_2\ninst✝² : EMetricSpace X\ninst✝¹ : MeasurableSpace X\ninst✝ : BorelSpace X\ns : Set X\n⊢ dimH s = ⨅ d, ⨅ (_ : μH[↑d] s = 0), ↑d",
"usedConstants": [
"ENNReal.instCanonicallyOrderedAdd",
"Eq.mpr",
"False",
"Real.instLE",
"Real",
"ENNReal.ofNNReal",
... | apply le_antisymm
· rw [dimH_def]
simp only [le_iInf_iff, iSup_le_iff, ENNReal.coe_le_coe]
intro i hi j hj
by_contra! hij
simpa [hi, hj] using hausdorffMeasure_mono hij.le s
· by_contra! h
rcases ENNReal.lt_iff_exists_nnreal_btwn.1 h with ⟨d', hdim_lt, hlt⟩
have h0 : μH[d'] s = 0 := hausdorf... | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Topology.MetricSpace.HausdorffDimension | {
"line": 152,
"column": 2
} | {
"line": 161,
"column": 37
} | [
{
"pp": "X : Type u_2\ninst✝² : EMetricSpace X\ninst✝¹ : MeasurableSpace X\ninst✝ : BorelSpace X\ns : Set X\n⊢ dimH s = ⨅ d, ⨅ (_ : μH[↑d] s = 0), ↑d",
"usedConstants": [
"ENNReal.instCanonicallyOrderedAdd",
"Eq.mpr",
"False",
"Real.instLE",
"Real",
"ENNReal.ofNNReal",
... | apply le_antisymm
· rw [dimH_def]
simp only [le_iInf_iff, iSup_le_iff, ENNReal.coe_le_coe]
intro i hi j hj
by_contra! hij
simpa [hi, hj] using hausdorffMeasure_mono hij.le s
· by_contra! h
rcases ENNReal.lt_iff_exists_nnreal_btwn.1 h with ⟨d', hdim_lt, hlt⟩
have h0 : μH[d'] s = 0 := hausdorf... | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Topology.MetricSpace.GromovHausdorff | {
"line": 310,
"column": 40
} | {
"line": 310,
"column": 60
} | [
{
"pp": "case inl.a\nX : Type u\ninst✝⁵ : MetricSpace X\ninst✝⁴ : CompactSpace X\ninst✝³ : Nonempty X\nY : Type v\ninst✝² : MetricSpace Y\ninst✝¹ : CompactSpace Y\ninst✝ : Nonempty Y\ninhabited_h✝ : Inhabited X\ninhabited_h : Inhabited Y\np q : NonemptyCompacts ↥(lp (fun n ↦ ℝ) ∞)\nhp : ⟦p⟧ = toGHSpace X\nhq : ... | apply mem_range_self | Lean.Elab.Tactic.evalApply | Lean.Parser.Tactic.apply |
Mathlib.Topology.MetricSpace.GromovHausdorff | {
"line": 311,
"column": 41
} | {
"line": 311,
"column": 61
} | [
{
"pp": "case inr.a\nX : Type u\ninst✝⁵ : MetricSpace X\ninst✝⁴ : CompactSpace X\ninst✝³ : Nonempty X\nY : Type v\ninst✝² : MetricSpace Y\ninst✝¹ : CompactSpace Y\ninst✝ : Nonempty Y\ninhabited_h✝ : Inhabited X\ninhabited_h : Inhabited Y\np q : NonemptyCompacts ↥(lp (fun n ↦ ℝ) ∞)\nhp : ⟦p⟧ = toGHSpace X\nhq : ... | apply mem_range_self | Lean.Elab.Tactic.evalApply | Lean.Parser.Tactic.apply |
Mathlib.Topology.Sets.VietorisTopology | {
"line": 715,
"column": 80
} | {
"line": 717,
"column": 10
} | [
{
"pp": "α : Type u_1\nβ : Type u_2\ninst✝¹ : TopologicalSpace α\ninst✝ : TopologicalSpace β\n⊢ Continuous fun p ↦ p.1 ×ˢ p.2",
"usedConstants": [
"Continuous.comp'",
"Eq.mpr",
"Continuous",
"TopologicalSpace.NonemptyCompacts.toCompacts",
"TopologicalSpace.NonemptyCompacts",
... | by
simp_rw [isEmbedding_toCompacts.continuous_iff, Function.comp_def, toCompacts_prod]
fun_prop | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Topology.MetricSpace.HausdorffDimension | {
"line": 511,
"column": 2
} | {
"line": 511,
"column": 35
} | [
{
"pp": "E : Type u_4\ninst✝⁴ : NormedAddCommGroup E\ninst✝³ : NormedSpace ℝ E\ninst✝² : FiniteDimensional ℝ E\ninst✝¹ : MeasurableSpace E\ninst✝ : BorelSpace E\nd : ℝ≥0\nhd : ↑(finrank ℝ E) < ↑d\n⊢ μH[↑d] univ = 0",
"usedConstants": [
"NormedAddCommGroup.toMetricSpace",
"Set.univ",
"hausd... | apply hausdorffMeasure_of_dimH_lt | Lean.Elab.Tactic.evalApply | Lean.Parser.Tactic.apply |
Mathlib.Topology.MetricSpace.HolderNorm | {
"line": 251,
"column": 2
} | {
"line": 251,
"column": 25
} | [
{
"pp": "X : Type u_1\nY : Type u_2\ninst✝¹ : MetricSpace X\ninst✝ : EMetricSpace Y\nC r : ℝ≥0\nf : X → Y\nhf : HolderWith C r f\n⊢ eHolderNorm r f ≤ ↑C",
"usedConstants": [
"EMetricSpace.toPseudoEMetricSpace",
"MetricSpace.toEMetricSpace",
"HolderWith.eHolderNorm_le"
]
}
] | exact hf.eHolderNorm_le | Lean.Elab.Tactic.evalExact | Lean.Parser.Tactic.exact |
Mathlib.Topology.MetricSpace.Infsep | {
"line": 160,
"column": 55
} | {
"line": 166,
"column": 54
} | [
{
"pp": "α : Type u_1\ninst✝¹ : EDist α\ns : Set α\ninst✝ : Finite ↑s\nhs : s.Nontrivial\n⊢ ∃ x ∈ s, ∃ y ∈ s, x ≠ y ∧ s.einfsep = edist x y",
"usedConstants": [
"Finset.exists_mem_eq_inf",
"Eq.mpr",
"Set.einfsep_of_fintype",
"congrArg",
"Finset",
"Set.offDiag",
"Mem... | by
classical
cases nonempty_fintype s
simp_rw [einfsep_of_fintype]
rcases Finset.exists_mem_eq_inf s.offDiag.toFinset (by simpa) (uncurry edist) with ⟨w, hxy, hed⟩
simp_rw [mem_toFinset] at hxy
exact ⟨w.fst, hxy.1, w.snd, hxy.2.1, hxy.2.2, hed⟩ | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Topology.MetricSpace.Infsep | {
"line": 418,
"column": 2
} | {
"line": 422,
"column": 58
} | [
{
"pp": "α : Type u_1\ninst✝ : PseudoMetricSpace α\ns : Finset α\n⊢ (↑s).infsep = if hs : s.offDiag.Nonempty then s.offDiag.inf' hs (uncurry dist) else 0",
"usedConstants": [
"Iff.mpr",
"Eq.mpr",
"PseudoEMetricSpace.toWeakPseudoEMetricSpace",
"Set.offDiag_nonempty",
"Real",
... | have H : (s : Set α).Nontrivial ↔ s.offDiag.Nonempty := by
rw [← Set.offDiag_nonempty, ← Finset.coe_offDiag, Finset.coe_nonempty]
split_ifs with hs
· classical simp_rw [(H.mpr hs).infsep_of_fintype, ← Finset.coe_offDiag, Finset.toFinset_coe]
· exact (not_nontrivial_iff.mp (H.mp.mt hs)).infsep_zero | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Topology.MetricSpace.Infsep | {
"line": 418,
"column": 2
} | {
"line": 422,
"column": 58
} | [
{
"pp": "α : Type u_1\ninst✝ : PseudoMetricSpace α\ns : Finset α\n⊢ (↑s).infsep = if hs : s.offDiag.Nonempty then s.offDiag.inf' hs (uncurry dist) else 0",
"usedConstants": [
"Iff.mpr",
"Eq.mpr",
"PseudoEMetricSpace.toWeakPseudoEMetricSpace",
"Set.offDiag_nonempty",
"Real",
... | have H : (s : Set α).Nontrivial ↔ s.offDiag.Nonempty := by
rw [← Set.offDiag_nonempty, ← Finset.coe_offDiag, Finset.coe_nonempty]
split_ifs with hs
· classical simp_rw [(H.mpr hs).infsep_of_fintype, ← Finset.coe_offDiag, Finset.toFinset_coe]
· exact (not_nontrivial_iff.mp (H.mp.mt hs)).infsep_zero | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Topology.MetricSpace.Infsep | {
"line": 459,
"column": 2
} | {
"line": 460,
"column": 38
} | [
{
"pp": "α : Type u_1\ninst✝¹ : MetricSpace α\ns : Set α\ninst✝ : Finite ↑s\n⊢ 0 < s.infsep ↔ s.Nontrivial",
"usedConstants": [
"Eq.mpr",
"PseudoEMetricSpace.toWeakPseudoEMetricSpace",
"Real",
"Preorder.toLT",
"Set.einfsep_lt_top_iff",
"Real.instZero",
"congrArg",
... | rw [infsep_pos, einfsep_lt_top_iff, and_iff_right_iff_imp]
exact fun _ => einfsep_pos_of_finite | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Topology.MetricSpace.Infsep | {
"line": 459,
"column": 2
} | {
"line": 460,
"column": 38
} | [
{
"pp": "α : Type u_1\ninst✝¹ : MetricSpace α\ns : Set α\ninst✝ : Finite ↑s\n⊢ 0 < s.infsep ↔ s.Nontrivial",
"usedConstants": [
"Eq.mpr",
"PseudoEMetricSpace.toWeakPseudoEMetricSpace",
"Real",
"Preorder.toLT",
"Set.einfsep_lt_top_iff",
"Real.instZero",
"congrArg",
... | rw [infsep_pos, einfsep_lt_top_iff, and_iff_right_iff_imp]
exact fun _ => einfsep_pos_of_finite | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Topology.MetricSpace.GromovHausdorff | {
"line": 765,
"column": 6
} | {
"line": 765,
"column": 35
} | [
{
"pp": "case neg\nt : Set GHSpace\nC : ℝ\nu : ℕ → ℝ\nK : ℕ → ℕ\nulim : Tendsto u atTop (𝓝 0)\nhdiam : ∀ p ∈ t, diam univ ≤ C\nhcov : ∀ p ∈ t, ∀ (n : ℕ), ∃ s, #↑s ≤ ↑(K n) ∧ univ ⊆ ⋃ x ∈ s, ball x (u n)\nδ : ℝ\nδpos : δ > 0\nε : ℝ := 1 / 5 * δ\nεpos : 0 < ε\nn : ℕ\nhn : ∀ n_1 ≥ n, dist (u n_1) 0 < ε\nu_le_ε : ... | rw [hN, Nat.cast_le] at scard | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.Topology.MetricSpace.GromovHausdorff | {
"line": 763,
"column": 4
} | {
"line": 769,
"column": 38
} | [
{
"pp": "case neg\nt : Set GHSpace\nC : ℝ\nu : ℕ → ℝ\nK : ℕ → ℕ\nulim : Tendsto u atTop (𝓝 0)\nhdiam : ∀ p ∈ t, diam univ ≤ C\nhcov : ∀ p ∈ t, ∀ (n : ℕ), ∃ s, #↑s ≤ ↑(K n) ∧ univ ⊆ ⋃ x ∈ s, ball x (u n)\nδ : ℝ\nδpos : δ > 0\nε : ℝ := 1 / 5 * δ\nεpos : 0 < ε\nn : ℕ\nhn : ∀ n_1 ≥ n, dist (u n_1) 0 < ε\nu_le_ε : ... | · rcases hcov _ (Set.not_notMem.1 hp) n with ⟨s, ⟨scard, scover⟩⟩
rcases Cardinal.lt_aleph0.1 (scard.trans_lt Cardinal.natCast_lt_aleph0) with ⟨N, hN⟩
rw [hN, Nat.cast_le] at scard
have : #s = #(Fin N) := by rw [hN, Cardinal.mk_fin]
obtain ⟨E⟩ := Quotient.exact this
use s, N, scard, E
... | Lean.Elab.Tactic.evalTacticCDot | Lean.cdot |
Mathlib.Topology.Order.LawsonTopology | {
"line": 206,
"column": 44
} | {
"line": 206,
"column": 77
} | [
{
"pp": "α : Type u_1\ninst✝² : Preorder α\nL S : TopologicalSpace α\ninst✝¹ : IsLawson α\ninst✝ : IsScott α univ\ns : Set α\nh : IsUpperSet s\n⊢ IsOpen[lawson α] s ↔ IsOpen[S] s",
"usedConstants": [
"Eq.mpr",
"Topology.IsScott.topology_eq",
"congrArg",
"Set.univ",
"id",
... | @IsScott.topology_eq α univ _ S _ | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Topology.Partial | {
"line": 65,
"column": 2
} | {
"line": 65,
"column": 22
} | [
{
"pp": "case mpr\nX : Type u_1\nY : Type u_2\ninst✝¹ : TopologicalSpace X\ninst✝ : TopologicalSpace Y\nf : X →. Y\nhf : ∀ {x : X} {y : Y}, y ∈ f x → PTendsto' f (𝓝 x) (𝓝 y)\ns : Set Y\nos : IsOpen[inst✝] s\n⊢ IsOpen[inst✝¹] (f.preimage s)",
"usedConstants": [
"Eq.mpr",
"congrArg",
"Part... | rw [isOpen_iff_nhds] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.Topology.Sheaves.Skyscraper | {
"line": 164,
"column": 16
} | {
"line": 167,
"column": 23
} | [
{
"pp": "X : TopCat\np₀ : ↑X\ninst✝² : (U : Opens ↑X) → Decidable (p₀ ∈ U)\nC : Type v\ninst✝¹ : Category.{u, v} C\nA : C\ninst✝ : HasTerminal C\ny : ↑X\nh✝ : p₀ ⤳ y\nc : Cocone ((OpenNhds.inclusion y).op ⋙ skyscraperPresheaf p₀ A)\nf : (skyscraperPresheafCoconeOfSpecializes p₀ A h✝).pt ⟶ c.pt\nh : ∀ (j : (Open... | by
dsimp
rw [← h, skyscraperPresheafCoconeOfSpecializes_ι_app, eqToHom_trans_assoc, eqToHom_refl,
Category.id_comp] | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Topology.Sheaves.EtaleSpace | {
"line": 122,
"column": 22
} | {
"line": 131,
"column": 86
} | [
{
"pp": "X : TopCat\nC : Type u\ninst✝⁴ : Category.{v, u} C\nCC : C → Type v\nFC : C → C → Type w\ninst✝³ : (X Y : C) → FunLike (FC X Y) (CC X) (CC Y)\ninst✝² : ConcreteCategory C FC\ninst✝¹ : Limits.HasColimits C\nF : Presheaf C X\ninst✝ : Limits.PreservesFilteredColimits (forget C)\nU : Opens ↑X\nhF_bij : ∀ (... | by
refine .prodMk (by fun_prop) ?_
simp_rw [continuous_iff_continuousAt, ContinuousAt, nhds_discrete, tendsto_pure, nhds_subtype,
eventually_comap]
rintro ⟨g, hg⟩
rcases hF_bij _ hg |>.surjective g.germ with ⟨f, hf⟩
filter_upwards [g.eventually_nhds hg f hf]
rintro _ ⟨hgU, hgf⟩ g' rfl
... | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Topology.Spectral.ConstructibleTopology | {
"line": 138,
"column": 4
} | {
"line": 140,
"column": 81
} | [
{
"pp": "case neg\nX : Type u_1\ninst✝⁴ : TopologicalSpace X\ninst✝³ : CompactSpace X\ninst✝² : QuasiSober X\ninst✝¹ : PrespectralSpace X\ninst✝ : QuasiSeparatedSpace X\n𝔅 : Set (Set X) := constructibleTopologySubbasis X\n𝒮 : Set (Set (Set X)) := {P | P ⊆ 𝔅 ∧ (∀ Q ⊆ P, Q.Finite → (⋂₀ Q).Nonempty) ∧ ⋂₀ P = ∅}... | have hY₂B : insert Y₂ B ∉ 𝒮 := by
intro hY₂B
grind [show insert Y₂ B ⊆ B from hB.le_of_ge hY₂B (Set.subset_insert Y₂ B)] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_tacticHave___1 | Lean.Parser.Tactic.tacticHave__ |
Mathlib.Topology.Sion | {
"line": 345,
"column": 4
} | {
"line": 351,
"column": 40
} | [
{
"pp": "case a.a\nE : Type u_1\nF : Type u_2\nβ : Type u_3\ninst✝¹¹ : LinearOrder β\nX : Set E\nY : Set F\nf : E → F → β\ninst✝¹⁰ : TopologicalSpace E\ninst✝⁹ : AddCommGroup E\ninst✝⁸ : Module ℝ E\ninst✝⁷ : IsTopologicalAddGroup E\ninst✝⁶ : ContinuousSMul ℝ E\nne_X : X.Nonempty\nkX : IsCompact X\nhfy : ∀ y ∈ Y... | rw [le_isGLB_iff hinf_sup, mem_lowerBounds]
rintro _ ⟨x, hx, rfl⟩
rw [isLUB_le_iff hsup_inf, mem_upperBounds]
rintro _ ⟨y, hy, rfl⟩
trans f x y
· exact (hinf_x y hy).1 ⟨x, hx, rfl⟩
· exact (hsup_y x hx).1 ⟨y, hy, rfl⟩ | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Topology.Sion | {
"line": 345,
"column": 4
} | {
"line": 351,
"column": 40
} | [
{
"pp": "case a.a\nE : Type u_1\nF : Type u_2\nβ : Type u_3\ninst✝¹¹ : LinearOrder β\nX : Set E\nY : Set F\nf : E → F → β\ninst✝¹⁰ : TopologicalSpace E\ninst✝⁹ : AddCommGroup E\ninst✝⁸ : Module ℝ E\ninst✝⁷ : IsTopologicalAddGroup E\ninst✝⁶ : ContinuousSMul ℝ E\nne_X : X.Nonempty\nkX : IsCompact X\nhfy : ∀ y ∈ Y... | rw [le_isGLB_iff hinf_sup, mem_lowerBounds]
rintro _ ⟨x, hx, rfl⟩
rw [isLUB_le_iff hsup_inf, mem_upperBounds]
rintro _ ⟨y, hy, rfl⟩
trans f x y
· exact (hinf_x y hy).1 ⟨x, hx, rfl⟩
· exact (hsup_y x hx).1 ⟨y, hy, rfl⟩ | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Topology.UniformSpace.Ultra.Completion | {
"line": 44,
"column": 2
} | {
"line": 44,
"column": 52
} | [
{
"pp": "case h_trans\nX : Type u_1\nY : Type u_2\ninst✝² : UniformSpace X\ninst✝¹ : UniformSpace Y\ninst✝ : IsUltraUniformity X\n⊢ ∀ (i : SetRel X X), i ∈ 𝓤 X ∧ i.IsSymm ∧ i.IsTrans → SetRel.IsTrans ((CauchyFilter.gen ∘ id) i)",
"usedConstants": [
"Filter.instMembership",
"CauchyFilter.isTrans... | · exact fun _ ⟨_, _, hU⟩ ↦ by simp; infer_instance | Lean.Elab.Tactic.evalTacticCDot | Lean.cdot |
Mathlib.Data.Nat.BinaryRec | {
"line": 195,
"column": 46
} | {
"line": 195,
"column": 56
} | [
{
"pp": "motive : Nat → Sort u\nzero : motive 0\nbit : (b : Bool) → (n : Nat) → (n = 0 → b = true) → motive n → motive (Nat.bit b n)\nb : Bool\nn : Nat\nh : n = 0 → b = true\n⊢ (if h : n = 0 → b = true then\n bit b n h\n (binaryRec zero\n (fun b n ih ↦\n if h : n = 0 → b = true t... | dif_pos h, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Algebra.Group.Semiconj.Defs | {
"line": 115,
"column": 2
} | {
"line": 121,
"column": 24
} | [
{
"pp": "M : Type u_2\ninst✝ : Monoid M\na x y : M\nh : SemiconjBy a x y\nn : ℕ\n⊢ SemiconjBy a (x ^ n) (y ^ n)",
"usedConstants": [
"Eq.mpr",
"MulOne.toOne",
"Nat.recAux",
"HMul.hMul",
"Monoid.toMulOneClass",
"congrArg",
"pow_succ",
"SemiconjBy",
"id",
... | induction n with
| zero =>
rw [pow_zero, pow_zero]
exact SemiconjBy.one_right _
| succ n ih =>
rw [pow_succ, pow_succ]
exact ih.mul_right h | _private.Lean.Elab.Tactic.Induction.0.Lean.Elab.Tactic.evalInduction | Lean.Parser.Tactic.induction |
Mathlib.Algebra.Group.Semiconj.Defs | {
"line": 115,
"column": 2
} | {
"line": 121,
"column": 24
} | [
{
"pp": "M : Type u_2\ninst✝ : Monoid M\na x y : M\nh : SemiconjBy a x y\nn : ℕ\n⊢ SemiconjBy a (x ^ n) (y ^ n)",
"usedConstants": [
"Eq.mpr",
"MulOne.toOne",
"Nat.recAux",
"HMul.hMul",
"Monoid.toMulOneClass",
"congrArg",
"pow_succ",
"SemiconjBy",
"id",
... | induction n with
| zero =>
rw [pow_zero, pow_zero]
exact SemiconjBy.one_right _
| succ n ih =>
rw [pow_succ, pow_succ]
exact ih.mul_right h | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Algebra.Group.Semiconj.Defs | {
"line": 115,
"column": 2
} | {
"line": 121,
"column": 24
} | [
{
"pp": "M : Type u_2\ninst✝ : Monoid M\na x y : M\nh : SemiconjBy a x y\nn : ℕ\n⊢ SemiconjBy a (x ^ n) (y ^ n)",
"usedConstants": [
"Eq.mpr",
"MulOne.toOne",
"Nat.recAux",
"HMul.hMul",
"Monoid.toMulOneClass",
"congrArg",
"pow_succ",
"SemiconjBy",
"id",
... | induction n with
| zero =>
rw [pow_zero, pow_zero]
exact SemiconjBy.one_right _
| succ n ih =>
rw [pow_succ, pow_succ]
exact ih.mul_right h | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Algebra.Group.Defs | {
"line": 588,
"column": 2
} | {
"line": 588,
"column": 31
} | [
{
"pp": "M : Type u_2\ninst✝¹ : Semigroup M\ninst✝ : One M\nk : ℕ\nm n : M\nk' : ℕ\nhk : k + 1 = k'\n⊢ Nat.binaryRec (motive := fun x ↦ M → M → M) (fun y x ↦ y) (fun bn _n fn y x ↦ fn (bif bn then y * x else y) (x * x))\n k' m n =\n m * npowRec' k' n",
"usedConstants": [
"Ne",
"instOfNat... | replace hk : k' ≠ 0 := by lia | Lean.Elab.Tactic.evalReplace | Lean.Parser.Tactic.replace |
Mathlib.Algebra.Group.Defs | {
"line": 589,
"column": 2
} | {
"line": 596,
"column": 46
} | [
{
"pp": "M : Type u_2\ninst✝¹ : Semigroup M\ninst✝ : One M\nk : ℕ\nm n : M\nk' : ℕ\nhk : k' ≠ 0\n⊢ Nat.binaryRec (motive := fun x ↦ M → M → M) (fun y x ↦ y) (fun bn _n fn y x ↦ fn (bif bn then y * x else y) (x * x))\n k' m n =\n m * npowRec' k' n",
"usedConstants": [
"cond",
"Nat.bit",
... | induction k' using Nat.binaryRecFromOne generalizing n m with
| zero => simp at hk
| one => simp [npowRec']
| bit b k' k'0 ih =>
rw [Nat.binaryRec_eq _ _ (Or.inl rfl), ih _ _ k'0]
cases b <;> simp only [Nat.bit, cond_false, cond_true, npowRec'_two_mul]
rw [npowRec'_succ (by lia), npowRec'_two_mul, ← n... | _private.Lean.Elab.Tactic.Induction.0.Lean.Elab.Tactic.evalInduction | Lean.Parser.Tactic.induction |
Mathlib.Algebra.Group.Defs | {
"line": 634,
"column": 2
} | {
"line": 635,
"column": 5
} | [
{
"pp": "M : Type u_2\ninst✝¹ : Semigroup M\ninst✝ : One M\nn : ℕ\nm : M\n⊢ npowBinRec (n + 1) m = npowBinRec n m * m",
"usedConstants": [
"Semigroup",
"Eq.mpr",
"Semigroup.toMul",
"One",
"HMul.hMul",
"congrArg",
"npowRec_eq_npowBinRec",
"id",
"npowRecAu... | iterate 2 rw [← npowBinRecAuto, ← npowRec_eq_npowBinRec]
rfl | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Algebra.Group.Defs | {
"line": 634,
"column": 2
} | {
"line": 635,
"column": 5
} | [
{
"pp": "M : Type u_2\ninst✝¹ : Semigroup M\ninst✝ : One M\nn : ℕ\nm : M\n⊢ npowBinRec (n + 1) m = npowBinRec n m * m",
"usedConstants": [
"Semigroup",
"Eq.mpr",
"Semigroup.toMul",
"One",
"HMul.hMul",
"congrArg",
"npowRec_eq_npowBinRec",
"id",
"npowRecAu... | iterate 2 rw [← npowBinRecAuto, ← npowRec_eq_npowBinRec]
rfl | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Logic.Function.Basic | {
"line": 1155,
"column": 87
} | {
"line": 1157,
"column": 40
} | [
{
"pp": "α β : Sort u_3\nh : α = β\n⊢ Bijective h.mpr",
"usedConstants": [
"Eq.mpr",
"HEq.refl",
"Eq.casesOn",
"id",
"And.intro",
"Exists.intro",
"eq_of_heq",
"Eq.ndrec",
"Function.Bijective",
"Eq.refl",
"HEq",
"Function.Injective",
... | by
cases h
exact ⟨fun _ _ ↦ id, fun x ↦ ⟨x, rfl⟩⟩ | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Logic.Function.Basic | {
"line": 1159,
"column": 83
} | {
"line": 1161,
"column": 40
} | [
{
"pp": "α β : Sort u_3\nh : α = β\n⊢ Bijective (cast h)",
"usedConstants": [
"HEq.refl",
"cast",
"Eq.casesOn",
"id",
"And.intro",
"Exists.intro",
"eq_of_heq",
"Eq.ndrec",
"Function.Bijective",
"Eq.refl",
"HEq",
"Function.Injective",
... | by
cases h
exact ⟨fun _ _ ↦ id, fun x ↦ ⟨x, rfl⟩⟩ | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Logic.Relation | {
"line": 529,
"column": 2
} | {
"line": 531,
"column": 34
} | [
{
"pp": "case tail\nα : Sort u_1\nr : α → α → Prop\nb✝ a b c : α\na✝ : TransGen r a b\nhbc : r b c\nh_ih :\n ∀ {motive : (a : α) → TransGen r a b → Prop},\n (∀ {a : α} (h : r a b), motive a ⋯) →\n (∀ {a c : α} (h' : r a c) (h : TransGen r c b), motive c h → motive a ⋯) → motive a a✝\nmotive : (a : α) →... | apply h_ih
· exact fun h ↦ head h (.single hbc) (single hbc)
· exact fun hab hbc ↦ head hab _ | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Logic.Relation | {
"line": 529,
"column": 2
} | {
"line": 531,
"column": 34
} | [
{
"pp": "case tail\nα : Sort u_1\nr : α → α → Prop\nb✝ a b c : α\na✝ : TransGen r a b\nhbc : r b c\nh_ih :\n ∀ {motive : (a : α) → TransGen r a b → Prop},\n (∀ {a : α} (h : r a b), motive a ⋯) →\n (∀ {a c : α} (h' : r a c) (h : TransGen r c b), motive c h → motive a ⋯) → motive a a✝\nmotive : (a : α) →... | apply h_ih
· exact fun h ↦ head h (.single hbc) (single hbc)
· exact fun hab hbc ↦ head hab _ | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Data.Quot | {
"line": 388,
"column": 6
} | {
"line": 388,
"column": 23
} | [
{
"pp": "α : Sort u_1\ns : Setoid α\nx : α\ny : Quotient s\n⊢ ⟦x⟧ = y ↔ ⟦x⟧ = ⟦y.out⟧",
"usedConstants": [
"Eq.mpr",
"congrArg",
"id",
"Quotient.out",
"Quotient.mk",
"Iff",
"Quotient",
"Quotient.out_eq",
"Eq"
]
}
] | Quotient.out_eq y | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Order.Defs.LinearOrder | {
"line": 166,
"column": 2
} | {
"line": 167,
"column": 26
} | [
{
"pp": "α : Type u_1\ninst✝ : LinearOrder α\na b c : α\nh₁ : c ≤ a\nh₂ : c ≤ b\n⊢ c ≤ min a b",
"usedConstants": [
"Eq.mpr",
"congrArg",
"PartialOrder.toPreorder",
"Preorder.toLE",
"LinearOrder.toDecidableLE",
"id",
"LE.le",
"if_pos",
"dite",
"min... | rw [min_def]
split_ifs <;> assumption | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Order.Defs.LinearOrder | {
"line": 166,
"column": 2
} | {
"line": 167,
"column": 26
} | [
{
"pp": "α : Type u_1\ninst✝ : LinearOrder α\na b c : α\nh₁ : c ≤ a\nh₂ : c ≤ b\n⊢ c ≤ min a b",
"usedConstants": [
"Eq.mpr",
"congrArg",
"PartialOrder.toPreorder",
"Preorder.toLE",
"LinearOrder.toDecidableLE",
"id",
"LE.le",
"if_pos",
"dite",
"min... | rw [min_def]
split_ifs <;> assumption | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Order.Max | {
"line": 165,
"column": 11
} | {
"line": 165,
"column": 27
} | [
{
"pp": "α : Type u_3\ninst✝ : PartialOrder α\ni j : α\nh : IsBot i\n⊢ IsMin j ↔ j = i",
"usedConstants": [
"Eq.mpr",
"congrArg",
"PartialOrder.toPreorder",
"Preorder.toLE",
"id",
"LE.le",
"_private.Mathlib.Order.Max.0.IsBot.isMin_iff._simp_1_1",
"And",
... | le_antisymm_iff, | Mathlib.Tactic._aux_Mathlib_Tactic_SimpRw___elabRules_Mathlib_Tactic_tacticSimp_rw____1 | null |
Mathlib.Order.BoundedOrder.Basic | {
"line": 59,
"column": 4
} | {
"line": 59,
"column": 40
} | [
{
"pp": "case neg\nα✝ : Type u\nβ : Type v\nα : Type u_1\ninst✝ : LE α\nH : ∃ a, ∀ (b : α), b ≤ a\n⊢ OrderTop α ⊕' NoTopOrder α",
"usedConstants": [
"Top.mk",
"LE.le",
"Classical.choose"
]
}
] | letI : Top α := ⟨Classical.choose H⟩ | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_tacticLetI___1 | Lean.Parser.Tactic.tacticLetI__ |
Mathlib.Order.Compare | {
"line": 197,
"column": 6
} | {
"line": 197,
"column": 22
} | [
{
"pp": "α : Type u_1\ninst✝¹ : LinearOrder α\nx y : α\nβ : Type u_3\ninst✝ : LinearOrder β\nx' y' : β\nh : cmp x y = cmp x' y'\n⊢ x = y ↔ x' = y'",
"usedConstants": [
"Eq.mpr",
"congrArg",
"PartialOrder.toPreorder",
"Preorder.toLE",
"id",
"LE.le",
"And",
"Iff... | le_antisymm_iff, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Order.Compare | {
"line": 197,
"column": 23
} | {
"line": 197,
"column": 39
} | [
{
"pp": "α : Type u_1\ninst✝¹ : LinearOrder α\nx y : α\nβ : Type u_3\ninst✝ : LinearOrder β\nx' y' : β\nh : cmp x y = cmp x' y'\n⊢ x ≤ y ∧ y ≤ x ↔ x' = y'",
"usedConstants": [
"Eq.mpr",
"congrArg",
"PartialOrder.toPreorder",
"Preorder.toLE",
"id",
"LE.le",
"And",
... | le_antisymm_iff, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Order.Monotone.Basic | {
"line": 654,
"column": 2
} | {
"line": 654,
"column": 82
} | [
{
"pp": "α : Type u\ninst✝³ : Preorder α\ninst✝² : Nonempty α\ninst✝¹ : NoMinOrder α\ninst✝ : NoMaxOrder α\ninhabited_h : Inhabited α\nf : ℕ → α\nhf : StrictMono f\nhf₀ : f 0 = default\ng : ℕ → α\nhg : StrictAnti g\nhg₀ : g 0 = default\n⊢ ∃ f, StrictMono f",
"usedConstants": [
"StrictMono",
"Int... | refine ⟨fun n ↦ Int.casesOn n f fun n ↦ g (n + 1), strictMono_int_of_lt_succ ?_⟩ | Lean.Elab.Tactic.evalRefine | Lean.Parser.Tactic.refine |
Mathlib.Data.Set.Basic | {
"line": 897,
"column": 11
} | {
"line": 897,
"column": 23
} | [
{
"pp": "α : Type u\ns : Set α\np q : α → Prop\n⊢ {x | x ∈ s ∧ p x} = {x | x ∈ s ∧ q x} ↔ ∀ (x : α), x ∈ s → (p x ↔ q x)",
"usedConstants": [
"Eq.mpr",
"congrArg",
"setOf",
"Membership.mem",
"id",
"And",
"Iff",
"congrFun'",
"_private.Mathlib.Data.Set.Bas... | Set.ext_iff, | Mathlib.Tactic._aux_Mathlib_Tactic_SimpRw___elabRules_Mathlib_Tactic_tacticSimp_rw____1 | null |
Mathlib.Data.Set.Basic | {
"line": 910,
"column": 11
} | {
"line": 910,
"column": 23
} | [
{
"pp": "α : Type u\ns : Set α\np : α → Prop\n⊢ {x | x ∈ s ∧ p x} = s ↔ ∀ (x : α), x ∈ s → p x",
"usedConstants": [
"_private.Mathlib.Data.Set.Basic.0.Set.sep_eq_self_iff_mem_true._simp_1_1",
"Eq.mpr",
"congrArg",
"setOf",
"Membership.mem",
"id",
"And",
"Iff",... | Set.ext_iff, | Mathlib.Tactic._aux_Mathlib_Tactic_SimpRw___elabRules_Mathlib_Tactic_tacticSimp_rw____1 | null |
Mathlib.Data.Set.Basic | {
"line": 914,
"column": 11
} | {
"line": 914,
"column": 23
} | [
{
"pp": "α : Type u\ns : Set α\np : α → Prop\n⊢ {x | x ∈ s ∧ p x} = ∅ ↔ ∀ (x : α), x ∈ s → ¬p x",
"usedConstants": [
"Eq.mpr",
"congrArg",
"setOf",
"Membership.mem",
"id",
"_private.Mathlib.Data.Set.Basic.0.Set.sep_eq_empty_iff_mem_false._simp_1_1",
"And",
"If... | Set.ext_iff, | Mathlib.Tactic._aux_Mathlib_Tactic_SimpRw___elabRules_Mathlib_Tactic_tacticSimp_rw____1 | null |
Mathlib.Data.Set.Basic | {
"line": 994,
"column": 16
} | {
"line": 994,
"column": 24
} | [
{
"pp": "case pos\nα : Type u\np : Prop\ninst✝ : Decidable p\nt : ¬p → Set α\nx : α\nh✝ : p\n⊢ x ∈ univ ↔ ∀ (h : ¬p), x ∈ t h",
"usedConstants": [
"False",
"congrArg",
"Set.mem_univ._simp_1",
"Set.univ",
"Membership.mem",
"not_true_eq_false",
"iff_self",
"fora... | simp_all | Lean.Elab.Tactic.evalSimpAll | Lean.Parser.Tactic.simpAll |
Mathlib.Data.Set.Basic | {
"line": 994,
"column": 16
} | {
"line": 994,
"column": 24
} | [
{
"pp": "case neg\nα : Type u\np : Prop\ninst✝ : Decidable p\nt : ¬p → Set α\nx : α\nh✝ : ¬p\n⊢ x ∈ t h✝ ↔ ∀ (h : ¬p), x ∈ t h",
"usedConstants": [
"False",
"eq_false",
"congrArg",
"Membership.mem",
"iff_self",
"forall_prop_domain_congr",
"Iff",
"True",
... | simp_all | Lean.Elab.Tactic.evalSimpAll | Lean.Parser.Tactic.simpAll |
Mathlib.Order.Lattice | {
"line": 400,
"column": 6
} | {
"line": 401,
"column": 24
} | [
{
"pp": "α✝ : Type u\nβ : Type v\nα : Type u_1\ninst✝¹ : Max α\ninst✝ : Min α\nsup_comm : ∀ (a b : α), a ⊔ b = b ⊔ a\nsup_assoc : ∀ (a b c : α), a ⊔ b ⊔ c = a ⊔ (b ⊔ c)\ninf_comm : ∀ (a b : α), a ⊓ b = b ⊓ a\ninf_assoc : ∀ (a b c : α), a ⊓ b ⊓ c = a ⊓ (b ⊓ c)\nsup_inf_self : ∀ (a b : α), a ⊔ a ⊓ b = a\ninf_sup_... | rw [partial_order_eq]
apply inf_le_right | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Order.Lattice | {
"line": 400,
"column": 6
} | {
"line": 401,
"column": 24
} | [
{
"pp": "α✝ : Type u\nβ : Type v\nα : Type u_1\ninst✝¹ : Max α\ninst✝ : Min α\nsup_comm : ∀ (a b : α), a ⊔ b = b ⊔ a\nsup_assoc : ∀ (a b c : α), a ⊔ b ⊔ c = a ⊔ (b ⊔ c)\ninf_comm : ∀ (a b : α), a ⊓ b = b ⊓ a\ninf_assoc : ∀ (a b c : α), a ⊓ b ⊓ c = a ⊓ (b ⊓ c)\nsup_inf_self : ∀ (a b : α), a ⊔ a ⊓ b = a\ninf_sup_... | rw [partial_order_eq]
apply inf_le_right | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Order.Lattice | {
"line": 416,
"column": 47
} | {
"line": 416,
"column": 86
} | [
{
"pp": "α : Type u\ninst✝ : Lattice α\na b : α\n⊢ a ⊓ b = a ⊔ b ↔ a = b",
"usedConstants": [
"Eq.mpr",
"Lattice.toSemilatticeSup",
"sup_le_inf",
"congrArg",
"Iff.rfl",
"PartialOrder.toPreorder",
"Preorder.toLE",
"SemilatticeInf.toPartialOrder",
"Semilat... | rw [← inf_le_sup.ge_iff_eq, sup_le_inf] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.Order.Lattice | {
"line": 416,
"column": 47
} | {
"line": 416,
"column": 86
} | [
{
"pp": "α : Type u\ninst✝ : Lattice α\na b : α\n⊢ a ⊓ b = a ⊔ b ↔ a = b",
"usedConstants": [
"Eq.mpr",
"Lattice.toSemilatticeSup",
"sup_le_inf",
"congrArg",
"Iff.rfl",
"PartialOrder.toPreorder",
"Preorder.toLE",
"SemilatticeInf.toPartialOrder",
"Semilat... | rw [← inf_le_sup.ge_iff_eq, sup_le_inf] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Order.Lattice | {
"line": 416,
"column": 47
} | {
"line": 416,
"column": 86
} | [
{
"pp": "α : Type u\ninst✝ : Lattice α\na b : α\n⊢ a ⊓ b = a ⊔ b ↔ a = b",
"usedConstants": [
"Eq.mpr",
"Lattice.toSemilatticeSup",
"sup_le_inf",
"congrArg",
"Iff.rfl",
"PartialOrder.toPreorder",
"Preorder.toLE",
"SemilatticeInf.toPartialOrder",
"Semilat... | rw [← inf_le_sup.ge_iff_eq, sup_le_inf] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Order.Lattice | {
"line": 418,
"column": 52
} | {
"line": 418,
"column": 96
} | [
{
"pp": "α : Type u\ninst✝ : Lattice α\na b : α\n⊢ a ⊓ b < a ⊔ b ↔ a ≠ b",
"usedConstants": [
"Eq.mpr",
"Preorder.toLT",
"Lattice.toSemilatticeSup",
"inf_eq_sup",
"congrArg",
"Iff.rfl",
"PartialOrder.toPreorder",
"SemilatticeInf.toPartialOrder",
"Semilat... | by rw [inf_le_sup.lt_iff_ne, Ne, inf_eq_sup] | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Data.Set.Subsingleton | {
"line": 67,
"column": 68
} | {
"line": 67,
"column": 76
} | [
{
"pp": "case inl\nα : Type u\ns : Set α\nh✝ : s = ∅\n⊢ s.Subsingleton",
"usedConstants": [
"congrArg",
"Set.subsingleton_empty._simp_1",
"True",
"Set.Subsingleton",
"Set.instEmptyCollection",
"of_eq_true",
"EmptyCollection.emptyCollection",
"Eq.trans",
... | simp_all | Lean.Elab.Tactic.evalSimpAll | Lean.Parser.Tactic.simpAll |
Mathlib.Data.Set.Subsingleton | {
"line": 67,
"column": 68
} | {
"line": 67,
"column": 76
} | [
{
"pp": "case inr\nα : Type u\nw✝ : α\n⊢ {w✝}.Subsingleton",
"usedConstants": [
"Set.subsingleton_singleton._simp_1",
"Set.instSingletonSet",
"Set.Subsingleton",
"of_eq_true",
"Singleton.singleton",
"Set"
]
}
] | simp_all | Lean.Elab.Tactic.evalSimpAll | Lean.Parser.Tactic.simpAll |
Mathlib.Order.BooleanAlgebra.Set | {
"line": 450,
"column": 2
} | {
"line": 450,
"column": 80
} | [
{
"pp": "α : Type u_1\na b : α\nhab : a ≠ b\n⊢ {a, b} \\ {a} = {b}",
"usedConstants": [
"Set.mem_singleton",
"Eq.mpr",
"congrArg",
"Set.diff_singleton_eq_self",
"Membership.mem",
"Set.instSingletonSet",
"id",
"Insert.insert",
"Set.insert_diff_of_mem",
... | rw [insert_diff_of_mem _ (mem_singleton a), diff_singleton_eq_self (by simpa)] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.Order.BooleanAlgebra.Set | {
"line": 450,
"column": 2
} | {
"line": 450,
"column": 80
} | [
{
"pp": "α : Type u_1\na b : α\nhab : a ≠ b\n⊢ {a, b} \\ {a} = {b}",
"usedConstants": [
"Set.mem_singleton",
"Eq.mpr",
"congrArg",
"Set.diff_singleton_eq_self",
"Membership.mem",
"Set.instSingletonSet",
"id",
"Insert.insert",
"Set.insert_diff_of_mem",
... | rw [insert_diff_of_mem _ (mem_singleton a), diff_singleton_eq_self (by simpa)] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Order.BooleanAlgebra.Set | {
"line": 450,
"column": 2
} | {
"line": 450,
"column": 80
} | [
{
"pp": "α : Type u_1\na b : α\nhab : a ≠ b\n⊢ {a, b} \\ {a} = {b}",
"usedConstants": [
"Set.mem_singleton",
"Eq.mpr",
"congrArg",
"Set.diff_singleton_eq_self",
"Membership.mem",
"Set.instSingletonSet",
"id",
"Insert.insert",
"Set.insert_diff_of_mem",
... | rw [insert_diff_of_mem _ (mem_singleton a), diff_singleton_eq_self (by simpa)] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Data.Sigma.Basic | {
"line": 204,
"column": 2
} | {
"line": 204,
"column": 10
} | [
{
"pp": "α : Type u_7\nβ : Type u_8\na : α\nb : β\nc : α\nd : β\nh : (a, b).toSigma = (c, d).toSigma\n⊢ (a, b) = (c, d)",
"usedConstants": [
"Prod.toSigma",
"congrArg",
"heq_eq_eq",
"Eq.mp",
"id",
"Sigma.mk.injEq",
"Prod.mk",
"And",
"congr",
"True"... | simp_all | Lean.Elab.Tactic.evalSimpAll | Lean.Parser.Tactic.simpAll |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.