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.HilbertPoly | {
"line": 241,
"column": 6
} | {
"line": 241,
"column": 65
} | [
{
"pp": "F : Type u_1\ninst✝¹ : Field F\ninst✝ : CharZero F\np : F[X]\nd : ℕ\nhdp : d ≤ rootMultiplicity 1 p\nhp : ¬p = 0\nq : F[X]\nhq1 : p = (X - C 1) ^ rootMultiplicity 1 p * q\nhq2 : ¬X - C 1 ∣ q\n⊢ p = q * (-1) ^ rootMultiplicity 1 p * (1 - X) ^ rootMultiplicity 1 p",
"usedConstants": [
"Eq.mpr",... | simp only [mul_assoc, ← mul_pow, neg_mul, one_mul, neg_sub] | Lean.Elab.Tactic.evalSimp | Lean.Parser.Tactic.simp |
Mathlib.RingTheory.Polynomial.HilbertPoly | {
"line": 251,
"column": 4
} | {
"line": 251,
"column": 63
} | [
{
"pp": "F : Type u_1\ninst✝¹ : Field F\ninst✝ : CharZero F\np : F[X]\nd : ℕ\nhp : p ≠ 0\nhpd : rootMultiplicity 1 p < d\nq : F[X]\nhq1 : p = (X - C 1) ^ rootMultiplicity 1 p * q\nhq2 : ¬X - C 1 ∣ q\n⊢ p = q * (-1) ^ rootMultiplicity 1 p * (1 - X) ^ rootMultiplicity 1 p",
"usedConstants": [
"Eq.mpr",
... | simp only [mul_assoc, ← mul_pow, neg_mul, one_mul, neg_sub] | Lean.Elab.Tactic.evalSimp | Lean.Parser.Tactic.simp |
Mathlib.RingTheory.UniqueFactorizationDomain.Kaplansky | {
"line": 84,
"column": 2
} | {
"line": 84,
"column": 43
} | [
{
"pp": "R : Type u_1\ninst✝¹ : CommSemiring R\ninst✝ : IsDomain R\nH : ∀ (I : Ideal R), I ≠ ⊥ → I.IsPrime → ∃ x ∈ I, Prime x\na : R\nha : a ≠ 0\n⊢ ∃ f, (∀ b ∈ f, Prime b) ∧ Associated f.prod a",
"usedConstants": [
"CommSemiring.toSemiring",
"Submonoid.toSubsemigroup",
"Prime",
"setO... | have ha₂ := span_notMem_kaplanskySet ha H | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_tacticHave___1 | Lean.Parser.Tactic.tacticHave__ |
Mathlib.RingTheory.PowerSeries.Ideal | {
"line": 182,
"column": 2
} | {
"line": 193,
"column": 24
} | [
{
"pp": "R : Type u_1\ninst✝¹ : CommRing R\nP : Ideal R⟦X⟧\ninst✝ : P.IsPrime\n⊢ P.FG ↔ (Ideal.map constantCoeff P).FG",
"usedConstants": [
"Semiring.toModule",
"congrArg",
"CommSemiring.toSemiring",
"Ideal.FG.map",
"Finset",
"Classical.propDecidable",
"RingHom",
... | constructor
· exact (FG.map · _)
· intro ⟨S, hS⟩
by_cases hX : X ∈ P
· have H := eq_span_insert_X_of_X_mem_of_span_eq hX hS
have : (insert X <| (C (R := R)) '' S).Finite :=
Finite.insert X <| Finite.image _ S.finite_toSet
lift insert X <| (C (R := R)) '' S to Finset R⟦X⟧ using this with ... | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.RingTheory.PowerSeries.Ideal | {
"line": 182,
"column": 2
} | {
"line": 193,
"column": 24
} | [
{
"pp": "R : Type u_1\ninst✝¹ : CommRing R\nP : Ideal R⟦X⟧\ninst✝ : P.IsPrime\n⊢ P.FG ↔ (Ideal.map constantCoeff P).FG",
"usedConstants": [
"Semiring.toModule",
"congrArg",
"CommSemiring.toSemiring",
"Ideal.FG.map",
"Finset",
"Classical.propDecidable",
"RingHom",
... | constructor
· exact (FG.map · _)
· intro ⟨S, hS⟩
by_cases hX : X ∈ P
· have H := eq_span_insert_X_of_X_mem_of_span_eq hX hS
have : (insert X <| (C (R := R)) '' S).Finite :=
Finite.insert X <| Finite.image _ S.finite_toSet
lift insert X <| (C (R := R)) '' S to Finset R⟦X⟧ using this with ... | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.RingTheory.PowerSeries.Restricted | {
"line": 101,
"column": 6
} | {
"line": 101,
"column": 19
} | [
{
"pp": "R : Type u_1\ninst✝ : NormedRing R\nc : ℝ\nf : R⟦X⟧\nhf✝ : ∀ (ε : ℝ), 0 < ε → ∃ N, ∀ (n : ℕ), N ≤ n → ‖‖(coeff n) f‖ * c ^ n‖ < ε\nN : ℕ\nhf : ∀ (n : ℕ), N ≤ n → ‖(coeff n) f‖ * |c| ^ n < 1\n⊢ BddAbove (convergenceSet c f)",
"usedConstants": [
"Eq.mpr",
"Real.instLE",
"Real",
... | bddAbove_def, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.RingTheory.PolynomialLaw.Basic | {
"line": 462,
"column": 2
} | {
"line": 462,
"column": 69
} | [
{
"pp": "R : Type u\ninst✝⁴ : CommSemiring R\nM : Type u_1\ninst✝³ : AddCommMonoid M\ninst✝² : Module R M\nS : Type v\ninst✝¹ : CommSemiring S\ninst✝ : Algebra R S\nt : S ⊗[R] M\ns : S\nA : Subalgebra R S\nhA : A.FG\nht : t ∈ (rTensor M A.val.toLinearMap).range\nhB : (A ⊔ Algebra.adjoin R ↑{s}).FG\ngen : Finset... | have hAB : A ≤ A ⊔ Algebra.adjoin R ({s} : Finset S) := le_sup_left | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_tacticHave___1 | Lean.Parser.Tactic.tacticHave__ |
Mathlib.RingTheory.PowerSeries.WeierstrassPreparation | {
"line": 268,
"column": 16
} | {
"line": 268,
"column": 25
} | [
{
"pp": "A : Type u_1\ninst✝ : CommRing A\ng : A⟦X⟧\nI : Ideal A\nH : g.IsWeierstrassDivisorAt I\nf : A⟦X⟧\n⊢ 0 + (mk fun i ↦ (coeff (i + ((map (Ideal.Quotient.mk I)) g).order.toNat)) (f - g * 0)) * ↑⋯.unit⁻¹ =\n (mk fun i ↦ (coeff (i + ((map (Ideal.Quotient.mk I)) g).order.toNat)) f) * ↑⋯.unit⁻¹",
"used... | mul_zero, | Mathlib.Tactic._aux_Mathlib_Tactic_SimpRw___elabRules_Mathlib_Tactic_tacticSimp_rw____1 | null |
Mathlib.RingTheory.PowerSeries.WeierstrassPreparation | {
"line": 328,
"column": 12
} | {
"line": 328,
"column": 21
} | [
{
"pp": "A : Type u_1\ninst✝¹ : CommRing A\ng : A⟦X⟧\nI : Ideal A\nH : g.IsWeierstrassDivisorAt I\ninst✝ : IsHausdorff I A\nq : A⟦X⟧\nr : A[X]\nhdeg : r.degree < ↑((map (Ideal.Quotient.mk I)) g).order.toNat\nheq : g * 0 = ↑r\nthis : ∀ (k i : ℕ), (coeff i) q ∈ I ^ k\nhq : q = 0\n⊢ q = 0 ∧ r = 0",
"usedConsta... | mul_zero, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.RingTheory.PowerSeries.WeierstrassPreparation | {
"line": 368,
"column": 2
} | {
"line": 368,
"column": 89
} | [
{
"pp": "A : Type u_1\ninst✝¹ : CommRing A\ng : A⟦X⟧\nI : Ideal A\nH : g.IsWeierstrassDivisorAt I\ninst✝ : IsHausdorff I A\nq q' : A⟦X⟧\nr r' : A[X]\nhr : r.degree < ↑((map (Ideal.Quotient.mk I)) g).order.toNat\nhr' : r'.degree < ↑((map (Ideal.Quotient.mk I)) g).order.toNat\nheq : g * (q - q') = ↑(r' - r)\n⊢ q ... | have h := H.eq_zero_of_mul_eq (lt_of_le_of_lt (r'.degree_sub_le r) (max_lt hr' hr)) heq | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_tacticHave___1 | Lean.Parser.Tactic.tacticHave__ |
Mathlib.RingTheory.PicardGroup | {
"line": 687,
"column": 2
} | {
"line": 688,
"column": 72
} | [
{
"pp": "R : Type u\nM : Type v\nN : Type u_1\nP : Type u_2\nQ : Type u_3\nA : Type u_4\ninst✝¹¹ : CommSemiring R\ninst✝¹⁰ : AddCommMonoid M\ninst✝⁹ : AddCommMonoid N\ninst✝⁸ : AddCommMonoid P\ninst✝⁷ : AddCommMonoid Q\ninst✝⁶ : Module R M\ninst✝⁵ : Module R N\ninst✝⁴ : Module R P\ninst✝³ : Module R Q\ninst✝² :... | convert (projective_units_and_mul'_comp_lTensor_bijective J).2.1.comp
(Flat.rTensor_preserves_injective_linearMap _ I.1.subtype_injective) | Mathlib.Tactic._aux_Mathlib_Tactic_Convert___elabRules_Mathlib_Tactic_convert_1 | Mathlib.Tactic.convert |
Mathlib.RingTheory.SimpleModule.Isotypic | {
"line": 127,
"column": 2
} | {
"line": 130,
"column": 50
} | [
{
"pp": "R : Type u_2\nM : Type u\ninst✝² : Ring R\ninst✝¹ : AddCommGroup M\ninst✝ : Module R M\nN : Submodule R M\n⊢ IsIsotypic R ↥N ↔ ∀ m ≤ N, ∀ [IsSimpleModule R ↥m], IsIsotypicOfType R ↥N ↥m",
"usedConstants": [
"Eq.mpr",
"Submodule",
"Submodule.MapSubtype.orderIso",
"RingHomSurj... | rw [Subtype.forall', ← (Submodule.MapSubtype.orderIso N).forall_congr_right]
have e := Submodule.equivMapOfInjective _ N.subtype_injective
simp_rw [Submodule.MapSubtype.orderIso, Equiv.coe_fn_mk, ← (e _).isSimpleModule_iff,
← (e _).isIsotypicOfType_iff_type, IsIsotypic] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.RingTheory.SimpleModule.Isotypic | {
"line": 127,
"column": 2
} | {
"line": 130,
"column": 50
} | [
{
"pp": "R : Type u_2\nM : Type u\ninst✝² : Ring R\ninst✝¹ : AddCommGroup M\ninst✝ : Module R M\nN : Submodule R M\n⊢ IsIsotypic R ↥N ↔ ∀ m ≤ N, ∀ [IsSimpleModule R ↥m], IsIsotypicOfType R ↥N ↥m",
"usedConstants": [
"Eq.mpr",
"Submodule",
"Submodule.MapSubtype.orderIso",
"RingHomSurj... | rw [Subtype.forall', ← (Submodule.MapSubtype.orderIso N).forall_congr_right]
have e := Submodule.equivMapOfInjective _ N.subtype_injective
simp_rw [Submodule.MapSubtype.orderIso, Equiv.coe_fn_mk, ← (e _).isSimpleModule_iff,
← (e _).isIsotypicOfType_iff_type, IsIsotypic] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.RingTheory.TensorProduct.MonoidAlgebra | {
"line": 81,
"column": 2
} | {
"line": 81,
"column": 38
} | [
{
"pp": "R : Type u_1\nM : Type u_2\nA : Type u_4\nB : Type u_5\ninst✝⁵ : CommSemiring R\ninst✝⁴ : CommSemiring A\ninst✝³ : CommSemiring B\ninst✝² : Algebra R A\ninst✝¹ : Algebra R B\ninst✝ : CommMonoid M\na : A\np : B[M]\n⊢ (tensorEquiv R A B) (a ⊗ₜ[R] p) = a • (mapAlgHom M includeRight) p",
"usedConstants... | simp [tensorEquiv, Algebra.smul_def] | Lean.Elab.Tactic.evalSimp | Lean.Parser.Tactic.simp |
Mathlib.RingTheory.TensorProduct.MonoidAlgebra | {
"line": 81,
"column": 2
} | {
"line": 81,
"column": 38
} | [
{
"pp": "R : Type u_1\nM : Type u_2\nA : Type u_4\nB : Type u_5\ninst✝⁵ : CommSemiring R\ninst✝⁴ : CommSemiring A\ninst✝³ : CommSemiring B\ninst✝² : Algebra R A\ninst✝¹ : Algebra R B\ninst✝ : CommMonoid M\na : A\np : B[M]\n⊢ (tensorEquiv R A B) (a ⊗ₜ[R] p) = a • (mapAlgHom M includeRight) p",
"usedConstants... | simp [tensorEquiv, Algebra.smul_def] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.RingTheory.TensorProduct.MonoidAlgebra | {
"line": 81,
"column": 2
} | {
"line": 81,
"column": 38
} | [
{
"pp": "R : Type u_1\nM : Type u_2\nA : Type u_4\nB : Type u_5\ninst✝⁵ : CommSemiring R\ninst✝⁴ : CommSemiring A\ninst✝³ : CommSemiring B\ninst✝² : Algebra R A\ninst✝¹ : Algebra R B\ninst✝ : CommMonoid M\na : A\np : B[M]\n⊢ (tensorEquiv R A B) (a ⊗ₜ[R] p) = a • (mapAlgHom M includeRight) p",
"usedConstants... | simp [tensorEquiv, Algebra.smul_def] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.RingTheory.Valuation.Extension | {
"line": 100,
"column": 4
} | {
"line": 100,
"column": 63
} | [
{
"pp": "R : Type u_1\nA : Type u_2\nΓR : Type u_3\nΓA : Type u_4\ninst✝⁴ : CommRing R\ninst✝³ : Ring A\ninst✝² : LinearOrderedCommMonoidWithZero ΓR\ninst✝¹ : LinearOrderedCommMonoidWithZero ΓA\ninst✝ : Algebra R A\nvR : Valuation R ΓR\nvA : Valuation A ΓA\n⊢ vR.IsEquiv (comap (algebraMap R R) vR)",
"usedCo... | simp only [Algebra.algebraMap_self, comap_id, IsEquiv.refl] | Lean.Elab.Tactic.evalSimp | Lean.Parser.Tactic.simp |
Mathlib.RingTheory.Valuation.Extension | {
"line": 100,
"column": 4
} | {
"line": 100,
"column": 63
} | [
{
"pp": "R : Type u_1\nA : Type u_2\nΓR : Type u_3\nΓA : Type u_4\ninst✝⁴ : CommRing R\ninst✝³ : Ring A\ninst✝² : LinearOrderedCommMonoidWithZero ΓR\ninst✝¹ : LinearOrderedCommMonoidWithZero ΓA\ninst✝ : Algebra R A\nvR : Valuation R ΓR\nvA : Valuation A ΓA\n⊢ vR.IsEquiv (comap (algebraMap R R) vR)",
"usedCo... | simp only [Algebra.algebraMap_self, comap_id, IsEquiv.refl] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.RingTheory.Valuation.Extension | {
"line": 100,
"column": 4
} | {
"line": 100,
"column": 63
} | [
{
"pp": "R : Type u_1\nA : Type u_2\nΓR : Type u_3\nΓA : Type u_4\ninst✝⁴ : CommRing R\ninst✝³ : Ring A\ninst✝² : LinearOrderedCommMonoidWithZero ΓR\ninst✝¹ : LinearOrderedCommMonoidWithZero ΓA\ninst✝ : Algebra R A\nvR : Valuation R ΓR\nvA : Valuation A ΓA\n⊢ vR.IsEquiv (comap (algebraMap R R) vR)",
"usedCo... | simp only [Algebra.algebraMap_self, comap_id, IsEquiv.refl] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.RingTheory.WittVector.DiscreteValuationRing | {
"line": 72,
"column": 4
} | {
"line": 72,
"column": 81
} | [
{
"pp": "case a.a\np : ℕ\nhp : Fact (Nat.Prime p)\nk : Type u_1\ninst✝¹ : CommRing k\ninst✝ : CharP k p\na : kˣ\nA : failed to pretty print expression (use 'set_option pp.rawOnError true' for raw representation)\nhA : A.coeff 0 = ↑a\nn : ℕ\na✝ : (A * { coeff := inverseCoeff a A }).coeff n = coeff 1 n\nH_coeff :... | have ha_inv : (↑a⁻¹ : k) ^ p ^ (n + 1) = ↑(a ^ p ^ (n + 1))⁻¹ := by norm_cast | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_tacticHave___1 | Lean.Parser.Tactic.tacticHave__ |
Mathlib.RingTheory.WittVector.MulCoeff | {
"line": 117,
"column": 4
} | {
"line": 126,
"column": 43
} | [
{
"pp": "case h.e'_2\np : ℕ\nhp : Fact (Nat.Prime p)\nn : ℕ\n⊢ ∑ i ∈ range (n + 1), ↑p ^ i * wittMul p i ^ p ^ (n - i) =\n (bind₁ (wittStructureInt p (X 0 * X 1))) (wittPolynomial p ℤ n)",
"usedConstants": [
"Finsupp.instAddZeroClass",
"Finsupp.instFunLike",
"Int.cast",
"Eq.mpr",
... | simp only [wittPolynomial, wittMul]
rw [map_sum]
congr 1 with i
congr 1
have hsupp : (Finsupp.single i (p ^ (n - i))).support = {i} := by
rw [Finsupp.support_eq_singleton]
simp only [and_true, Finsupp.single_eq_same, Ne]
exact pow_ne_zero _ hp.out.ne_zero
simp only [bind₁_monomial,... | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.RingTheory.WittVector.MulCoeff | {
"line": 117,
"column": 4
} | {
"line": 126,
"column": 43
} | [
{
"pp": "case h.e'_2\np : ℕ\nhp : Fact (Nat.Prime p)\nn : ℕ\n⊢ ∑ i ∈ range (n + 1), ↑p ^ i * wittMul p i ^ p ^ (n - i) =\n (bind₁ (wittStructureInt p (X 0 * X 1))) (wittPolynomial p ℤ n)",
"usedConstants": [
"Finsupp.instAddZeroClass",
"Finsupp.instFunLike",
"Int.cast",
"Eq.mpr",
... | simp only [wittPolynomial, wittMul]
rw [map_sum]
congr 1 with i
congr 1
have hsupp : (Finsupp.single i (p ^ (n - i))).support = {i} := by
rw [Finsupp.support_eq_singleton]
simp only [and_true, Finsupp.single_eq_same, Ne]
exact pow_ne_zero _ hp.out.ne_zero
simp only [bind₁_monomial,... | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.SetTheory.Ordinal.FixedPointApproximants | {
"line": 170,
"column": 2
} | {
"line": 170,
"column": 68
} | [
{
"pp": "α : Type u\ninst✝ : CompleteLattice α\nf : α →o α\nx : α\nh_ninj : ¬Set.InjOn (lfpApprox f x) (Set.Iio (SuccOrder.succ #α).ord)\n⊢ ∃ a < (succ #α).ord, ∃ b < (succ #α).ord, a ≠ b ∧ lfpApprox f x a = lfpApprox f x b",
"usedConstants": [
"SuccOrder.succ",
"Ordinal.partialOrder",
"Ca... | rw [Set.injOn_iff_injective, Function.not_injective_iff] at h_ninj | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.SetTheory.Lists | {
"line": 155,
"column": 2
} | {
"line": 155,
"column": 41
} | [
{
"pp": "α : Type u_1\na : Lists α\nl₁ l₂ l₁' : Lists' α true\nh' : cons a l₁ = l₁'\nh : l₁' ⊆ l₂\n⊢ a ∈ l₂ ∧ l₁ ⊆ l₂",
"usedConstants": [
"HEq.refl",
"HasSubset.Subset",
"Bool.true",
"Lists'.instHasSubsetTrue",
"Eq.refl",
"Lists'"
]
}
] | obtain - | @⟨a', _, _, _, e, m, s⟩ := h | _private.Lean.Elab.Tactic.RCases.0.Lean.Elab.Tactic.RCases.evalObtain | Lean.Parser.Tactic.obtain |
Mathlib.SetTheory.Ordinal.FixedPointApproximants | {
"line": 175,
"column": 16
} | {
"line": 175,
"column": 44
} | [
{
"pp": "case h.left\nα : Type u\ninst✝ : CompleteLattice α\nf : α →o α\nx : α\nh_ninj :\n ∃ a b,\n (Set.Iio (SuccOrder.succ #α).ord).restrict (lfpApprox f x) a =\n (Set.Iio (SuccOrder.succ #α).ord).restrict (lfpApprox f x) b ∧\n a ≠ b\na b : ↑(Set.Iio (SuccOrder.succ #α).ord)\nh_fab :\n (Set.I... | rw [Subtype.coe_inj] at h_eq | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.SetTheory.Ordinal.CantorNormalForm | {
"line": 123,
"column": 87
} | {
"line": 128,
"column": 14
} | [
{
"pp": "b o : Ordinal.{u}\nx : Ordinal.{u} × Ordinal.{u}\n⊢ x ∈ CNF b o → 0 < x.2",
"usedConstants": [
"Eq.mpr",
"False",
"Preorder.toLT",
"instHDiv",
"Ordinal.partialOrder",
"congrArg",
"Ordinal.div_opow_log_pos",
"HEq.refl",
"List.Mem.tail",
"Pa... | by
refine CNF.rec b (by simp) (fun o ho IH ↦ ?_) o
rw [CNF.ne_zero ho]
rintro (h | ⟨_, h⟩)
· exact div_opow_log_pos b ho
· exact IH h | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.SetTheory.Ordinal.FundamentalSequence | {
"line": 85,
"column": 24
} | {
"line": 85,
"column": 36
} | [
{
"pp": "o : Ordinal.{u_1}\n⊢ IsCofinal (range fun x ↦ ⟨o, ⋯⟩)",
"usedConstants": [
"isCofinal_singleton_iff._simp_1",
"Ordinal.instLinearOrder",
"Preorder.toLT",
"Ordinal.partialOrder",
"congrArg",
"lt_add_one",
"AddMonoid.toAddZeroClass",
"PartialOrder.toPre... | simp [IsTop] | Lean.Elab.Tactic.evalSimp | Lean.Parser.Tactic.simp |
Mathlib.SetTheory.Ordinal.FundamentalSequence | {
"line": 85,
"column": 24
} | {
"line": 85,
"column": 36
} | [
{
"pp": "o : Ordinal.{u_1}\n⊢ IsCofinal (range fun x ↦ ⟨o, ⋯⟩)",
"usedConstants": [
"isCofinal_singleton_iff._simp_1",
"Ordinal.instLinearOrder",
"Preorder.toLT",
"Ordinal.partialOrder",
"congrArg",
"lt_add_one",
"AddMonoid.toAddZeroClass",
"PartialOrder.toPre... | simp [IsTop] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.SetTheory.Ordinal.FundamentalSequence | {
"line": 85,
"column": 24
} | {
"line": 85,
"column": 36
} | [
{
"pp": "o : Ordinal.{u_1}\n⊢ IsCofinal (range fun x ↦ ⟨o, ⋯⟩)",
"usedConstants": [
"isCofinal_singleton_iff._simp_1",
"Ordinal.instLinearOrder",
"Preorder.toLT",
"Ordinal.partialOrder",
"congrArg",
"lt_add_one",
"AddMonoid.toAddZeroClass",
"PartialOrder.toPre... | simp [IsTop] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.SetTheory.Ordinal.FundamentalSequence | {
"line": 248,
"column": 8
} | {
"line": 248,
"column": 20
} | [
{
"pp": "case refine_1\nf : Ordinal.{u} → Ordinal.{u}\nhf : IsNormal f\na o : Ordinal.{u}\nha : IsSuccLimit a\ng : (b : Ordinal.{u}) → b < o → Ordinal.{u}\nhg : a.IsFundamentalSequence o g\nι : Type u\nf' : ι → Ordinal.{u}\nhf' : lsub f' = f a\nhι : #ι = (f a).cof\n⊢ o ≤ (f a).cof.ord",
"usedConstants": [
... | ← hg.cof_eq, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.SetTheory.Ordinal.CantorNormalForm | {
"line": 311,
"column": 4
} | {
"line": 317,
"column": 16
} | [
{
"pp": "case single_add\nb : Ordinal.{u_1}\nf₂ : Ordinal.{u_1} →₀ Ordinal.{u_1}\ne₁ x : Ordinal.{u_1}\nf₁ : Ordinal.{u_1} →₀ Ordinal.{u_1}\nhf₁ : ∀ c ∈ f₁.support, c < e₁\nhx : x ≠ 0\nIH : (∀ e₁ ∈ f₁.support, ∀ e₂ ∈ f₂.support, e₂ ≤ e₁) → eval b (f₁ + f₂) = eval b f₁ + eval b f₂\nh : ∀ e₁_1 ∈ (single e₁ x + f₁... | rw [add_assoc, eval_single_add, eval_single_add' _ hf₁, IH, add_assoc]
· simp_all
· intro e₂ he₂
obtain he₂ | he₂ := Finset.mem_union.1 <| support_add he₂
· exact (hf₁ _ he₂).le
· apply h _ _ _ he₂
simp_all | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.SetTheory.Ordinal.CantorNormalForm | {
"line": 311,
"column": 4
} | {
"line": 317,
"column": 16
} | [
{
"pp": "case single_add\nb : Ordinal.{u_1}\nf₂ : Ordinal.{u_1} →₀ Ordinal.{u_1}\ne₁ x : Ordinal.{u_1}\nf₁ : Ordinal.{u_1} →₀ Ordinal.{u_1}\nhf₁ : ∀ c ∈ f₁.support, c < e₁\nhx : x ≠ 0\nIH : (∀ e₁ ∈ f₁.support, ∀ e₂ ∈ f₂.support, e₂ ≤ e₁) → eval b (f₁ + f₂) = eval b f₁ + eval b f₂\nh : ∀ e₁_1 ∈ (single e₁ x + f₁... | rw [add_assoc, eval_single_add, eval_single_add' _ hf₁, IH, add_assoc]
· simp_all
· intro e₂ he₂
obtain he₂ | he₂ := Finset.mem_union.1 <| support_add he₂
· exact (hf₁ _ he₂).le
· apply h _ _ _ he₂
simp_all | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.SetTheory.Ordinal.CantorNormalForm | {
"line": 327,
"column": 8
} | {
"line": 327,
"column": 29
} | [
{
"pp": "case single_add\nb e' x : Ordinal.{u_1}\nf : Ordinal.{u_1} →₀ Ordinal.{u_1}\nhf : ∀ c ∈ f.support, c < e'\nhx : x ≠ 0\nIH : ∀ {e : Ordinal.{u_1}}, (∀ (e' : Ordinal.{u_1}), f e' < b) → (∀ e' ∈ f.support, e' < e) → eval b f < b ^ e\ne : Ordinal.{u_1}\nhb : ∀ (e'_1 : Ordinal.{u_1}), (single e' x + f) e'_1... | eval_single_add' _ hf | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.SetTheory.Ordinal.FundamentalSequence | {
"line": 261,
"column": 6
} | {
"line": 261,
"column": 28
} | [
{
"pp": "case refine_1.refine_2\nf : Ordinal.{u} → Ordinal.{u}\nhf : IsNormal f\na o : Ordinal.{u}\nha : IsSuccLimit a\ng : (b : Ordinal.{u}) → b < o → Ordinal.{u}\nhg : a.IsFundamentalSequence o g\nι : Type u\nf' : ι → Ordinal.{u}\nhf' : lsub f' = f a\nhι : #ι = (f a).cof\nH : ∀ (i : ι), ∃ b < a, f' i ≤ f b\nb... | obtain ⟨i, hi⟩ := this | _private.Lean.Elab.Tactic.RCases.0.Lean.Elab.Tactic.RCases.evalObtain | Lean.Parser.Tactic.obtain |
Mathlib.SetTheory.Ordinal.Notation | {
"line": 315,
"column": 17
} | {
"line": 315,
"column": 41
} | [
{
"pp": "o₁ e₁ a₁ o₂ : ONote\nn₂ : ℕ+\na₂ : ONote\nh✝¹ : o₂ = e₁.oadd n₂ a₂\nh₂ : (namedPattern o₂ (e₁.oadd n₂ a₂) h✝¹).NF\nh✝ : o₁ = e₁.oadd n₂ a₁\nh₁ : (namedPattern o₁ (e₁.oadd n₂ a₁) h✝).NF\nnhl : ↑n₂ ≤ ↑n₂\nnhr : ¬↑n₂ < ↑n₂ ∧ Ordering.eq = Ordering.eq\nIHa : a₁ < a₂\n⊢ (Ordering.eq.then (Ordering.eq.then O... | exact oadd_lt_oadd_3 IHa | Lean.Elab.Tactic.evalExact | Lean.Parser.Tactic.exact |
Mathlib.SetTheory.Ordinal.Notation | {
"line": 315,
"column": 17
} | {
"line": 315,
"column": 41
} | [
{
"pp": "o₁ e₁ a₁ o₂ : ONote\nn₂ : ℕ+\na₂ : ONote\nh✝¹ : o₂ = e₁.oadd n₂ a₂\nh₂ : (namedPattern o₂ (e₁.oadd n₂ a₂) h✝¹).NF\nh✝ : o₁ = e₁.oadd n₂ a₁\nh₁ : (namedPattern o₁ (e₁.oadd n₂ a₁) h✝).NF\nnhl : ↑n₂ ≤ ↑n₂\nnhr : ¬↑n₂ < ↑n₂ ∧ Ordering.eq = Ordering.eq\nIHa : a₁ < a₂\n⊢ (Ordering.eq.then (Ordering.eq.then O... | exact oadd_lt_oadd_3 IHa | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.SetTheory.Ordinal.Notation | {
"line": 315,
"column": 17
} | {
"line": 315,
"column": 41
} | [
{
"pp": "o₁ e₁ a₁ o₂ : ONote\nn₂ : ℕ+\na₂ : ONote\nh✝¹ : o₂ = e₁.oadd n₂ a₂\nh₂ : (namedPattern o₂ (e₁.oadd n₂ a₂) h✝¹).NF\nh✝ : o₁ = e₁.oadd n₂ a₁\nh₁ : (namedPattern o₁ (e₁.oadd n₂ a₁) h✝).NF\nnhl : ↑n₂ ≤ ↑n₂\nnhr : ¬↑n₂ < ↑n₂ ∧ Ordering.eq = Ordering.eq\nIHa : a₁ < a₂\n⊢ (Ordering.eq.then (Ordering.eq.then O... | exact oadd_lt_oadd_3 IHa | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.SetTheory.Ordinal.Notation | {
"line": 316,
"column": 17
} | {
"line": 316,
"column": 41
} | [
{
"pp": "o₁ e₁ a₁ o₂ : ONote\nn₂ : ℕ+\na₂ : ONote\nh✝¹ : o₂ = e₁.oadd n₂ a₂\nh₂ : (namedPattern o₂ (e₁.oadd n₂ a₂) h✝¹).NF\nh✝ : o₁ = e₁.oadd n₂ a₁\nh₁ : (namedPattern o₁ (e₁.oadd n₂ a₁) h✝).NF\nnhl : ↑n₂ ≤ ↑n₂\nnhr : ¬↑n₂ < ↑n₂ ∧ Ordering.eq = Ordering.eq\nIHa : a₁ > a₂\n⊢ (Ordering.eq.then (Ordering.eq.then O... | exact oadd_lt_oadd_3 IHa | Lean.Elab.Tactic.evalExact | Lean.Parser.Tactic.exact |
Mathlib.SetTheory.Ordinal.Notation | {
"line": 316,
"column": 17
} | {
"line": 316,
"column": 41
} | [
{
"pp": "o₁ e₁ a₁ o₂ : ONote\nn₂ : ℕ+\na₂ : ONote\nh✝¹ : o₂ = e₁.oadd n₂ a₂\nh₂ : (namedPattern o₂ (e₁.oadd n₂ a₂) h✝¹).NF\nh✝ : o₁ = e₁.oadd n₂ a₁\nh₁ : (namedPattern o₁ (e₁.oadd n₂ a₁) h✝).NF\nnhl : ↑n₂ ≤ ↑n₂\nnhr : ¬↑n₂ < ↑n₂ ∧ Ordering.eq = Ordering.eq\nIHa : a₁ > a₂\n⊢ (Ordering.eq.then (Ordering.eq.then O... | exact oadd_lt_oadd_3 IHa | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.SetTheory.Ordinal.Notation | {
"line": 316,
"column": 17
} | {
"line": 316,
"column": 41
} | [
{
"pp": "o₁ e₁ a₁ o₂ : ONote\nn₂ : ℕ+\na₂ : ONote\nh✝¹ : o₂ = e₁.oadd n₂ a₂\nh₂ : (namedPattern o₂ (e₁.oadd n₂ a₂) h✝¹).NF\nh✝ : o₁ = e₁.oadd n₂ a₁\nh₁ : (namedPattern o₁ (e₁.oadd n₂ a₁) h✝).NF\nnhl : ↑n₂ ≤ ↑n₂\nnhr : ¬↑n₂ < ↑n₂ ∧ Ordering.eq = Ordering.eq\nIHa : a₁ > a₂\n⊢ (Ordering.eq.then (Ordering.eq.then O... | exact oadd_lt_oadd_3 IHa | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.SetTheory.Ordinal.Veblen | {
"line": 448,
"column": 75
} | {
"line": 452,
"column": 72
} | [
{
"pp": "o a : Ordinal.{u}\n⊢ a < veblen o a ↔ a.invVeblen₁ ≤ o",
"usedConstants": [
"Ordinal.veblen",
"Eq.mpr",
"False",
"Ordinal.instLinearOrder",
"Preorder.toLT",
"Ordinal.partialOrder",
"congrArg",
"Ordinal.veblen_eq_of_lt_invVeblen₁",
"PartialOrder.... | by
obtain h | h := lt_or_ge o (invVeblen₁ a)
· rw [veblen_eq_of_lt_invVeblen₁ h]
simpa
· simpa [(lt_veblen_invVeblen₁ a).trans_le (veblen_left_monotone _ h)] | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.SetTheory.Ordinal.Notation | {
"line": 459,
"column": 6
} | {
"line": 459,
"column": 25
} | [
{
"pp": "case eq\ne₁ : ONote\nn₁ : ℕ+\na₁ : ONote\nn₂ : ℕ+\na₂ : ONote\nb : Ordinal.{0}\nh₁ : (e₁.oadd n₁ a₁).NFBelow b\nh' : (a₁.sub a₂).NFBelow e₁.repr\nh₂ : (e₁.oadd n₂ a₂).NF\nh : e₁.cmp e₁ = Ordering.eq\n⊢ (match Ordering.eq with\n | Ordering.lt => 0\n | Ordering.gt => e₁.oadd n₁ a₁\n | Orde... | cases (n₁ : ℕ) - n₂ | _private.Lean.Elab.Tactic.Induction.0.Lean.Elab.Tactic.evalCases | Lean.Parser.Tactic.cases |
Mathlib.SetTheory.Ordinal.Notation | {
"line": 496,
"column": 24
} | {
"line": 496,
"column": 32
} | [
{
"pp": "case eq.succ\ne₁ : ONote\nn₁ : ℕ+\na₁ : ONote\nn₂ : ℕ+\na₂ : ONote\nh₁ : (e₁.oadd n₁ a₁).NF\nthis✝ : a₁.NF\nthis : a₂.NF\nh' : (a₁.sub a₂).repr = a₁.repr - a₂.repr\nh₂ : (e₁.oadd n₂ a₂).NF\nh : e₁.cmp e₁ = Ordering.eq\nn✝ : ℕ\nmn : ↑n₁ - ↑n₂ = n✝ + 1\n⊢ ω ^ e₁.repr * ↑(succ n✝) + a₁.repr = ω ^ e₁.repr ... | mul_add, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.SetTheory.ZFC.Ordinal | {
"line": 393,
"column": 2
} | {
"line": 397,
"column": 29
} | [
{
"pp": "x : ZFSet.{u}\n⊢ x.IsOrdinal ↔ x ∈ Set.range toZFSet",
"usedConstants": [
"Set.mem_range_self",
"Eq.mpr",
"congrArg",
"ZFSet",
"ZFSet.IsOrdinal.toZFSet_rank_eq",
"Membership.mem",
"ZFSet.IsOrdinal",
"id",
"ZFSet.isOrdinal_toZFSet",
"ZFSet.... | refine ⟨fun h ↦ ?_, ?_⟩
· rw [← h.toZFSet_rank_eq]
exact Set.mem_range_self _
· rintro ⟨a, rfl⟩
exact isOrdinal_toZFSet a | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.SetTheory.ZFC.Ordinal | {
"line": 393,
"column": 2
} | {
"line": 397,
"column": 29
} | [
{
"pp": "x : ZFSet.{u}\n⊢ x.IsOrdinal ↔ x ∈ Set.range toZFSet",
"usedConstants": [
"Set.mem_range_self",
"Eq.mpr",
"congrArg",
"ZFSet",
"ZFSet.IsOrdinal.toZFSet_rank_eq",
"Membership.mem",
"ZFSet.IsOrdinal",
"id",
"ZFSet.isOrdinal_toZFSet",
"ZFSet.... | refine ⟨fun h ↦ ?_, ?_⟩
· rw [← h.toZFSet_rank_eq]
exact Set.mem_range_self _
· rintro ⟨a, rfl⟩
exact isOrdinal_toZFSet a | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.SetTheory.ZFC.VonNeumann | {
"line": 78,
"column": 2
} | {
"line": 78,
"column": 52
} | [
{
"pp": "o : Ordinal.{u}\nx : ZFSet.{u}\n⊢ (∃ a < o, x.rank ≤ a) ↔ x.rank < o",
"usedConstants": [
"le_refl",
"Preorder.toLT",
"Ordinal.partialOrder",
"PartialOrder.toPreorder",
"Preorder.toLE",
"Exists",
"ZFSet.rank",
"LE.le",
"And",
"And.intro",
... | exact ⟨fun ⟨a, h₁, h₂⟩ ↦ h₂.trans_lt h₁, by aesop⟩ | Lean.Elab.Tactic.evalExact | Lean.Parser.Tactic.exact |
Mathlib.SetTheory.ZFC.Class | {
"line": 175,
"column": 22
} | {
"line": 175,
"column": 49
} | [
{
"pp": "A : Class.{u}\nx : ZFSet.{u}\nx✝ : A.ToSet ↑x\ny : ZFSet.{u}\nyx : ↑y = ↑x\npy : A y\n⊢ A x",
"usedConstants": [
"congrArg",
"ZFSet",
"Class.ofSet.inj",
"Eq.mp"
]
}
] | by rwa [ofSet.inj yx] at py | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.SetTheory.ZFC.Class | {
"line": 237,
"column": 2
} | {
"line": 241,
"column": 31
} | [
{
"pp": "x y : Class.{u}\n⊢ y ∈ ⋃₀ x ↔ ∃ z ∈ x, y ∈ z",
"usedConstants": [
"Iff.mpr",
"Class.ofSet",
"Class.coe_mem",
"ZFSet",
"Membership.mem",
"Exists",
"And.casesOn",
"And",
"Exists.casesOn",
"And.intro",
"Iff.intro",
"Exists.intro",... | constructor
· rintro ⟨w, rfl, z, hzx, hwz⟩
exact ⟨z, hzx, coe_mem.2 hwz⟩
· rintro ⟨w, hwx, z, rfl, hwz⟩
exact ⟨z, rfl, w, hwx, hwz⟩ | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.SetTheory.ZFC.Class | {
"line": 237,
"column": 2
} | {
"line": 241,
"column": 31
} | [
{
"pp": "x y : Class.{u}\n⊢ y ∈ ⋃₀ x ↔ ∃ z ∈ x, y ∈ z",
"usedConstants": [
"Iff.mpr",
"Class.ofSet",
"Class.coe_mem",
"ZFSet",
"Membership.mem",
"Exists",
"And.casesOn",
"And",
"Exists.casesOn",
"And.intro",
"Iff.intro",
"Exists.intro",... | constructor
· rintro ⟨w, rfl, z, hzx, hwz⟩
exact ⟨z, hzx, coe_mem.2 hwz⟩
· rintro ⟨w, hwx, z, rfl, hwz⟩
exact ⟨z, rfl, w, hwx, hwz⟩ | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.SetTheory.Ordinal.Notation | {
"line": 694,
"column": 2
} | {
"line": 695,
"column": 16
} | [
{
"pp": "x : ONote\ninst✝¹ : x.NF\no : ONote\ninst✝ : o.NF\n⊢ (x.scale o).NF",
"usedConstants": [
"ONote.NF",
"Eq.mpr",
"ONote.instMul",
"HMul.hMul",
"congrArg",
"ONote.oadd",
"ONote.instZero",
"inferInstance",
"id",
"instOfNatPNatOfNeZeroNat",
... | rw [scale_eq_mul]
infer_instance | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.SetTheory.Ordinal.Notation | {
"line": 694,
"column": 2
} | {
"line": 695,
"column": 16
} | [
{
"pp": "x : ONote\ninst✝¹ : x.NF\no : ONote\ninst✝ : o.NF\n⊢ (x.scale o).NF",
"usedConstants": [
"ONote.NF",
"Eq.mpr",
"ONote.instMul",
"HMul.hMul",
"congrArg",
"ONote.oadd",
"ONote.instZero",
"inferInstance",
"id",
"instOfNatPNatOfNeZeroNat",
... | rw [scale_eq_mul]
infer_instance | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.SetTheory.Ordinal.Notation | {
"line": 859,
"column": 20
} | {
"line": 859,
"column": 29
} | [
{
"pp": "case h₁\na0 a' : ONote\nN0 : a0.NF\nNa' : a'.NF\nm : ℕ\nd : ω ∣ a'.repr\ne0 : a0.repr ≠ 0\nh : a'.repr + ↑m < ω ^ a0.repr\nn : ℕ+\nNo : (a0.oadd n a').NF\nk : ℕ\nR' : Ordinal.{0} := (opowAux 0 a0 (a0.oadd n a' * ↑m) (k + 1) m).repr\nR : Ordinal.{0} := (opowAux 0 a0 (a0.oadd n a' * ↑m) k m).repr\nω0 : O... | opow_succ | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Tactic.ComputeAsymptotics.Multiseries.Corecursion | {
"line": 83,
"column": 4
} | {
"line": 83,
"column": 36
} | [
{
"pp": "α : Type u_1\nβ : Type u_2\nγ : Type u_3\nγ' : Type u_4\nthis : IsClosed fun x ↦ ∀ {n : ℕ}, x n = none → x (n + 1) = none\n⊢ CompleteSpace (Stream'.Seq α)",
"usedConstants": [
"PseudoMetricSpace.toUniformSpace",
"instOfNatNat",
"Stream'",
"Option.none",
"instHAdd",
... | apply IsClosed.completeSpace_coe | Lean.Elab.Tactic.evalApply | Lean.Parser.Tactic.apply |
Mathlib.Tactic.ComputeAsymptotics.Multiseries.Corecursion | {
"line": 83,
"column": 4
} | {
"line": 83,
"column": 36
} | [
{
"pp": "α : Type u_1\nβ : Type u_2\nγ : Type u_3\nγ' : Type u_4\nthis : IsClosed fun x ↦ ∀ {n : ℕ}, x n = none → x (n + 1) = none\n⊢ CompleteSpace (Stream'.Seq α)",
"usedConstants": [
"PseudoMetricSpace.toUniformSpace",
"instOfNatNat",
"Stream'",
"Option.none",
"instHAdd",
... | apply IsClosed.completeSpace_coe | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Tactic.ComputeAsymptotics.Multiseries.Corecursion | {
"line": 83,
"column": 4
} | {
"line": 83,
"column": 36
} | [
{
"pp": "α : Type u_1\nβ : Type u_2\nγ : Type u_3\nγ' : Type u_4\nthis : IsClosed fun x ↦ ∀ {n : ℕ}, x n = none → x (n + 1) = none\n⊢ CompleteSpace (Stream'.Seq α)",
"usedConstants": [
"PseudoMetricSpace.toUniformSpace",
"instOfNatNat",
"Stream'",
"Option.none",
"instHAdd",
... | apply IsClosed.completeSpace_coe | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.SetTheory.Ordinal.Notation | {
"line": 870,
"column": 20
} | {
"line": 870,
"column": 29
} | [
{
"pp": "case succ.refine_2.e_a.succ.ba\na0 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\nn✝ : ℕ\nh : a'.repr + ↑(n✝ + 1) < ω ^ a0.repr\nR' : ... | opow_succ | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.SetTheory.Ordinal.Notation | {
"line": 999,
"column": 11
} | {
"line": 1000,
"column": 95
} | [
{
"pp": "case oadd.inl.none.inl.none.zero\na : ONote\nm : ℕ+\nb : ONote\niha : a = 0\nihb : b = 0\ne✝ : b.fundamentalSequence = Sum.inl none\ne : a.fundamentalSequence = Sum.inl none\ne' : m.natPred = 0\n⊢ (a.oadd 1 b).repr = succ zero.repr ∧ ((a.oadd 1 b).NF → zero.NF)",
"usedConstants": []
}
] | rw [show m = (m' + 1).succPNat by
rw [← e', ← PNat.coe_inj, Nat.succPNat_coe, ← Nat.add_one, PNat.natPred_add_one]] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.SetTheory.Ordinal.Notation | {
"line": 999,
"column": 11
} | {
"line": 1000,
"column": 95
} | [
{
"pp": "case oadd.inl.none.inl.none.zero\na : ONote\nm : ℕ+\nb : ONote\niha : a = 0\nihb : b = 0\ne✝ : b.fundamentalSequence = Sum.inl none\ne : a.fundamentalSequence = Sum.inl none\ne' : m.natPred = 0\n⊢ (a.oadd 1 b).repr = succ zero.repr ∧ ((a.oadd 1 b).NF → zero.NF)",
"usedConstants": []
}
] | rw [show m = (m' + 1).succPNat by
rw [← e', ← PNat.coe_inj, Nat.succPNat_coe, ← Nat.add_one, PNat.natPred_add_one]] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.SetTheory.Ordinal.Notation | {
"line": 999,
"column": 11
} | {
"line": 1000,
"column": 95
} | [
{
"pp": "case oadd.inl.none.inl.none.zero\na : ONote\nm : ℕ+\nb : ONote\niha : a = 0\nihb : b = 0\ne✝ : b.fundamentalSequence = Sum.inl none\ne : a.fundamentalSequence = Sum.inl none\ne' : m.natPred = 0\n⊢ (a.oadd 1 b).repr = succ zero.repr ∧ ((a.oadd 1 b).NF → zero.NF)",
"usedConstants": []
}
] | rw [show m = (m' + 1).succPNat by
rw [← e', ← PNat.coe_inj, Nat.succPNat_coe, ← Nat.add_one, PNat.natPred_add_one]] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.SetTheory.Ordinal.Notation | {
"line": 999,
"column": 11
} | {
"line": 1000,
"column": 95
} | [
{
"pp": "case oadd.inl.none.inl.none.succ\na : ONote\nm : ℕ+\nb : ONote\niha : a = 0\nihb : b = 0\ne✝ : b.fundamentalSequence = Sum.inl none\ne : a.fundamentalSequence = Sum.inl none\nm' : ℕ\ne' : m.natPred = m' + 1\n⊢ (a.oadd m b).repr = succ (zero.oadd m'.succPNat zero).repr ∧ ((a.oadd m b).NF → (zero.oadd m'... | rw [show m = (m' + 1).succPNat by
rw [← e', ← PNat.coe_inj, Nat.succPNat_coe, ← Nat.add_one, PNat.natPred_add_one]] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.SetTheory.Ordinal.Notation | {
"line": 999,
"column": 11
} | {
"line": 1000,
"column": 95
} | [
{
"pp": "case oadd.inl.none.inl.none.succ\na : ONote\nm : ℕ+\nb : ONote\niha : a = 0\nihb : b = 0\ne✝ : b.fundamentalSequence = Sum.inl none\ne : a.fundamentalSequence = Sum.inl none\nm' : ℕ\ne' : m.natPred = m' + 1\n⊢ (a.oadd m b).repr = succ (zero.oadd m'.succPNat zero).repr ∧ ((a.oadd m b).NF → (zero.oadd m'... | rw [show m = (m' + 1).succPNat by
rw [← e', ← PNat.coe_inj, Nat.succPNat_coe, ← Nat.add_one, PNat.natPred_add_one]] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.SetTheory.Ordinal.Notation | {
"line": 999,
"column": 11
} | {
"line": 1000,
"column": 95
} | [
{
"pp": "case oadd.inl.none.inl.none.succ\na : ONote\nm : ℕ+\nb : ONote\niha : a = 0\nihb : b = 0\ne✝ : b.fundamentalSequence = Sum.inl none\ne : a.fundamentalSequence = Sum.inl none\nm' : ℕ\ne' : m.natPred = m' + 1\n⊢ (a.oadd m b).repr = succ (zero.oadd m'.succPNat zero).repr ∧ ((a.oadd m b).NF → (zero.oadd m'... | rw [show m = (m' + 1).succPNat by
rw [← e', ← PNat.coe_inj, Nat.succPNat_coe, ← Nat.add_one, PNat.natPred_add_one]] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.SetTheory.Ordinal.Notation | {
"line": 999,
"column": 11
} | {
"line": 1000,
"column": 95
} | [
{
"pp": "case oadd.inl.none.inl.some.zero\na : ONote\nm : ℕ+\nb : ONote\nihb : b = 0\ne✝ : b.fundamentalSequence = Sum.inl none\na' : ONote\niha : a.repr = succ a'.repr ∧ (a.NF → a'.NF)\ne : a.fundamentalSequence = Sum.inl (some a')\ne' : m.natPred = 0\n⊢ IsSuccLimit (a.oadd 1 b).repr ∧\n (∀ (i : ℕ),\n ... | rw [show m = (m' + 1).succPNat by
rw [← e', ← PNat.coe_inj, Nat.succPNat_coe, ← Nat.add_one, PNat.natPred_add_one]] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.SetTheory.Ordinal.Notation | {
"line": 999,
"column": 11
} | {
"line": 1000,
"column": 95
} | [
{
"pp": "case oadd.inl.none.inl.some.zero\na : ONote\nm : ℕ+\nb : ONote\nihb : b = 0\ne✝ : b.fundamentalSequence = Sum.inl none\na' : ONote\niha : a.repr = succ a'.repr ∧ (a.NF → a'.NF)\ne : a.fundamentalSequence = Sum.inl (some a')\ne' : m.natPred = 0\n⊢ IsSuccLimit (a.oadd 1 b).repr ∧\n (∀ (i : ℕ),\n ... | rw [show m = (m' + 1).succPNat by
rw [← e', ← PNat.coe_inj, Nat.succPNat_coe, ← Nat.add_one, PNat.natPred_add_one]] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.SetTheory.Ordinal.Notation | {
"line": 999,
"column": 11
} | {
"line": 1000,
"column": 95
} | [
{
"pp": "case oadd.inl.none.inl.some.zero\na : ONote\nm : ℕ+\nb : ONote\nihb : b = 0\ne✝ : b.fundamentalSequence = Sum.inl none\na' : ONote\niha : a.repr = succ a'.repr ∧ (a.NF → a'.NF)\ne : a.fundamentalSequence = Sum.inl (some a')\ne' : m.natPred = 0\n⊢ IsSuccLimit (a.oadd 1 b).repr ∧\n (∀ (i : ℕ),\n ... | rw [show m = (m' + 1).succPNat by
rw [← e', ← PNat.coe_inj, Nat.succPNat_coe, ← Nat.add_one, PNat.natPred_add_one]] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.SetTheory.Ordinal.Notation | {
"line": 999,
"column": 11
} | {
"line": 1000,
"column": 95
} | [
{
"pp": "case oadd.inl.none.inl.some.succ\na : ONote\nm : ℕ+\nb : ONote\nihb : b = 0\ne✝ : b.fundamentalSequence = Sum.inl none\na' : ONote\niha : a.repr = succ a'.repr ∧ (a.NF → a'.NF)\ne : a.fundamentalSequence = Sum.inl (some a')\nm' : ℕ\ne' : m.natPred = m' + 1\n⊢ IsSuccLimit (a.oadd m b).repr ∧\n (∀ (i ... | rw [show m = (m' + 1).succPNat by
rw [← e', ← PNat.coe_inj, Nat.succPNat_coe, ← Nat.add_one, PNat.natPred_add_one]] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.SetTheory.Ordinal.Notation | {
"line": 999,
"column": 11
} | {
"line": 1000,
"column": 95
} | [
{
"pp": "case oadd.inl.none.inl.some.succ\na : ONote\nm : ℕ+\nb : ONote\nihb : b = 0\ne✝ : b.fundamentalSequence = Sum.inl none\na' : ONote\niha : a.repr = succ a'.repr ∧ (a.NF → a'.NF)\ne : a.fundamentalSequence = Sum.inl (some a')\nm' : ℕ\ne' : m.natPred = m' + 1\n⊢ IsSuccLimit (a.oadd m b).repr ∧\n (∀ (i ... | rw [show m = (m' + 1).succPNat by
rw [← e', ← PNat.coe_inj, Nat.succPNat_coe, ← Nat.add_one, PNat.natPred_add_one]] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.SetTheory.Ordinal.Notation | {
"line": 999,
"column": 11
} | {
"line": 1000,
"column": 95
} | [
{
"pp": "case oadd.inl.none.inl.some.succ\na : ONote\nm : ℕ+\nb : ONote\nihb : b = 0\ne✝ : b.fundamentalSequence = Sum.inl none\na' : ONote\niha : a.repr = succ a'.repr ∧ (a.NF → a'.NF)\ne : a.fundamentalSequence = Sum.inl (some a')\nm' : ℕ\ne' : m.natPred = m' + 1\n⊢ IsSuccLimit (a.oadd m b).repr ∧\n (∀ (i ... | rw [show m = (m' + 1).succPNat by
rw [← e', ← PNat.coe_inj, Nat.succPNat_coe, ← Nat.add_one, PNat.natPred_add_one]] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.SetTheory.Ordinal.Notation | {
"line": 999,
"column": 11
} | {
"line": 1000,
"column": 95
} | [
{
"pp": "case oadd.inl.none.inr.zero\na : ONote\nm : ℕ+\nb : ONote\nihb : b = 0\ne✝ : b.fundamentalSequence = Sum.inl none\nf : ℕ → ONote\niha :\n IsSuccLimit a.repr ∧\n (∀ (i : ℕ), f i < f (i + 1) ∧ f i < a ∧ (a.NF → (f i).NF)) ∧ ∀ a_1 < a.repr, ∃ i, a_1 < (f i).repr\ne : a.fundamentalSequence = Sum.inr f\... | rw [show m = (m' + 1).succPNat by
rw [← e', ← PNat.coe_inj, Nat.succPNat_coe, ← Nat.add_one, PNat.natPred_add_one]] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.SetTheory.Ordinal.Notation | {
"line": 999,
"column": 11
} | {
"line": 1000,
"column": 95
} | [
{
"pp": "case oadd.inl.none.inr.zero\na : ONote\nm : ℕ+\nb : ONote\nihb : b = 0\ne✝ : b.fundamentalSequence = Sum.inl none\nf : ℕ → ONote\niha :\n IsSuccLimit a.repr ∧\n (∀ (i : ℕ), f i < f (i + 1) ∧ f i < a ∧ (a.NF → (f i).NF)) ∧ ∀ a_1 < a.repr, ∃ i, a_1 < (f i).repr\ne : a.fundamentalSequence = Sum.inr f\... | rw [show m = (m' + 1).succPNat by
rw [← e', ← PNat.coe_inj, Nat.succPNat_coe, ← Nat.add_one, PNat.natPred_add_one]] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.SetTheory.Ordinal.Notation | {
"line": 999,
"column": 11
} | {
"line": 1000,
"column": 95
} | [
{
"pp": "case oadd.inl.none.inr.zero\na : ONote\nm : ℕ+\nb : ONote\nihb : b = 0\ne✝ : b.fundamentalSequence = Sum.inl none\nf : ℕ → ONote\niha :\n IsSuccLimit a.repr ∧\n (∀ (i : ℕ), f i < f (i + 1) ∧ f i < a ∧ (a.NF → (f i).NF)) ∧ ∀ a_1 < a.repr, ∃ i, a_1 < (f i).repr\ne : a.fundamentalSequence = Sum.inr f\... | rw [show m = (m' + 1).succPNat by
rw [← e', ← PNat.coe_inj, Nat.succPNat_coe, ← Nat.add_one, PNat.natPred_add_one]] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.SetTheory.Ordinal.Notation | {
"line": 999,
"column": 11
} | {
"line": 1000,
"column": 95
} | [
{
"pp": "case oadd.inl.none.inr.succ\na : ONote\nm : ℕ+\nb : ONote\nihb : b = 0\ne✝ : b.fundamentalSequence = Sum.inl none\nf : ℕ → ONote\niha :\n IsSuccLimit a.repr ∧\n (∀ (i : ℕ), f i < f (i + 1) ∧ f i < a ∧ (a.NF → (f i).NF)) ∧ ∀ a_1 < a.repr, ∃ i, a_1 < (f i).repr\ne : a.fundamentalSequence = Sum.inr f\... | rw [show m = (m' + 1).succPNat by
rw [← e', ← PNat.coe_inj, Nat.succPNat_coe, ← Nat.add_one, PNat.natPred_add_one]] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.SetTheory.Ordinal.Notation | {
"line": 999,
"column": 11
} | {
"line": 1000,
"column": 95
} | [
{
"pp": "case oadd.inl.none.inr.succ\na : ONote\nm : ℕ+\nb : ONote\nihb : b = 0\ne✝ : b.fundamentalSequence = Sum.inl none\nf : ℕ → ONote\niha :\n IsSuccLimit a.repr ∧\n (∀ (i : ℕ), f i < f (i + 1) ∧ f i < a ∧ (a.NF → (f i).NF)) ∧ ∀ a_1 < a.repr, ∃ i, a_1 < (f i).repr\ne : a.fundamentalSequence = Sum.inr f\... | rw [show m = (m' + 1).succPNat by
rw [← e', ← PNat.coe_inj, Nat.succPNat_coe, ← Nat.add_one, PNat.natPred_add_one]] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.SetTheory.Ordinal.Notation | {
"line": 999,
"column": 11
} | {
"line": 1000,
"column": 95
} | [
{
"pp": "case oadd.inl.none.inr.succ\na : ONote\nm : ℕ+\nb : ONote\nihb : b = 0\ne✝ : b.fundamentalSequence = Sum.inl none\nf : ℕ → ONote\niha :\n IsSuccLimit a.repr ∧\n (∀ (i : ℕ), f i < f (i + 1) ∧ f i < a ∧ (a.NF → (f i).NF)) ∧ ∀ a_1 < a.repr, ∃ i, a_1 < (f i).repr\ne : a.fundamentalSequence = Sum.inr f\... | rw [show m = (m' + 1).succPNat by
rw [← e', ← PNat.coe_inj, Nat.succPNat_coe, ← Nat.add_one, PNat.natPred_add_one]] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.SetTheory.Ordinal.Notation | {
"line": 1024,
"column": 53
} | {
"line": 1024,
"column": 62
} | [
{
"pp": "case oadd.inl.none.inl.some.succ.refine_2\na : ONote\nm : ℕ+\nb : ONote\nihb : b = 0\ne✝ : b.fundamentalSequence = Sum.inl none\na' : ONote\niha : a.repr = succ a'.repr ∧ (a.NF → a'.NF)\ne : a.fundamentalSequence = Sum.inl (some a')\nm' : ℕ\ne' : m.natPred = m' + 1\nthis : 0 < ω ^ a'.repr\ni : ℕ\nH : (... | opow_succ | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Tactic.Simproc.FinsetInterval | {
"line": 272,
"column": 25
} | {
"line": 272,
"column": 55
} | [
{
"pp": "⊢ Ico 1 1 = ∅",
"usedConstants": [
"congrArg",
"Finset",
"Nat.instLocallyFiniteOrder",
"Finset.Ico",
"_private.Mathlib.Tactic.Simproc.FinsetInterval.0.Mathlib.Tactic.Simp.Nat.Icc_eq_empty_of_lt",
"instOfNatNat",
"_private.Mathlib.Tactic.Simproc.FinsetInterv... | by simp only [Ico_ofNat_ofNat] | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Tactic.Simproc.FinsetInterval | {
"line": 273,
"column": 27
} | {
"line": 273,
"column": 57
} | [
{
"pp": "⊢ Ico 1 2 = {1}",
"usedConstants": [
"congrArg",
"Finset",
"Nat.instLocallyFiniteOrder",
"Finset.Ico",
"instOfNatNat",
"_private.Mathlib.Tactic.Simproc.FinsetInterval.0.Mathlib.Tactic.Simp.Nat.Ico_succ_eq_of_Icc_eq",
"Nat.instPreorder",
"Finset.Icc_se... | by simp only [Ico_ofNat_ofNat] | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Tactic.Simproc.FinsetInterval | {
"line": 274,
"column": 30
} | {
"line": 274,
"column": 60
} | [
{
"pp": "⊢ Ico 1 3 = {1, 2}",
"usedConstants": [
"congrArg",
"_private.Mathlib.Tactic.Simproc.FinsetInterval.0.Mathlib.Tactic.Simp.Nat.Icc_eq_insert_of_Icc_succ_eq",
"Finset",
"Nat.instLocallyFiniteOrder",
"Finset.Ico",
"Insert.insert",
"instOfNatNat",
"_priva... | by simp only [Ico_ofNat_ofNat] | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Tactic.Simproc.FinsetInterval | {
"line": 298,
"column": 31
} | {
"line": 298,
"column": 61
} | [
{
"pp": "⊢ Ico 1 1 = ∅",
"usedConstants": [
"of_decide_eq_true",
"congrArg",
"Finset",
"_private.Mathlib.Tactic.Simproc.FinsetInterval.0.Mathlib.Tactic.Simp.Int.Ico_eq_of_Icc_pred_eq",
"PartialOrder.toPreorder",
"SemilatticeInf.toPartialOrder",
"id",
"Finset.I... | by simp only [Ico_ofNat_ofNat] | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Tactic.Simproc.FinsetInterval | {
"line": 299,
"column": 33
} | {
"line": 299,
"column": 63
} | [
{
"pp": "⊢ Ico 1 2 = {1}",
"usedConstants": [
"congrArg",
"Finset",
"_private.Mathlib.Tactic.Simproc.FinsetInterval.0.Mathlib.Tactic.Simp.Int.Ico_eq_of_Icc_pred_eq",
"PartialOrder.toPreorder",
"SemilatticeInf.toPartialOrder",
"Finset.Ico",
"Int",
"Int.instLoca... | by simp only [Ico_ofNat_ofNat] | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Tactic.Simproc.FinsetInterval | {
"line": 300,
"column": 36
} | {
"line": 300,
"column": 66
} | [
{
"pp": "⊢ Ico 1 3 = {1, 2}",
"usedConstants": [
"of_decide_eq_true",
"congrArg",
"Finset",
"_private.Mathlib.Tactic.Simproc.FinsetInterval.0.Mathlib.Tactic.Simp.Int.Ico_eq_of_Icc_pred_eq",
"PartialOrder.toPreorder",
"Int.decLe",
"SemilatticeInf.toPartialOrder",
... | by simp only [Ico_ofNat_ofNat] | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Testing.Plausible.Functions | {
"line": 190,
"column": 2
} | {
"line": 190,
"column": 19
} | [
{
"pp": "α : Type u\ninst✝ : DecidableEq α\nxs : List (α × α)\nx y z : α\n⊢ (if h : y = x then some z else dlookup x (map Prod.toSigma xs)).getD x =\n if y = x then z else (dlookup x (map Prod.toSigma xs)).getD x",
"usedConstants": [
"Eq.mpr",
"Prod.toSigma",
"congrArg",
"List.map... | split_ifs <;> rfl | Lean.Parser.Tactic.«_aux_Init_Tactics___macroRules_Lean_Parser_Tactic_tactic_<;>__1» | Lean.Parser.Tactic.«tactic_<;>_» |
Mathlib.Testing.Plausible.Functions | {
"line": 260,
"column": 2
} | {
"line": 260,
"column": 32
} | [
{
"pp": "α : Type u\ninst✝ : DecidableEq α\nxs ys : List α\nx : α\nh : x ∉ xs\ny : α\nhy : (x, y) ∈ xs.zip ys\n⊢ False",
"usedConstants": [
"Membership.mem",
"List",
"List.instMembership",
"And.left",
"List.of_mem_zip"
]
}
] | exact h (List.of_mem_zip hy).1 | Lean.Elab.Tactic.evalExact | Lean.Parser.Tactic.exact |
Mathlib.Topology.UniformSpace.Ascoli | {
"line": 504,
"column": 2
} | {
"line": 504,
"column": 98
} | [
{
"pp": "X : Type u_2\nα : Type u_3\ninst✝¹ : TopologicalSpace X\ninst✝ : UniformSpace α\nS : Set C(X, α)\nhS1 : IsCompact (ContinuousMap.toFun '' S)\nhS2 : Equicontinuous fun x ↦ ⇑↑x\n⊢ ⋃₀ {K | IsCompact K} = univ",
"usedConstants": [
"Iff.mpr",
"Set.mem_singleton",
"Set.univ",
"Set... | · exact eq_univ_iff_forall.mpr (fun x ↦ mem_sUnion_of_mem (mem_singleton x) isCompact_singleton) | Lean.Elab.Tactic.evalTacticCDot | Lean.cdot |
Mathlib.Topology.Algebra.Group.OpenMapping | {
"line": 78,
"column": 8
} | {
"line": 78,
"column": 19
} | [
{
"pp": "G : Type u_1\nX : Type u_2\ninst✝⁹ : TopologicalSpace G\ninst✝⁸ : TopologicalSpace X\ninst✝⁷ : Group G\ninst✝⁶ : IsTopologicalGroup G\ninst✝⁵ : MulAction G X\ninst✝⁴ : SigmaCompactSpace G\ninst✝³ : BaireSpace X\ninst✝² : T2Space X\ninst✝¹ : ContinuousSMul G X\ninst✝ : IsPretransitive G X\nU : Set G\nhU... | smul_assoc, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Topology.Algebra.Group.OpenMapping | {
"line": 83,
"column": 9
} | {
"line": 83,
"column": 20
} | [
{
"pp": "G : Type u_1\nX : Type u_2\ninst✝⁹ : TopologicalSpace G\ninst✝⁸ : TopologicalSpace X\ninst✝⁷ : Group G\ninst✝⁶ : IsTopologicalGroup G\ninst✝⁵ : MulAction G X\ninst✝⁴ : SigmaCompactSpace G\ninst✝³ : BaireSpace X\ninst✝² : T2Space X\ninst✝¹ : ContinuousSMul G X\ninst✝ : IsPretransitive G X\nU : Set G\nhU... | smul_assoc, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Topology.Algebra.IsOpenUnits | {
"line": 82,
"column": 4
} | {
"line": 85,
"column": 44
} | [
{
"pp": "R : Type u_1\ninst✝² : CommRing R\ninst✝¹ : TopologicalSpace R\ninst✝ : IsTopologicalRing R\nI : Ideal R\nhR : IsAdic I\nhI : I ≤ ⊥.jacobson\ns : Set R\nhs : s ∈ Filter.map (⇑(Units.coeHom R)) (Filter.comap (⇑(Units.embedProduct R)) (𝓝 1 ×ˢ 𝓝 1))\nH : (𝓝 1).HasBasis (fun _n ↦ True) fun n ↦ (fun y ↦ ... | obtain ⟨n₁, n₂, H⟩ := this
exact ⟨n₁ ⊔ n₂ ⊔ 1, by simp, fun u h₁ h₂ ↦ H u
(Ideal.pow_le_pow_right (by simp) h₁)
(Ideal.pow_le_pow_right (by simp) h₂)⟩ | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Topology.Algebra.IsOpenUnits | {
"line": 82,
"column": 4
} | {
"line": 85,
"column": 44
} | [
{
"pp": "R : Type u_1\ninst✝² : CommRing R\ninst✝¹ : TopologicalSpace R\ninst✝ : IsTopologicalRing R\nI : Ideal R\nhR : IsAdic I\nhI : I ≤ ⊥.jacobson\ns : Set R\nhs : s ∈ Filter.map (⇑(Units.coeHom R)) (Filter.comap (⇑(Units.embedProduct R)) (𝓝 1 ×ˢ 𝓝 1))\nH : (𝓝 1).HasBasis (fun _n ↦ True) fun n ↦ (fun y ↦ ... | obtain ⟨n₁, n₂, H⟩ := this
exact ⟨n₁ ⊔ n₂ ⊔ 1, by simp, fun u h₁ h₂ ↦ H u
(Ideal.pow_le_pow_right (by simp) h₁)
(Ideal.pow_le_pow_right (by simp) h₂)⟩ | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Topology.Algebra.IsOpenUnits | {
"line": 94,
"column": 10
} | {
"line": 94,
"column": 18
} | [
{
"pp": "R : Type u_1\ninst✝² : CommRing R\ninst✝¹ : TopologicalSpace R\ninst✝ : IsTopologicalRing R\nI : Ideal R\nhR : IsAdic I\nhI : I ≤ ⊥.jacobson\ns : Set R\nhs : s ∈ Filter.map (⇑(Units.coeHom R)) (Filter.comap (⇑(Units.embedProduct R)) (𝓝 1 ×ˢ 𝓝 1))\nH : (𝓝 1).HasBasis (fun _n ↦ True) fun n ↦ (fun y ↦ ... | mul_add, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Topology.Baire.BaireMeasurable | {
"line": 143,
"column": 4
} | {
"line": 143,
"column": 28
} | [
{
"pp": "case iUnion\nα : Type u_1\ninst✝² : TopologicalSpace α\ns : Set α\ninst✝¹ : MeasurableSpace α\ninst✝ : BorelSpace α\nf : ℕ → Set α\na✝ : Pairwise (Function.onFun Disjoint f)\nhf✝ : ∀ (i : ℕ), MeasurableSet (f i)\nihf : ∀ (i : ℕ), ∃ u, IsOpen u ∧ f i =ᶠ[residual α] u\n⊢ ∃ u, IsOpen u ∧ ⋃ i, f i =ᶠ[resid... | choose u uo su using ihf | Mathlib.Tactic.Choose._aux_Mathlib_Tactic_Choose___elabRules_Mathlib_Tactic_Choose_choose_1 | Mathlib.Tactic.Choose.choose |
Mathlib.Topology.Category.Compactum | {
"line": 238,
"column": 4
} | {
"line": 238,
"column": 72
} | [
{
"pp": "X : Compactum\nA : Set X.A\nF : Ultrafilter X.A\nhF : F ∈ basic (cl A)\nfsu : Type u_1 := Finset (Set (Ultrafilter X.A))\nssu : Type u_1 := Set (Set (Ultrafilter X.A))\nι : fsu → ssu := fun x ↦ ↑x\nC0 : ssu := {Z | ∃ B ∈ F, X.str ⁻¹' B = Z}\nAA : Set (Ultrafilter X.A) := {G | A ∈ G}\nC1 : ssu := insert... | obtain ⟨G, h1⟩ := exists_ultrafilter_of_finite_inter_nonempty _ this | _private.Lean.Elab.Tactic.RCases.0.Lean.Elab.Tactic.RCases.evalObtain | Lean.Parser.Tactic.obtain |
Mathlib.Topology.Category.Profinite.Product | {
"line": 122,
"column": 8
} | {
"line": 129,
"column": 13
} | [
{
"pp": "ι : Type u\nX : ι → Type\ninst✝² : (i : ι) → TopologicalSpace (X i)\nC : Set ((i : ι) → X i)\nJ K : ι → Prop\ninst✝¹ : ∀ (i : ι), T2Space (X i)\ninst✝ : ∀ (i : ι), TotallyDisconnectedSpace (X i)\nhC : IsCompact C\nthis : CompactSpace ↑C\na : (fun X ↦ ↑X.toTop) (limitCone (indexFunctor hC)).pt\nhc : ∀ (... | have H₁ : ∀ (Q₁ Q₂ : Finset ι), Q₁ ≤ Q₂ →
π_app C (· ∈ Q₁) ⁻¹' {a.val (op Q₁)} ⊇
π_app C (· ∈ Q₂) ⁻¹' {a.val (op Q₂)} := by
intro J K h x hx
simp only [Set.mem_preimage] at hx ⊢
rw [← map_comp_π_app C h, Function.comp_apply,
hx, ← a.prop (homOfLE h).op]
... | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_tacticHave___1 | Lean.Parser.Tactic.tacticHave__ |
Mathlib.Topology.Category.Compactum | {
"line": 402,
"column": 4
} | {
"line": 402,
"column": 16
} | [
{
"pp": "case h\nX : Type u_1\ninst✝² : TopologicalSpace X\ninst✝¹ : CompactSpace X\ninst✝ : T2Space X\nFF : Ultrafilter (Ultrafilter X)\nx : X := (Ultrafilter.map Ultrafilter.lim FF).lim\nc1 : x = (Ultrafilter.map Ultrafilter.lim FF).lim\nc2 : ∀ (U : Set X) (F : Ultrafilter X), F.lim ∈ U → IsOpen U → U ∈ F\nc3... | apply lim_eq | Lean.Elab.Tactic.evalApply | Lean.Parser.Tactic.apply |
Mathlib.Topology.Category.Profinite.Nobeling.Span | {
"line": 109,
"column": 11
} | {
"line": 109,
"column": 34
} | [
{
"pp": "case pos\nI : Type u\nC : Set (I → Bool)\ninst✝ : LinearOrder I\ns : Finset I\nx y : ↑(π C fun x ↦ x ∈ s)\nh : y = x\nb : I\nleft✝ : b ∈ s.sort fun x1 x2 ↦ x1 ≥ x2\nhh : ↑x b = true\n⊢ { toFun := fun f ↦ if ↑f b = true then 1 else 0, isLocallyConstant := ⋯ } x = 1",
"usedConstants": [
"Locall... | LocallyConstant.coe_mk, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Topology.Category.Profinite.Nobeling.Span | {
"line": 110,
"column": 38
} | {
"line": 110,
"column": 61
} | [
{
"pp": "case neg\nI : Type u\nC : Set (I → Bool)\ninst✝ : LinearOrder I\ns : Finset I\nx y : ↑(π C fun x ↦ x ∈ s)\nh : y = x\nb : I\nleft✝ : b ∈ s.sort fun x1 x2 ↦ x1 ≥ x2\nhh : ¬↑x b = true\n⊢ 1 x - { toFun := fun f ↦ if ↑f b = true then 1 else 0, isLocallyConstant := ⋯ } x = 1",
"usedConstants": [
... | LocallyConstant.coe_mk, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Topology.Category.Profinite.Nobeling.Span | {
"line": 110,
"column": 62
} | {
"line": 110,
"column": 85
} | [
{
"pp": "case neg\nI : Type u\nC : Set (I → Bool)\ninst✝ : LinearOrder I\ns : Finset I\nx y : ↑(π C fun x ↦ x ∈ s)\nh : y = x\nb : I\nleft✝ : b ∈ s.sort fun x1 x2 ↦ x1 ≥ x2\nhh : ¬↑x b = true\n⊢ LocallyConstant.toFun 1 x - { toFun := fun f ↦ if ↑f b = true then 1 else 0, isLocallyConstant := ⋯ } x = 1",
"us... | LocallyConstant.coe_mk, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Topology.CWComplex.Classical.Basic | {
"line": 289,
"column": 13
} | {
"line": 292,
"column": 55
} | [
{
"pp": "X : Type u_1\nt : TopologicalSpace X\nC D : Set X\ninst✝ : RelCWComplex C D\nI J : (n : ℕ) → Set (cell C n)\nhIJ : D ∪ ⋃ n, ⋃ j, openCell n ↑j = D ∪ ⋃ n, ⋃ j, openCell n ↑j\n⊢ I = J",
"usedConstants": [
"Set.ext",
"Topology.RelCWComplex.openCell",
"Membership.mem",
"Set.inst... | by
ext n x
exact ⟨fun h ↦ subset_of_eq_union_iUnion I J hIJ n h,
fun h ↦ subset_of_eq_union_iUnion J I hIJ.symm n h⟩ | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Topology.Category.Profinite.Nobeling.Span | {
"line": 138,
"column": 45
} | {
"line": 138,
"column": 68
} | [
{
"pp": "case a.false\nI : Type u\nC : Set (I → Bool)\ninst✝ : LinearOrder I\ns : Finset I\nx y : ↑(π C fun x ↦ x ∈ s)\nh : y ≠ x\na : I\nha : ↑y a = true\nhx : ↑x a = false\n⊢ 1 - { toFun := fun f ↦ if ↑f a = true then 1 else 0, isLocallyConstant := ⋯ } y = 0",
"usedConstants": [
"LocallyConstant.mk"... | LocallyConstant.coe_mk, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Topology.Category.Profinite.Nobeling.Span | {
"line": 141,
"column": 48
} | {
"line": 141,
"column": 71
} | [
{
"pp": "case a.true\nI : Type u\nC : Set (I → Bool)\ninst✝ : LinearOrder I\ns : Finset I\nx y : ↑(π C fun x ↦ x ∈ s)\nh : y ≠ x\na : I\nha : ↑y a ≠ true\nhx : ↑x a = true\n⊢ { toFun := fun f ↦ if ↑f a = true then 1 else 0, isLocallyConstant := ⋯ } y = 0",
"usedConstants": [
"LocallyConstant.mk",
... | LocallyConstant.coe_mk, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Topology.Category.Profinite.Nobeling.Basic | {
"line": 251,
"column": 6
} | {
"line": 251,
"column": 33
} | [
{
"pp": "case h.h\nI : 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)\ninst✝ : (s : Finset I) → (i : I) → Decidable (i ∈ s)\nhC : IsCompact C\nx✝ : (Finset I)ᵒᵖ\ns : Finset I\na✝ : ↑(((Functor.const (Finset... | exact congr_fun this.symm _ | Lean.Elab.Tactic.evalExact | Lean.Parser.Tactic.exact |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.