module stringlengths 16 90 | startPos dict | endPos dict | goals listlengths 0 96 | ppTac stringlengths 1 14.5k | elaborator stringclasses 366
values | kind stringclasses 370
values |
|---|---|---|---|---|---|---|
Mathlib.RingTheory.Radical.NatInt | {
"line": 112,
"column": 17
} | {
"line": 112,
"column": 25
} | [
{
"pp": "z : ℤ\nhz : z ≠ 0\np : ℕ\nx✝ : Prime ↑p ∧ 0 ≤ ↑p ∧ ↑p ∣ z\npp : Nat.Prime p\ndp : p ∣ z.natAbs\n⊢ p ∈ z.natAbs.primeFactors",
"usedConstants": [
"False",
"Nat.Prime",
"Dvd.dvd",
"eq_false",
"congrArg",
"and_self",
"Finset",
"Membership.mem",
"id... | simp_all | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.RingTheory.Radical.NatInt | {
"line": 112,
"column": 17
} | {
"line": 112,
"column": 25
} | [
{
"pp": "z : ℤ\nhz : z ≠ 0\np : ℕ\nx✝ : Prime ↑p ∧ 0 ≤ ↑p ∧ ↑p ∣ z\npp : Nat.Prime p\ndp : p ∣ z.natAbs\n⊢ p ∈ z.natAbs.primeFactors",
"usedConstants": [
"False",
"Nat.Prime",
"Dvd.dvd",
"eq_false",
"congrArg",
"and_self",
"Finset",
"Membership.mem",
"id... | simp_all | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.RingTheory.Radical.NatInt | {
"line": 113,
"column": 2
} | {
"line": 116,
"column": 27
} | [
{
"pp": "case inr.h.refine_2\nz : ℤ\nhz : z ≠ 0\np : ℤ\nh : ∃ a ∈ z.natAbs.primeFactors, Nat.castEmbedding.toFun a = p\n⊢ Prime p ∧ 0 ≤ p ∧ p ∣ z",
"usedConstants": [
"Eq.mpr",
"NonAssocSemiring.toAddCommMonoidWithOne",
"Int.instIsStrictOrderedRing",
"Nat.Prime",
"Dvd.dvd",
... | · simp_rw [Nat.mem_primeFactors, Function.Embedding.toFun_eq_coe, Nat.castEmbedding_apply] at h
obtain ⟨n, ⟨pn, dn, -⟩, rfl⟩ := h
rw [Int.natCast_dvd, ← Nat.prime_iff_prime_int]
exact ⟨pn, by simp, dn⟩ | Lean.Elab.Tactic.evalTacticCDot | Lean.cdot |
Mathlib.RingTheory.PowerSeries.WeierstrassPreparation | {
"line": 138,
"column": 2
} | {
"line": 143,
"column": 58
} | [
{
"pp": "A : Type u_1\ninst✝ : CommRing A\nf g q : A⟦X⟧\nr : A[X]\nI : Ideal A\nH : f.IsWeierstrassDivisionAt g q r I\ni : ℕ\nhi : i < ((map (Ideal.Quotient.mk I)) g).order.toNat\n⊢ (coeff i) (f - ↑r) ∈ I",
"usedConstants": [
"PowerSeries.coeff_of_lt_order_toNat",
"Eq.mpr",
"RingHom.instRi... | replace H := H.2
rw [← sub_eq_iff_eq_add] at H
rw [H]
refine coeff_mul_mem_ideal_of_coeff_left_mem_ideal i (fun j hj ↦ ?_) i le_rfl
have := coeff_of_lt_order_toNat _ (lt_of_le_of_lt hj hi)
rwa [coeff_map, ← RingHom.mem_ker, Ideal.mk_ker] at this | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.RingTheory.PowerSeries.WeierstrassPreparation | {
"line": 138,
"column": 2
} | {
"line": 143,
"column": 58
} | [
{
"pp": "A : Type u_1\ninst✝ : CommRing A\nf g q : A⟦X⟧\nr : A[X]\nI : Ideal A\nH : f.IsWeierstrassDivisionAt g q r I\ni : ℕ\nhi : i < ((map (Ideal.Quotient.mk I)) g).order.toNat\n⊢ (coeff i) (f - ↑r) ∈ I",
"usedConstants": [
"PowerSeries.coeff_of_lt_order_toNat",
"Eq.mpr",
"RingHom.instRi... | replace H := H.2
rw [← sub_eq_iff_eq_add] at H
rw [H]
refine coeff_mul_mem_ideal_of_coeff_left_mem_ideal i (fun j hj ↦ ?_) i le_rfl
have := coeff_of_lt_order_toNat _ (lt_of_le_of_lt hj hi)
rwa [coeff_map, ← RingHom.mem_ker, Ideal.mk_ker] at this | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.RingTheory.RamificationInertia.Ramification | {
"line": 103,
"column": 2
} | {
"line": 110,
"column": 87
} | [
{
"pp": "R : Type u_1\nS : Type u_2\nT : Type u_3\ninst✝¹² : CommRing R\ninst✝¹¹ : CommRing S\ninst✝¹⁰ : CommRing T\ninst✝⁹ : Algebra R S\ninst✝⁸ : Algebra R T\ninst✝⁷ : Algebra S T\ninst✝⁶ : IsScalarTower R S T\nq : Ideal S\nr : Ideal T\ninst✝⁵ : q.IsPrime\ninst✝⁴ : r.IsPrime\ninst✝³ : r.LiesOver q\ninst✝² : A... | have : q.LiesOver (r.under R) := LiesOver.tower_bot r q (r.under R)
let f := (Ideal.quotientEquivAlgOfEq (Localization.AtPrime r)
(by rw [map_map, ← IsScalarTower.algebraMap_eq])).trans
(Algebra.TensorProduct.quotIdealMapEquivTensorQuot (Localization.AtPrime r)
((r.under R).map (algebraMap R (Locali... | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.RingTheory.RamificationInertia.Ramification | {
"line": 103,
"column": 2
} | {
"line": 110,
"column": 87
} | [
{
"pp": "R : Type u_1\nS : Type u_2\nT : Type u_3\ninst✝¹² : CommRing R\ninst✝¹¹ : CommRing S\ninst✝¹⁰ : CommRing T\ninst✝⁹ : Algebra R S\ninst✝⁸ : Algebra R T\ninst✝⁷ : Algebra S T\ninst✝⁶ : IsScalarTower R S T\nq : Ideal S\nr : Ideal T\ninst✝⁵ : q.IsPrime\ninst✝⁴ : r.IsPrime\ninst✝³ : r.LiesOver q\ninst✝² : A... | have : q.LiesOver (r.under R) := LiesOver.tower_bot r q (r.under R)
let f := (Ideal.quotientEquivAlgOfEq (Localization.AtPrime r)
(by rw [map_map, ← IsScalarTower.algebraMap_eq])).trans
(Algebra.TensorProduct.quotIdealMapEquivTensorQuot (Localization.AtPrime r)
((r.under R).map (algebraMap R (Locali... | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.RingTheory.Regular.Flat | {
"line": 90,
"column": 2
} | {
"line": 90,
"column": 82
} | [
{
"pp": "R : Type u_1\nS : Type u_2\nM : Type u_3\nN : Type u_4\ninst✝⁹ : CommRing R\ninst✝⁸ : CommRing S\ninst✝⁷ : Algebra R S\ninst✝⁶ : AddCommGroup M\ninst✝⁵ : Module R M\ninst✝⁴ : AddCommGroup N\ninst✝³ : Module R N\ninst✝² : Module S N\ninst✝¹ : IsScalarTower R S N\ninst✝ : FaithfullyFlat R S\nf : M →ₗ[R] ... | exact ((hf.map_smul_top_ne_top_iff_of_faithfullyFlat R M _).mpr reg.2.symm).symm | Lean.Elab.Tactic.evalExact | Lean.Parser.Tactic.exact |
Mathlib.RingTheory.PowerSeries.WeierstrassPreparation | {
"line": 381,
"column": 2
} | {
"line": 381,
"column": 57
} | [
{
"pp": "A : Type u_1\ninst✝¹ : CommRing A\ng : A⟦X⟧\nI : Ideal A\nH : g.IsWeierstrassDivisorAt I\na : A\nf : A⟦X⟧\ninst✝ : IsAdicComplete I A\n⊢ H.div (a • f) = a • H.div f",
"usedConstants": [
"instHSMul",
"Semiring.toModule",
"CommSemiring.toSemiring",
"PowerSeries.IsWeierstrassDi... | have H1 := (H.isWeierstrassDivisionAt_div_mod f).smul a | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_tacticHave___1 | Lean.Parser.Tactic.tacticHave__ |
Mathlib.RingTheory.PowerSeries.WeierstrassPreparation | {
"line": 399,
"column": 2
} | {
"line": 399,
"column": 57
} | [
{
"pp": "A : Type u_1\ninst✝¹ : CommRing A\ng : A⟦X⟧\nI : Ideal A\nH : g.IsWeierstrassDivisorAt I\na : A\nf : A⟦X⟧\ninst✝ : IsAdicComplete I A\n⊢ H.mod (a • f) = a • H.mod f",
"usedConstants": [
"instHSMul",
"Semiring.toModule",
"CommSemiring.toSemiring",
"PowerSeries.IsWeierstrassDi... | have H1 := (H.isWeierstrassDivisionAt_div_mod f).smul a | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_tacticHave___1 | Lean.Parser.Tactic.tacticHave__ |
Mathlib.RingTheory.SimpleModule.Isotypic | {
"line": 368,
"column": 25
} | {
"line": 368,
"column": 68
} | [
{
"pp": "R₀ : Type u_1\nR : Type u_2\nM : Type u\nN✝ : Type u_3\nS : Type u_4\ninst✝¹⁰ : CommSemiring R₀\ninst✝⁹ : Ring R\ninst✝⁸ : Algebra R₀ R\ninst✝⁷ : AddCommGroup M\ninst✝⁶ : AddCommGroup N✝\ninst✝⁵ : AddCommGroup S\ninst✝⁴ : Module R M\ninst✝³ : Module R N✝\ninst✝² : Module R S\ninst✝¹ : IsSimpleModule R ... | simpa only [map_add] using congr($h₁ + $h₂) | Lean.Elab.Tactic.Simpa.evalSimpa | Lean.Parser.Tactic.simpa |
Mathlib.RingTheory.SimpleModule.Isotypic | {
"line": 368,
"column": 25
} | {
"line": 368,
"column": 68
} | [
{
"pp": "R₀ : Type u_1\nR : Type u_2\nM : Type u\nN✝ : Type u_3\nS : Type u_4\ninst✝¹⁰ : CommSemiring R₀\ninst✝⁹ : Ring R\ninst✝⁸ : Algebra R₀ R\ninst✝⁷ : AddCommGroup M\ninst✝⁶ : AddCommGroup N✝\ninst✝⁵ : AddCommGroup S\ninst✝⁴ : Module R M\ninst✝³ : Module R N✝\ninst✝² : Module R S\ninst✝¹ : IsSimpleModule R ... | simpa only [map_add] using congr($h₁ + $h₂) | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.RingTheory.SimpleModule.Isotypic | {
"line": 368,
"column": 25
} | {
"line": 368,
"column": 68
} | [
{
"pp": "R₀ : Type u_1\nR : Type u_2\nM : Type u\nN✝ : Type u_3\nS : Type u_4\ninst✝¹⁰ : CommSemiring R₀\ninst✝⁹ : Ring R\ninst✝⁸ : Algebra R₀ R\ninst✝⁷ : AddCommGroup M\ninst✝⁶ : AddCommGroup N✝\ninst✝⁵ : AddCommGroup S\ninst✝⁴ : Module R M\ninst✝³ : Module R N✝\ninst✝² : Module R S\ninst✝¹ : IsSimpleModule R ... | simpa only [map_add] using congr($h₁ + $h₂) | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.RingTheory.Spectrum.Prime.Homeomorph | {
"line": 46,
"column": 31
} | {
"line": 46,
"column": 46
} | [
{
"pp": "case asIdeal.h\nR : Type u_3\nS : Type u_4\ninst✝¹ : CommRing R\ninst✝ : CommRing S\nf : R →+* S\nH : ∀ (x : S), ∃ n > 0, x ^ n ∈ f.range\nhker : RingHom.ker f ≤ nilradical R\nq q' : PrimeSpectrum S\nhqq' : (comap f q).asIdeal = (comap f q').asIdeal\nx : S\nn : ℕ\nhn : n > 0\ny : R\nhy : f y = x ^ n\n⊢... | SetLike.ext_iff | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.RingTheory.Smooth.Quotient | {
"line": 58,
"column": 4
} | {
"line": 58,
"column": 32
} | [
{
"pp": "case refine_2.add\nR : Type u_1\ninst✝⁵ : CommRing R\nM : Type u_2\nN : Type u_3\ninst✝⁴ : AddCommGroup M\ninst✝³ : AddCommGroup N\ninst✝² : Module R M\ninst✝¹ : Module R N\nI : Ideal R\nf : M →ₗ[R] N\nsurj : Function.Surjective ⇑f\ninst✝ : Module.Flat R N\nx y : M\nymem : y ∈ I • f.ker\nz : M\nzmem : ... | | add y ymem z zmem hy hz => | _private.Lean.Elab.Tactic.Induction.0.Lean.Elab.Tactic.evalInduction | null |
Mathlib.RingTheory.Smooth.Quotient | {
"line": 89,
"column": 4
} | {
"line": 89,
"column": 32
} | [
{
"pp": "case add\nR : Type u_1\ninst✝ : CommRing R\nJ I : Ideal R\nsq : I * I = ⊥\nf : J.Cotangent →ₗ[R] J.Cotangent\nle : f.range ≤ Submodule.map J.toCotangent (Submodule.comap (Submodule.subtype J) (I * J))\nx y : R\nymem : y ∈ I * J\nz : R\nzmem : z ∈ I * J\nhy : f (J.toCotangent ⟨y, ⋯⟩) = 0\nhz : f (J.toCo... | | add y ymem z zmem hy hz => | _private.Lean.Elab.Tactic.Induction.0.Lean.Elab.Tactic.evalInduction | null |
Mathlib.RingTheory.Valuation.ValuativeRel.Trivial | {
"line": 39,
"column": 36
} | {
"line": 39,
"column": 44
} | [
{
"pp": "case pos\nR Γ : Type\ninst✝³ : CommRing R\ninst✝² : DecidableEq R\ninst✝¹ : IsDomain R\ninst✝ : LinearOrderedCommGroupWithZero Γ\nx✝¹ x✝ : R\nh✝¹ : x✝ = 0\nh✝ : x✝¹ = 0\n⊢ x✝¹ = 0 ∨ x✝ = 0",
"usedConstants": [
"congrArg",
"CommSemiring.toSemiring",
"CommRing.toCommSemiring",
... | simp_all | Lean.Elab.Tactic.evalSimpAll | Lean.Parser.Tactic.simpAll |
Mathlib.RingTheory.Valuation.ValuativeRel.Trivial | {
"line": 39,
"column": 36
} | {
"line": 39,
"column": 44
} | [
{
"pp": "case neg\nR Γ : Type\ninst✝³ : CommRing R\ninst✝² : DecidableEq R\ninst✝¹ : IsDomain R\ninst✝ : LinearOrderedCommGroupWithZero Γ\nx✝¹ x✝ : R\nh✝¹ : x✝ = 0\nh✝ : ¬x✝¹ = 0\n⊢ x✝¹ = 0 ∨ True",
"usedConstants": [
"False",
"eq_false",
"congrArg",
"CommSemiring.toSemiring",
... | simp_all | Lean.Elab.Tactic.evalSimpAll | Lean.Parser.Tactic.simpAll |
Mathlib.RingTheory.Valuation.ValuativeRel.Trivial | {
"line": 39,
"column": 36
} | {
"line": 39,
"column": 44
} | [
{
"pp": "case pos\nR Γ : Type\ninst✝³ : CommRing R\ninst✝² : DecidableEq R\ninst✝¹ : IsDomain R\ninst✝ : LinearOrderedCommGroupWithZero Γ\nx✝¹ x✝ : R\nh✝¹ : ¬x✝ = 0\nh✝ : x✝¹ = 0\n⊢ True ∨ x✝ = 0",
"usedConstants": [
"False",
"eq_false",
"congrArg",
"CommSemiring.toSemiring",
"... | simp_all | Lean.Elab.Tactic.evalSimpAll | Lean.Parser.Tactic.simpAll |
Mathlib.RingTheory.Valuation.ValuativeRel.Trivial | {
"line": 39,
"column": 36
} | {
"line": 39,
"column": 44
} | [
{
"pp": "case neg\nR Γ : Type\ninst✝³ : CommRing R\ninst✝² : DecidableEq R\ninst✝¹ : IsDomain R\ninst✝ : LinearOrderedCommGroupWithZero Γ\nx✝¹ x✝ : R\nh✝¹ : ¬x✝ = 0\nh✝ : ¬x✝¹ = 0\n⊢ True ∨ True",
"usedConstants": [
"True",
"or_self",
"of_eq_true",
"Or"
]
}
] | simp_all | Lean.Elab.Tactic.evalSimpAll | Lean.Parser.Tactic.simpAll |
Mathlib.RingTheory.Valuation.ValuativeRel.Trivial | {
"line": 40,
"column": 33
} | {
"line": 40,
"column": 41
} | [
{
"pp": "case pos\nR Γ : Type\ninst✝³ : CommRing R\ninst✝² : DecidableEq R\ninst✝¹ : IsDomain R\ninst✝ : LinearOrderedCommGroupWithZero Γ\nz✝ y✝ x✝² : R\nx✝¹ : if y✝ = 0 then x✝² = 0 else True\nx✝ : if z✝ = 0 then y✝ = 0 else True\nh✝ : z✝ = 0\n⊢ x✝² = 0",
"usedConstants": [
"congrArg",
"CommSem... | simp_all | Lean.Elab.Tactic.evalSimpAll | Lean.Parser.Tactic.simpAll |
Mathlib.RingTheory.Valuation.ValuativeRel.Trivial | {
"line": 41,
"column": 31
} | {
"line": 41,
"column": 39
} | [
{
"pp": "case pos\nR Γ : Type\ninst✝³ : CommRing R\ninst✝² : DecidableEq R\ninst✝¹ : IsDomain R\ninst✝ : LinearOrderedCommGroupWithZero Γ\nx✝² y✝ z✝ : R\nx✝¹ : if z✝ = 0 then x✝² = 0 else True\nx✝ : if z✝ = 0 then y✝ = 0 else True\nh✝ : z✝ = 0\n⊢ x✝² + y✝ = 0",
"usedConstants": [
"congrArg",
"Co... | simp_all | Lean.Elab.Tactic.evalSimpAll | Lean.Parser.Tactic.simpAll |
Mathlib.RingTheory.Valuation.ValuativeRel.Trivial | {
"line": 42,
"column": 48
} | {
"line": 42,
"column": 56
} | [
{
"pp": "case pos\nR Γ : Type\ninst✝³ : CommRing R\ninst✝² : DecidableEq R\ninst✝¹ : IsDomain R\ninst✝ : LinearOrderedCommGroupWithZero Γ\nx✝² y✝ x✝¹ : R\nh✝¹ : y✝ * x✝¹ = 0\nh✝ : y✝ = 0\nx✝ : x✝² = 0\n⊢ x✝² * x✝¹ = 0",
"usedConstants": [
"HMul.hMul",
"congrArg",
"CommSemiring.toSemiring",... | simp_all | Lean.Elab.Tactic.evalSimpAll | Lean.Parser.Tactic.simpAll |
Mathlib.RingTheory.Valuation.ValuativeRel.Trivial | {
"line": 42,
"column": 48
} | {
"line": 42,
"column": 56
} | [
{
"pp": "case neg\nR Γ : Type\ninst✝³ : CommRing R\ninst✝² : DecidableEq R\ninst✝¹ : IsDomain R\ninst✝ : LinearOrderedCommGroupWithZero Γ\nx✝² y✝ x✝¹ : R\nh✝¹ : y✝ * x✝¹ = 0\nh✝ : ¬y✝ = 0\nx✝ : True\n⊢ x✝² * x✝¹ = 0",
"usedConstants": [
"False",
"IsDomain.to_noZeroDivisors",
"HMul.hMul",
... | simp_all | Lean.Elab.Tactic.evalSimpAll | Lean.Parser.Tactic.simpAll |
Mathlib.RingTheory.Valuation.ValuativeRel.Trivial | {
"line": 43,
"column": 39
} | {
"line": 43,
"column": 47
} | [
{
"pp": "case pos\nR Γ : Type\ninst✝³ : CommRing R\ninst✝² : DecidableEq R\ninst✝¹ : IsDomain R\ninst✝ : LinearOrderedCommGroupWithZero Γ\nx✝¹ y✝ z✝ : R\nx✝ : ¬if 0 = 0 then z✝ = 0 else True\nh✝¹ : y✝ * z✝ = 0\nh✝ : y✝ = 0\n⊢ x✝¹ * z✝ = 0 → x✝¹ = 0",
"usedConstants": [
"False",
"IsDomain.to_noZe... | simp_all | Lean.Elab.Tactic.evalSimpAll | Lean.Parser.Tactic.simpAll |
Mathlib.RingTheory.Valuation.ValuativeRel.Trivial | {
"line": 43,
"column": 39
} | {
"line": 43,
"column": 47
} | [
{
"pp": "case neg\nR Γ : Type\ninst✝³ : CommRing R\ninst✝² : DecidableEq R\ninst✝¹ : IsDomain R\ninst✝ : LinearOrderedCommGroupWithZero Γ\nx✝¹ y✝ z✝ : R\nx✝ : ¬if 0 = 0 then z✝ = 0 else True\nh✝¹ : y✝ * z✝ = 0\nh✝ : ¬y✝ = 0\n⊢ x✝¹ * z✝ = 0 → True",
"usedConstants": [
"False",
"IsDomain.to_noZero... | simp_all | Lean.Elab.Tactic.evalSimpAll | Lean.Parser.Tactic.simpAll |
Mathlib.RingTheory.Valuation.ValuativeRel.Trivial | {
"line": 43,
"column": 39
} | {
"line": 43,
"column": 47
} | [
{
"pp": "case pos\nR Γ : Type\ninst✝³ : CommRing R\ninst✝² : DecidableEq R\ninst✝¹ : IsDomain R\ninst✝ : LinearOrderedCommGroupWithZero Γ\nx✝¹ y✝ z✝ : R\nx✝ : ¬if 0 = 0 then z✝ = 0 else True\nh✝¹ : ¬y✝ * z✝ = 0\nh✝ : y✝ = 0\n⊢ True → x✝¹ = 0",
"usedConstants": [
"False",
"HMul.hMul",
"cong... | simp_all | Lean.Elab.Tactic.evalSimpAll | Lean.Parser.Tactic.simpAll |
Mathlib.RingTheory.Valuation.ValuativeRel.Trivial | {
"line": 43,
"column": 39
} | {
"line": 43,
"column": 47
} | [
{
"pp": "case neg\nR Γ : Type\ninst✝³ : CommRing R\ninst✝² : DecidableEq R\ninst✝¹ : IsDomain R\ninst✝ : LinearOrderedCommGroupWithZero Γ\nx✝¹ y✝ z✝ : R\nx✝ : ¬if 0 = 0 then z✝ = 0 else True\nh✝¹ : ¬y✝ * z✝ = 0\nh✝ : ¬y✝ = 0\n⊢ True → True",
"usedConstants": [
"imp_self._simp_1",
"True",
"... | simp_all | Lean.Elab.Tactic.evalSimpAll | Lean.Parser.Tactic.simpAll |
Mathlib.RingTheory.Valuation.ValuativeRel.Trivial | {
"line": 44,
"column": 39
} | {
"line": 44,
"column": 47
} | [
{
"pp": "case pos\nR Γ : Type\ninst✝³ : CommRing R\ninst✝² : DecidableEq R\ninst✝¹ : IsDomain R\ninst✝ : LinearOrderedCommGroupWithZero Γ\nh✝ : 0 = 0\n⊢ ¬1 = 0",
"usedConstants": [
"False",
"NeZero.one",
"congrArg",
"CommSemiring.toSemiring",
"AddGroupWithOne.toAddMonoidWithOne... | simp_all | Lean.Elab.Tactic.evalSimpAll | Lean.Parser.Tactic.simpAll |
Mathlib.RingTheory.Valuation.ValuativeRel.Trivial | {
"line": 44,
"column": 39
} | {
"line": 44,
"column": 47
} | [
{
"pp": "case neg\nR Γ : Type\ninst✝³ : CommRing R\ninst✝² : DecidableEq R\ninst✝¹ : IsDomain R\ninst✝ : LinearOrderedCommGroupWithZero Γ\nh✝ : ¬0 = 0\n⊢ ¬True",
"usedConstants": [
"False",
"congrArg",
"CommSemiring.toSemiring",
"False.elim",
"Eq.mp",
"not_true_eq_false",... | simp_all | Lean.Elab.Tactic.evalSimpAll | Lean.Parser.Tactic.simpAll |
Mathlib.RingTheory.Valuation.ValuativeRel.Trivial | {
"line": 76,
"column": 4
} | {
"line": 76,
"column": 12
} | [
{
"pp": "case inl\nR Γ : Type\ninst✝⁵ : CommRing R\ninst✝⁴ : DecidableEq R\ninst✝³ : IsDomain R\ninst✝² : LinearOrderedCommGroupWithZero Γ\ninst✝¹ : ValuativeRel R\ninst✝ : Valuation.Compatible 1\nthis : Subsingleton (ValueGroupWithZero R)ˣ\nhx : 0 ≠ 0\nhx' : 0 ≠ 1\n⊢ False",
"usedConstants": [
"Group... | simp_all | Lean.Elab.Tactic.evalSimpAll | Lean.Parser.Tactic.simpAll |
Mathlib.RingTheory.Valuation.ValuativeRel.Trivial | {
"line": 76,
"column": 4
} | {
"line": 76,
"column": 12
} | [
{
"pp": "case inl\nR Γ : Type\ninst✝⁵ : CommRing R\ninst✝⁴ : DecidableEq R\ninst✝³ : IsDomain R\ninst✝² : LinearOrderedCommGroupWithZero Γ\ninst✝¹ : ValuativeRel R\ninst✝ : Valuation.Compatible 1\nthis : Subsingleton (ValueGroupWithZero R)ˣ\nhx : 0 ≠ 0\nhx' : 0 ≠ 1\n⊢ False",
"usedConstants": [
"Group... | simp_all | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.RingTheory.Valuation.ValuativeRel.Trivial | {
"line": 76,
"column": 4
} | {
"line": 76,
"column": 12
} | [
{
"pp": "case inl\nR Γ : Type\ninst✝⁵ : CommRing R\ninst✝⁴ : DecidableEq R\ninst✝³ : IsDomain R\ninst✝² : LinearOrderedCommGroupWithZero Γ\ninst✝¹ : ValuativeRel R\ninst✝ : Valuation.Compatible 1\nthis : Subsingleton (ValueGroupWithZero R)ˣ\nhx : 0 ≠ 0\nhx' : 0 ≠ 1\n⊢ False",
"usedConstants": [
"Group... | simp_all | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.RingTheory.WittVector.Isocrystal | {
"line": 208,
"column": 4
} | {
"line": 208,
"column": 44
} | [
{
"pp": "case h\np : ℕ\ninst✝⁵ : Fact (Nat.Prime p)\nk : Type u_2\ninst✝⁴ : Field k\ninst✝³ : IsAlgClosed k\ninst✝² : CharP k p\nV : Type u_3\ninst✝¹ : AddCommGroup V\ninst✝ : Isocrystal p k V\nh_dim : finrank K(p, k) V = 1\nthis✝ : Nontrivial V\nx : V\nhx : x ≠ 0\nthis : Φ(p, k) x ≠ 0\na : K(p, k)\nha : a ≠ 0\... | StandardOneDimIsocrystal.frobenius_apply | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.SetTheory.Descriptive.Tree | {
"line": 114,
"column": 70
} | {
"line": 114,
"column": 93
} | [
{
"pp": "A : Type u_1\nT : ↥(tree A)\nx y : List A\n⊢ x ++ y ∈ pullSub T x ↔ y ∈ T",
"usedConstants": [
"Nat.le_add_right._simp_1",
"congrArg",
"_private.Mathlib.SetTheory.Descriptive.Tree.0.Descriptive.Tree.mem_pullSub_append._simp_1_1",
"Membership.mem",
"Exists",
"List... | simp [mem_pullSub_long] | Lean.Elab.Tactic.evalSimp | Lean.Parser.Tactic.simp |
Mathlib.SetTheory.Descriptive.Tree | {
"line": 114,
"column": 70
} | {
"line": 114,
"column": 93
} | [
{
"pp": "A : Type u_1\nT : ↥(tree A)\nx y : List A\n⊢ x ++ y ∈ pullSub T x ↔ y ∈ T",
"usedConstants": [
"Nat.le_add_right._simp_1",
"congrArg",
"_private.Mathlib.SetTheory.Descriptive.Tree.0.Descriptive.Tree.mem_pullSub_append._simp_1_1",
"Membership.mem",
"Exists",
"List... | simp [mem_pullSub_long] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.SetTheory.Descriptive.Tree | {
"line": 114,
"column": 70
} | {
"line": 114,
"column": 93
} | [
{
"pp": "A : Type u_1\nT : ↥(tree A)\nx y : List A\n⊢ x ++ y ∈ pullSub T x ↔ y ∈ T",
"usedConstants": [
"Nat.le_add_right._simp_1",
"congrArg",
"_private.Mathlib.SetTheory.Descriptive.Tree.0.Descriptive.Tree.mem_pullSub_append._simp_1_1",
"Membership.mem",
"Exists",
"List... | simp [mem_pullSub_long] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.SetTheory.Lists | {
"line": 190,
"column": 4
} | {
"line": 194,
"column": 41
} | [
{
"pp": "case ofList\nα : Type u_1\nl₂ : Lists' α true\nl₁ : List (Lists α)\nH : ∀ (a : Lists α), a ∈ (ofList l₁).toList → a ∈ l₂\n⊢ ofList l₁ ⊆ l₂",
"usedConstants": [
"Iff.mpr",
"Lists'.toList",
"_private.Mathlib.SetTheory.Lists.0.Lists'.subset_def._simp_1_2",
"congrArg",
"Li... | induction l₁ with
| nil => exact Subset.nil
| cons h t t_ih =>
simp only [to_ofList, ofList, toList_cons, List.mem_cons, forall_eq_or_imp] at *
exact cons_subset.2 ⟨H.1, t_ih H.2⟩ | _private.Lean.Elab.Tactic.Induction.0.Lean.Elab.Tactic.evalInduction | Lean.Parser.Tactic.induction |
Mathlib.SetTheory.Ordinal.CantorNormalForm | {
"line": 91,
"column": 4
} | {
"line": 91,
"column": 12
} | [
{
"pp": "b e x y : Ordinal.{u_1}\nhb : 1 < b\nhx : x ≠ 0\nhxb : x < b\nhy : y < b ^ e\nhb' : b ≠ ⊥\n⊢ b ^ e * x + y ≠ 0",
"usedConstants": [
"False",
"Ordinal.noZeroDivisors",
"Ordinal.instLinearOrder",
"HMul.hMul",
"eq_false",
"Ordinal.partialOrder",
"MulZeroClass.... | simp_all | Lean.Elab.Tactic.evalSimpAll | Lean.Parser.Tactic.simpAll |
Mathlib.SetTheory.Ordinal.CantorNormalForm | {
"line": 91,
"column": 4
} | {
"line": 91,
"column": 12
} | [
{
"pp": "b e x y : Ordinal.{u_1}\nhb : 1 < b\nhx : x ≠ 0\nhxb : x < b\nhy : y < b ^ e\nhb' : b ≠ ⊥\n⊢ b ^ e * x + y ≠ 0",
"usedConstants": [
"False",
"Ordinal.noZeroDivisors",
"Ordinal.instLinearOrder",
"HMul.hMul",
"eq_false",
"Ordinal.partialOrder",
"MulZeroClass.... | simp_all | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.SetTheory.Ordinal.CantorNormalForm | {
"line": 91,
"column": 4
} | {
"line": 91,
"column": 12
} | [
{
"pp": "b e x y : Ordinal.{u_1}\nhb : 1 < b\nhx : x ≠ 0\nhxb : x < b\nhy : y < b ^ e\nhb' : b ≠ ⊥\n⊢ b ^ e * x + y ≠ 0",
"usedConstants": [
"False",
"Ordinal.noZeroDivisors",
"Ordinal.instLinearOrder",
"HMul.hMul",
"eq_false",
"Ordinal.partialOrder",
"MulZeroClass.... | simp_all | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.SetTheory.Ordinal.CantorNormalForm | {
"line": 205,
"column": 4
} | {
"line": 205,
"column": 12
} | [
{
"pp": "case h.inl\nb o c : Ordinal.{u_1}\nhe : (0, c) ∈ CNF b o\nh : o < b ^ (0, c).1\n⊢ False",
"usedConstants": [
"False",
"Ordinal.instLinearOrder",
"Preorder.toLT",
"Ordinal.partialOrder",
"congrArg",
"instIsBotZeroClass",
"False.elim",
"AddMonoid.toAddZ... | simp_all | Lean.Elab.Tactic.evalSimpAll | Lean.Parser.Tactic.simpAll |
Mathlib.SetTheory.Ordinal.CantorNormalForm | {
"line": 205,
"column": 4
} | {
"line": 205,
"column": 12
} | [
{
"pp": "case h.inl\nb o c : Ordinal.{u_1}\nhe : (0, c) ∈ CNF b o\nh : o < b ^ (0, c).1\n⊢ False",
"usedConstants": [
"False",
"Ordinal.instLinearOrder",
"Preorder.toLT",
"Ordinal.partialOrder",
"congrArg",
"instIsBotZeroClass",
"False.elim",
"AddMonoid.toAddZ... | simp_all | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.SetTheory.Ordinal.CantorNormalForm | {
"line": 205,
"column": 4
} | {
"line": 205,
"column": 12
} | [
{
"pp": "case h.inl\nb o c : Ordinal.{u_1}\nhe : (0, c) ∈ CNF b o\nh : o < b ^ (0, c).1\n⊢ False",
"usedConstants": [
"False",
"Ordinal.instLinearOrder",
"Preorder.toLT",
"Ordinal.partialOrder",
"congrArg",
"instIsBotZeroClass",
"False.elim",
"AddMonoid.toAddZ... | simp_all | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.SetTheory.Ordinal.CantorNormalForm | {
"line": 259,
"column": 6
} | {
"line": 259,
"column": 14
} | [
{
"pp": "case neg\nb e x y : Ordinal.{u_1}\nhb : 1 < b\nhx : x ≠ 0\nhxb : x < b\nhy : y < b ^ e\ne' : Ordinal.{u_1}\nhe : e ≠ e'\nh : ¬∃ a ∈ CNF b y, a.1 = e'\n⊢ ¬∃ a ∈ (e, x) :: CNF b y, a.1 = e'",
"usedConstants": [
"not_exists._simp_1",
"False",
"eq_false",
"Ordinal.inhabited",
... | simp_all | Lean.Elab.Tactic.evalSimpAll | Lean.Parser.Tactic.simpAll |
Mathlib.Topology.Order.SuccPred | {
"line": 53,
"column": 4
} | {
"line": 53,
"column": 53
} | [
{
"pp": "case refine_2.inr\nα : Type u_1\ninst✝⁴ : LinearOrder α\ninst✝³ : TopologicalSpace α\ninst✝² : OrderTopology α\na : α\ninst✝¹ : SuccOrder α\ninst✝ : NoMaxOrder α\na✝ : Nontrivial α\nha✝ : ¬IsSuccLimit a\nha : ¬IsSuccPrelimit a\n⊢ IsOpen[inst✝³] {a}",
"usedConstants": [
"SuccOrder.isOpen_singl... | · exact isOpen_singleton_of_not_isSuccPrelimit ha | Lean.Elab.Tactic.evalTacticCDot | Lean.cdot |
Mathlib.SetTheory.Ordinal.CantorNormalForm | {
"line": 312,
"column": 6
} | {
"line": 312,
"column": 14
} | [
{
"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₁... | simp_all | Lean.Elab.Tactic.evalSimpAll | Lean.Parser.Tactic.simpAll |
Mathlib.SetTheory.Ordinal.CantorNormalForm | {
"line": 312,
"column": 6
} | {
"line": 312,
"column": 14
} | [
{
"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₁... | simp_all | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.SetTheory.Ordinal.CantorNormalForm | {
"line": 312,
"column": 6
} | {
"line": 312,
"column": 14
} | [
{
"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₁... | simp_all | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.SetTheory.Ordinal.CantorNormalForm | {
"line": 317,
"column": 8
} | {
"line": 317,
"column": 16
} | [
{
"pp": "b : 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₁).support, ∀ e₂ ∈... | simp_all | Lean.Elab.Tactic.evalSimpAll | Lean.Parser.Tactic.simpAll |
Mathlib.SetTheory.Ordinal.Notation | {
"line": 301,
"column": 10
} | {
"line": 301,
"column": 33
} | [
{
"pp": "case inl\no₁ e₁ : ONote\nn₁ : ℕ+\na₁ : ONote\nh✝¹ : o₁ = e₁.oadd n₁ a₁\no₂ : ONote\nn₂ : ℕ+\na₂ : ONote\nh₁ : (namedPattern o₁ (e₁.oadd n₁ a₁) h✝¹).NF\nh✝ : o₂ = e₁.oadd n₂ a₂\nh₂ : (namedPattern o₂ (e₁.oadd n₂ a₂) h✝).NF\nnh : ↑n₁ < ↑n₂ ∧ Ordering.lt = Ordering.gt\n⊢ (Ordering.eq.then (Ordering.gt.the... | cases nh; contradiction | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.SetTheory.Ordinal.Notation | {
"line": 301,
"column": 10
} | {
"line": 301,
"column": 33
} | [
{
"pp": "case inl\no₁ e₁ : ONote\nn₁ : ℕ+\na₁ : ONote\nh✝¹ : o₁ = e₁.oadd n₁ a₁\no₂ : ONote\nn₂ : ℕ+\na₂ : ONote\nh₁ : (namedPattern o₁ (e₁.oadd n₁ a₁) h✝¹).NF\nh✝ : o₂ = e₁.oadd n₂ a₂\nh₂ : (namedPattern o₂ (e₁.oadd n₂ a₂) h✝).NF\nnh : ↑n₁ < ↑n₂ ∧ Ordering.lt = Ordering.gt\n⊢ (Ordering.eq.then (Ordering.gt.the... | cases nh; contradiction | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.SetTheory.Ordinal.Notation | {
"line": 305,
"column": 12
} | {
"line": 305,
"column": 35
} | [
{
"pp": "case inr.inr\no₁ e₁ : ONote\nn₁ : ℕ+\na₁ : ONote\nh✝¹ : o₁ = e₁.oadd n₁ a₁\no₂ : ONote\nn₂ : ℕ+\na₂ : ONote\nh₁ : (namedPattern o₁ (e₁.oadd n₁ a₁) h✝¹).NF\nh✝ : o₂ = e₁.oadd n₂ a₂\nh₂ : (namedPattern o₂ (e₁.oadd n₂ a₂) h✝).NF\nleft✝ : ↑n₂ ≤ ↑n₁\nnh : ¬↑n₂ < ↑n₁ ∧ Ordering.eq = Ordering.gt\n⊢ (Ordering.... | cases nh; contradiction | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.SetTheory.Ordinal.Notation | {
"line": 305,
"column": 12
} | {
"line": 305,
"column": 35
} | [
{
"pp": "case inr.inr\no₁ e₁ : ONote\nn₁ : ℕ+\na₁ : ONote\nh✝¹ : o₁ = e₁.oadd n₁ a₁\no₂ : ONote\nn₂ : ℕ+\na₂ : ONote\nh₁ : (namedPattern o₁ (e₁.oadd n₁ a₁) h✝¹).NF\nh✝ : o₂ = e₁.oadd n₂ a₂\nh₂ : (namedPattern o₂ (e₁.oadd n₂ a₂) h✝).NF\nleft✝ : ↑n₂ ≤ ↑n₁\nnh : ¬↑n₂ < ↑n₁ ∧ Ordering.eq = Ordering.gt\n⊢ (Ordering.... | cases nh; contradiction | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.SetTheory.Ordinal.Notation | {
"line": 307,
"column": 8
} | {
"line": 307,
"column": 31
} | [
{
"pp": "case eq.inl\no₁ e₁ : ONote\nn₁ : ℕ+\na₁ : ONote\nh✝¹ : o₁ = e₁.oadd n₁ a₁\no₂ : ONote\nn₂ : ℕ+\na₂ : ONote\nh₁ : (namedPattern o₁ (e₁.oadd n₁ a₁) h✝¹).NF\nh✝ : o₂ = e₁.oadd n₂ a₂\nh₂ : (namedPattern o₂ (e₁.oadd n₂ a₂) h✝).NF\nnh : ↑n₁ < ↑n₂ ∧ Ordering.lt = Ordering.eq\n⊢ (Ordering.eq.then (Ordering.eq.... | cases nh; contradiction | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.SetTheory.Ordinal.Notation | {
"line": 307,
"column": 8
} | {
"line": 307,
"column": 31
} | [
{
"pp": "case eq.inl\no₁ e₁ : ONote\nn₁ : ℕ+\na₁ : ONote\nh✝¹ : o₁ = e₁.oadd n₁ a₁\no₂ : ONote\nn₂ : ℕ+\na₂ : ONote\nh₁ : (namedPattern o₁ (e₁.oadd n₁ a₁) h✝¹).NF\nh✝ : o₂ = e₁.oadd n₂ a₂\nh₂ : (namedPattern o₂ (e₁.oadd n₂ a₂) h✝).NF\nnh : ↑n₁ < ↑n₂ ∧ Ordering.lt = Ordering.eq\n⊢ (Ordering.eq.then (Ordering.eq.... | cases nh; contradiction | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.SetTheory.Ordinal.Topology | {
"line": 195,
"column": 6
} | {
"line": 195,
"column": 73
} | [
{
"pp": "case mp.right\no : Ordinal.{u_1}\nS : Set Ordinal.{u_1}\nh : ∀ U ∈ 𝓝 o, ∃ y ∈ U ∩ S, y ≠ o\np : Ordinal.{u_1}\nplt : p < o\n⊢ (S ∩ Ioo p o).Nonempty",
"usedConstants": [
"Ordinal.instLinearOrder",
"Ordinal.partialOrder",
"PartialOrder.toPreorder",
"Order.lt_succ",
"Or... | obtain ⟨x, hx⟩ := h (Ioo p (o + 1)) <| Ioo_mem_nhds plt (lt_succ o) | _private.Lean.Elab.Tactic.RCases.0.Lean.Elab.Tactic.RCases.evalObtain | Lean.Parser.Tactic.obtain |
Mathlib.SetTheory.Ordinal.Veblen | {
"line": 566,
"column": 70
} | {
"line": 568,
"column": 80
} | [
{
"pp": "o : Ordinal.{u}\nh : ω ^ o ≤ o\n⊢ ε_ 0 ≤ o",
"usedConstants": [
"Iff.mpr",
"zero_le",
"Eq.mpr",
"Ordinal.nfp_le_fp",
"Ordinal.omega0",
"Ordinal.partialOrder",
"congrArg",
"instIsBotZeroClass",
"AddMonoid.toAddZeroClass",
"PartialOrder.toPr... | by
rw [epsilon_zero_eq_nfp]
exact nfp_le_fp (fun _ _ ↦ (opow_le_opow_iff_right one_lt_omega0).2) zero_le h | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.SetTheory.Ordinal.Notation | {
"line": 448,
"column": 37
} | {
"line": 448,
"column": 55
} | [
{
"pp": "case zero\nb : Ordinal.{0}\nx✝ : NFBelow 0 b\nh₂ : zero.NF\n⊢ (0 - zero).NFBelow b",
"usedConstants": [
"ONote.NFBelow.zero"
]
}
] | exact NFBelow.zero | Lean.Elab.Tactic.evalExact | Lean.Parser.Tactic.exact |
Mathlib.SetTheory.Ordinal.Notation | {
"line": 448,
"column": 37
} | {
"line": 448,
"column": 55
} | [
{
"pp": "case oadd\nb : Ordinal.{0}\nx✝ : NFBelow 0 b\na✝² : ONote\na✝¹ : ℕ+\na✝ : ONote\nh₂ : (a✝².oadd a✝¹ a✝).NF\n⊢ (0 - a✝².oadd a✝¹ a✝).NFBelow b",
"usedConstants": [
"ONote.NFBelow.zero"
]
}
] | exact NFBelow.zero | Lean.Elab.Tactic.evalExact | Lean.Parser.Tactic.exact |
Mathlib.SetTheory.Ordinal.Notation | {
"line": 462,
"column": 10
} | {
"line": 462,
"column": 28
} | [
{
"pp": "case neg\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\nen : ¬n₁ = n₂\n⊢ NFBelow 0 b",
"usedConstants": [
"ONote.NFBelow.zero"
]
}
] | exact NFBelow.zero | Lean.Elab.Tactic.evalExact | Lean.Parser.Tactic.exact |
Mathlib.SetTheory.Ordinal.Notation | {
"line": 462,
"column": 10
} | {
"line": 462,
"column": 28
} | [
{
"pp": "case neg\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\nen : ¬n₁ = n₂\n⊢ NFBelow 0 b",
"usedConstants": [
"ONote.NFBelow.zero"
]
}
] | exact NFBelow.zero | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.SetTheory.Ordinal.Notation | {
"line": 462,
"column": 10
} | {
"line": 462,
"column": 28
} | [
{
"pp": "case neg\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\nen : ¬n₁ = n₂\n⊢ NFBelow 0 b",
"usedConstants": [
"ONote.NFBelow.zero"
]
}
] | exact NFBelow.zero | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.SetTheory.ZFC.Rank | {
"line": 121,
"column": 2
} | {
"line": 121,
"column": 50
} | [
{
"pp": "x : PSet.{u}\n⊢ lift.{u + 1, u} x.rank = IsWellFounded.rank (fun x1 x2 ↦ x1 ∈ x2) x",
"usedConstants": [
"PSet.mem_wf",
"PSet.instIsWellFoundedMem",
"PSet.instMembership",
"Ordinal.lift",
"Membership.mem",
"PSet",
"PSet.rank",
"WellFounded.induction",... | induction x using mem_wf.induction with | _ x ih | _private.Lean.Elab.Tactic.Induction.0.Lean.Elab.Tactic.evalInduction | Lean.Parser.Tactic.induction |
Mathlib.SetTheory.Ordinal.Notation | {
"line": 719,
"column": 2
} | {
"line": 719,
"column": 94
} | [
{
"pp": "o e : ONote\nn : ℕ+\na : ONote\nm : ℕ\ninst✝ : o.NF\nh : o.split = (e.oadd n a, m)\nh₁ : (e.oadd n a).NF\nh₂ : o.repr = (e.oadd n a).repr + ↑m\ne0 : e.repr ≠ 0\nd : ω ∣ a.repr\n⊢ a.repr + ↑m < ω ^ e.repr",
"usedConstants": [
"Ordinal.omega0",
"Ordinal.partialOrder",
"PartialOrder.... | apply isPrincipal_add_omega0_opow _ h₁.snd'.repr_lt (lt_of_lt_of_le (natCast_lt_omega0 _) _) | Lean.Elab.Tactic.evalApply | Lean.Parser.Tactic.apply |
Mathlib.SetTheory.ZFC.VonNeumann | {
"line": 59,
"column": 21
} | {
"line": 59,
"column": 29
} | [
{
"pp": "a b : Ordinal.{u}\nh : a ≤ b\n⊢ a = b → V_ a ⊆ V_ b",
"usedConstants": [
"subset_refl._simp_1",
"congrArg",
"ZFSet",
"HasSubset.Subset",
"ZFSet.vonNeumann",
"ZFSet.instReflSubset",
"True",
"of_eq_true",
"ZFSet.instHasSubset",
"Eq.refl",
... | simp_all | Lean.Elab.Tactic.evalSimpAll | Lean.Parser.Tactic.simpAll |
Mathlib.SetTheory.ZFC.VonNeumann | {
"line": 59,
"column": 21
} | {
"line": 59,
"column": 29
} | [
{
"pp": "a b : Ordinal.{u}\nh : a ≤ b\n⊢ a = b → V_ a ⊆ V_ b",
"usedConstants": [
"subset_refl._simp_1",
"congrArg",
"ZFSet",
"HasSubset.Subset",
"ZFSet.vonNeumann",
"ZFSet.instReflSubset",
"True",
"of_eq_true",
"ZFSet.instHasSubset",
"Eq.refl",
... | simp_all | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.SetTheory.ZFC.VonNeumann | {
"line": 59,
"column": 21
} | {
"line": 59,
"column": 29
} | [
{
"pp": "a b : Ordinal.{u}\nh : a ≤ b\n⊢ a = b → V_ a ⊆ V_ b",
"usedConstants": [
"subset_refl._simp_1",
"congrArg",
"ZFSet",
"HasSubset.Subset",
"ZFSet.vonNeumann",
"ZFSet.instReflSubset",
"True",
"of_eq_true",
"ZFSet.instHasSubset",
"Eq.refl",
... | simp_all | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.SetTheory.ZFC.Ordinal | {
"line": 255,
"column": 6
} | {
"line": 255,
"column": 22
} | [
{
"pp": "x y : ZFSet.{u_1}\nhx : x.IsOrdinal\nhy : y.IsOrdinal\n⊢ x.rank = y.rank ↔ x = y",
"usedConstants": [
"Eq.mpr",
"Ordinal.partialOrder",
"congrArg",
"ZFSet",
"PartialOrder.toPreorder",
"Preorder.toLE",
"id",
"ZFSet.rank",
"LE.le",
"And",
... | le_antisymm_iff, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.SetTheory.Ordinal.Notation | {
"line": 870,
"column": 6
} | {
"line": 870,
"column": 36
} | [
{
"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' : ... | apply add_of_omega0_opow_le Rl | Lean.Elab.Tactic.evalApply | Lean.Parser.Tactic.apply |
Mathlib.SetTheory.Ordinal.Notation | {
"line": 893,
"column": 30
} | {
"line": 893,
"column": 41
} | [
{
"pp": "case neg\no₁ o₂ : ONote\ninst✝¹ : o₁.NF\ninst✝ : o₂.NF\nN₁ : zero.NF\nm : ℕ\ne₁ : o₁.split = (zero, m + 1)\nr₁ : o₁.repr = zero.repr + ↑(m + 1)\nb' : ONote\nk : ℕ\ne₂ : o₂.split' = (b', k)\nleft✝ : b'.NF\nr₂ : o₂.repr = ω * b'.repr + ↑k\nh : ¬m = 0\n⊢ ω ^ b'.repr * ↑↑(m.succPNat ^ k) = ((↑m + 1) ^ ω) ^... | opow_omega0 | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Tactic.ComputeAsymptotics.Multiseries.Basis | {
"line": 63,
"column": 2
} | {
"line": 73,
"column": 9
} | [
{
"pp": "basis : Basis\nf : ℝ → ℝ\nh : WellFormedBasis basis\nh_comp : ∀ (g : ℝ → ℝ), List.getLast? basis = some g → (Real.log ∘ f) =o[atTop] (Real.log ∘ g)\n⊢ ∀ g ∈ basis, (Real.log ∘ f) =o[atTop] (Real.log ∘ g)",
"usedConstants": [
"List.getLast?_append",
"False",
"Real",
"List.Pai... | intro g hg
rcases basis.eq_nil_or_concat with rfl | ⟨basis_begin, basis_end, rfl⟩
· simp at hg
simp only [List.concat_eq_append, List.mem_append, List.mem_cons, List.not_mem_nil, or_false,
List.getLast?_append, List.getLast?_singleton, Option.some_or, Option.some.injEq,
forall_eq'] at hg h_comp
rcases h... | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Tactic.ComputeAsymptotics.Multiseries.Basis | {
"line": 63,
"column": 2
} | {
"line": 73,
"column": 9
} | [
{
"pp": "basis : Basis\nf : ℝ → ℝ\nh : WellFormedBasis basis\nh_comp : ∀ (g : ℝ → ℝ), List.getLast? basis = some g → (Real.log ∘ f) =o[atTop] (Real.log ∘ g)\n⊢ ∀ g ∈ basis, (Real.log ∘ f) =o[atTop] (Real.log ∘ g)",
"usedConstants": [
"List.getLast?_append",
"False",
"Real",
"List.Pai... | intro g hg
rcases basis.eq_nil_or_concat with rfl | ⟨basis_begin, basis_end, rfl⟩
· simp at hg
simp only [List.concat_eq_append, List.mem_append, List.mem_cons, List.not_mem_nil, or_false,
List.getLast?_append, List.getLast?_singleton, Option.some_or, Option.some.injEq,
forall_eq'] at hg h_comp
rcases h... | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Tactic.ComputeAsymptotics.Multiseries.Monomial.Basic | {
"line": 113,
"column": 4
} | {
"line": 113,
"column": 12
} | [
{
"pp": "case nil\nx : ℝ\nm2 : UnitMonomial\nbasis : Basis\nh_basis : WellFormedBasis basis\nh_length : List.length m2 = [].length\nh_pos : ∀ f ∈ basis, 0 < f x\n⊢ (List.zipWith (fun exp b ↦ b x ^ exp) (List.zipWith (fun x1 x2 ↦ x1 + x2) [] m2) basis).prod =\n (List.zipWith (fun exp b ↦ b x ^ exp) [] basis).... | simp_all | Lean.Elab.Tactic.evalSimpAll | Lean.Parser.Tactic.simpAll |
Mathlib.Tactic.ComputeAsymptotics.Multiseries.Corecursion | {
"line": 102,
"column": 2
} | {
"line": 102,
"column": 20
} | [
{
"pp": "α : Type u_1\ns t : Stream' α\n⊢ dist s t ≤ 1",
"usedConstants": [
"Real.instLE",
"Real",
"Classical.propDecidable",
"LE.le",
"dite",
"Real.instOne",
"Stream'",
"Tactic.ComputeAsymptotics.Seq.instMetricSpaceStream'",
"One.toOfNat1",
"Metri... | by_cases h : s = t | «_aux_Init_ByCases___macroRules_tacticBy_cases_:__2» | «tacticBy_cases_:_» |
Mathlib.Tactic.ComputeAsymptotics.Multiseries.Corecursion | {
"line": 279,
"column": 6
} | {
"line": 279,
"column": 10
} | [
{
"pp": "case h\nα : Type u_1\nβ : Type u_2\nγ : Type u_3\nF : β → Option (α × γ × β)\nop : γ → Stream'.Seq α → Stream'.Seq α\nh : FriendlyOperationClass op\nT : (β →ᵤ Stream'.Seq α) → β →ᵤ Stream'.Seq α :=\n fun f b ↦\n match F b with\n | none => nil\n | some (a, c, b') => Seq.cons a (op c (f b'))\nh... | ← hf | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Tactic.ComputeAsymptotics.Multiseries.Corecursion | {
"line": 244,
"column": 2
} | {
"line": 289,
"column": 11
} | [
{
"pp": "α : Type u_1\nβ : Type u_2\nγ : Type u_3\nF : β → Option (α × γ × β)\nop : γ → Stream'.Seq α → Stream'.Seq α\nh : FriendlyOperationClass op\n⊢ ∃ f,\n ∀ (b : β),\n match F b with\n | none => f b = nil\n | some (a, c, b') => f b = Seq.cons a (op c (f b'))",
"usedConstants": [
... | let T : (β →ᵤ Seq α) → (β →ᵤ Seq α) := fun f b =>
match F b with
| none => nil
| some (a, c, b') => Seq.cons a (op c (f b'))
have hT : LipschitzWith 2⁻¹ T := by
rw [lipschitzWith_iff_dist_le_mul]
intro f g
rw [UniformFun.dist_le (by positivity)]
intro b
simp only [UniformFun.toFun, Uni... | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Tactic.ComputeAsymptotics.Multiseries.Corecursion | {
"line": 244,
"column": 2
} | {
"line": 289,
"column": 11
} | [
{
"pp": "α : Type u_1\nβ : Type u_2\nγ : Type u_3\nF : β → Option (α × γ × β)\nop : γ → Stream'.Seq α → Stream'.Seq α\nh : FriendlyOperationClass op\n⊢ ∃ f,\n ∀ (b : β),\n match F b with\n | none => f b = nil\n | some (a, c, b') => f b = Seq.cons a (op c (f b'))",
"usedConstants": [
... | let T : (β →ᵤ Seq α) → (β →ᵤ Seq α) := fun f b =>
match F b with
| none => nil
| some (a, c, b') => Seq.cons a (op c (f b'))
have hT : LipschitzWith 2⁻¹ T := by
rw [lipschitzWith_iff_dist_le_mul]
intro f g
rw [UniformFun.dist_le (by positivity)]
intro b
simp only [UniformFun.toFun, Uni... | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Tactic.DeriveEncodable | {
"line": 116,
"column": 43
} | {
"line": 116,
"column": 54
} | [
{
"pp": "case ind\nn : ℕ\nih : ∀ m < n, (S.decode m).encode = m\n⊢ (S.decode n).encode = n",
"usedConstants": [
"Eq.mpr",
"Decidable.casesOn",
"_private.Mathlib.Tactic.DeriveEncodable.0.Mathlib.Deriving.Encodable.S_equiv._proof_3",
"congrArg",
"_private.Mathlib.Tactic.DeriveEnc... | | _ n ih => | _private.Lean.Elab.Tactic.Induction.0.Lean.Elab.Tactic.evalInduction | null |
Mathlib.Tactic.ComputeAsymptotics.Multiseries.Corecursion | {
"line": 396,
"column": 16
} | {
"line": 396,
"column": 24
} | [
{
"pp": "case cons.cons.cons\nα : Type u_1\nop : Stream'.Seq α → Stream'.Seq α\nh : FriendlyOperation op\ns_hd : α\ns_tl : Stream'.Seq α\nx✝¹ : α\ns✝¹ : Stream'.Seq α\nht0 : op (Seq.cons s_hd nil) = Seq.cons x✝¹ s✝¹\nx✝ : α\ns✝ : Stream'.Seq α\nht : op (Seq.cons s_hd s_tl) = Seq.cons x✝ s✝\nthis : (Seq.cons x✝¹... | simp_all | Lean.Elab.Tactic.evalSimpAll | Lean.Parser.Tactic.simpAll |
Mathlib.Tactic.ComputeAsymptotics.Multiseries.Corecursion | {
"line": 396,
"column": 16
} | {
"line": 396,
"column": 24
} | [
{
"pp": "case cons.cons.cons\nα : Type u_1\nop : Stream'.Seq α → Stream'.Seq α\nh : FriendlyOperation op\ns_hd : α\ns_tl : Stream'.Seq α\nx✝¹ : α\ns✝¹ : Stream'.Seq α\nht0 : op (Seq.cons s_hd nil) = Seq.cons x✝¹ s✝¹\nx✝ : α\ns✝ : Stream'.Seq α\nht : op (Seq.cons s_hd s_tl) = Seq.cons x✝ s✝\nthis : (Seq.cons x✝¹... | simp_all | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Tactic.ComputeAsymptotics.Multiseries.Corecursion | {
"line": 396,
"column": 16
} | {
"line": 396,
"column": 24
} | [
{
"pp": "case cons.cons.cons\nα : Type u_1\nop : Stream'.Seq α → Stream'.Seq α\nh : FriendlyOperation op\ns_hd : α\ns_tl : Stream'.Seq α\nx✝¹ : α\ns✝¹ : Stream'.Seq α\nht0 : op (Seq.cons s_hd nil) = Seq.cons x✝¹ s✝¹\nx✝ : α\ns✝ : Stream'.Seq α\nht : op (Seq.cons s_hd s_tl) = Seq.cons x✝ s✝\nthis : (Seq.cons x✝¹... | simp_all | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Tactic.ComputeAsymptotics.Multiseries.Defs | {
"line": 532,
"column": 48
} | {
"line": 532,
"column": 56
} | [
{
"pp": "basis_hd : ℝ → ℝ\nbasis_tl : Basis\nexp : ℝ\ncoef : MultiseriesExpansion basis_tl\ntl_exp : ℝ\ntl_coef : MultiseriesExpansion basis_tl\ntl_tl : Multiseries basis_hd basis_tl\nh_coef : ∀ x ∈ (mk (Multiseries.cons exp coef (Multiseries.cons tl_exp tl_coef tl_tl)) 0).seq, x.2.Sorted\nh_Pairwise✝ :\n Seq.... | simp_all | Lean.Elab.Tactic.evalSimpAll | Lean.Parser.Tactic.simpAll |
Mathlib.Tactic.ComputeAsymptotics.Multiseries.Defs | {
"line": 532,
"column": 48
} | {
"line": 532,
"column": 56
} | [
{
"pp": "basis_hd : ℝ → ℝ\nbasis_tl : Basis\nexp : ℝ\ncoef : MultiseriesExpansion basis_tl\ntl_exp : ℝ\ntl_coef : MultiseriesExpansion basis_tl\ntl_tl : Multiseries basis_hd basis_tl\nh_coef : ∀ x ∈ (mk (Multiseries.cons exp coef (Multiseries.cons tl_exp tl_coef tl_tl)) 0).seq, x.2.Sorted\nh_Pairwise✝ :\n Seq.... | simp_all | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Tactic.ComputeAsymptotics.Multiseries.Defs | {
"line": 532,
"column": 48
} | {
"line": 532,
"column": 56
} | [
{
"pp": "basis_hd : ℝ → ℝ\nbasis_tl : Basis\nexp : ℝ\ncoef : MultiseriesExpansion basis_tl\ntl_exp : ℝ\ntl_coef : MultiseriesExpansion basis_tl\ntl_tl : Multiseries basis_hd basis_tl\nh_coef : ∀ x ∈ (mk (Multiseries.cons exp coef (Multiseries.cons tl_exp tl_coef tl_tl)) 0).seq, x.2.Sorted\nh_Pairwise✝ :\n Seq.... | simp_all | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Tactic.NormNum.IsSquare | {
"line": 50,
"column": 4
} | {
"line": 50,
"column": 12
} | [
{
"pp": "case inl\na : ℤ\nn : ℕ\nh : IsInt a (Int.negOfNat n)\nx✝ : IsSquare a\nhb : -↑n = 0 * 0\n⊢ n = 0",
"usedConstants": [
"AddGroup.toSubtractionMonoid",
"NegZeroClass.toNeg",
"HMul.hMul",
"AddGroupWithOne.toAddGroup",
"congrArg",
"neg_eq_zero._simp_1",
"AddGro... | simp_all | Lean.Elab.Tactic.evalSimpAll | Lean.Parser.Tactic.simpAll |
Mathlib.Tactic.NormNum.IsSquare | {
"line": 50,
"column": 4
} | {
"line": 50,
"column": 12
} | [
{
"pp": "case inl\na : ℤ\nn : ℕ\nh : IsInt a (Int.negOfNat n)\nx✝ : IsSquare a\nhb : -↑n = 0 * 0\n⊢ n = 0",
"usedConstants": [
"AddGroup.toSubtractionMonoid",
"NegZeroClass.toNeg",
"HMul.hMul",
"AddGroupWithOne.toAddGroup",
"congrArg",
"neg_eq_zero._simp_1",
"AddGro... | simp_all | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Tactic.NormNum.IsSquare | {
"line": 50,
"column": 4
} | {
"line": 50,
"column": 12
} | [
{
"pp": "case inl\na : ℤ\nn : ℕ\nh : IsInt a (Int.negOfNat n)\nx✝ : IsSquare a\nhb : -↑n = 0 * 0\n⊢ n = 0",
"usedConstants": [
"AddGroup.toSubtractionMonoid",
"NegZeroClass.toNeg",
"HMul.hMul",
"AddGroupWithOne.toAddGroup",
"congrArg",
"neg_eq_zero._simp_1",
"AddGro... | simp_all | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Tactic.NormNum.IsSquare | {
"line": 63,
"column": 4
} | {
"line": 63,
"column": 12
} | [
{
"pp": "case inl\na : ℚ\nn : ℕ\nh : IsInt a (Int.negOfNat n)\nx✝ : IsSquare a\nhb : -↑n = 0 * 0\n⊢ n = 0",
"usedConstants": [
"AddGroup.toSubtractionMonoid",
"Rat.instOfNat",
"NegZeroClass.toNeg",
"Rat.instMul",
"HMul.hMul",
"AddGroupWithOne.toAddGroup",
"congrArg"... | simp_all | Lean.Elab.Tactic.evalSimpAll | Lean.Parser.Tactic.simpAll |
Mathlib.Tactic.NormNum.IsSquare | {
"line": 63,
"column": 4
} | {
"line": 63,
"column": 12
} | [
{
"pp": "case inl\na : ℚ\nn : ℕ\nh : IsInt a (Int.negOfNat n)\nx✝ : IsSquare a\nhb : -↑n = 0 * 0\n⊢ n = 0",
"usedConstants": [
"AddGroup.toSubtractionMonoid",
"Rat.instOfNat",
"NegZeroClass.toNeg",
"Rat.instMul",
"HMul.hMul",
"AddGroupWithOne.toAddGroup",
"congrArg"... | simp_all | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Tactic.NormNum.IsSquare | {
"line": 63,
"column": 4
} | {
"line": 63,
"column": 12
} | [
{
"pp": "case inl\na : ℚ\nn : ℕ\nh : IsInt a (Int.negOfNat n)\nx✝ : IsSquare a\nhb : -↑n = 0 * 0\n⊢ n = 0",
"usedConstants": [
"AddGroup.toSubtractionMonoid",
"Rat.instOfNat",
"NegZeroClass.toNeg",
"Rat.instMul",
"HMul.hMul",
"AddGroupWithOne.toAddGroup",
"congrArg"... | simp_all | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Tactic.NormNum.IsSquare | {
"line": 81,
"column": 4
} | {
"line": 81,
"column": 12
} | [
{
"pp": "case hb0\na : ℚ\nn d : ℕ\nhn : ¬IsSquare n\nha : IsNNRat a n d\nhnd : ↑d ≤ 0\nthis : n ≠ 1\n⊢ n.gcd d ≠ 1",
"usedConstants": [
"Nat.gcd",
"False",
"eq_false",
"Nat.gcd_zero_right",
"congrArg",
"Int.instLinearOrder",
"PartialOrder.toPreorder",
"Preorde... | simp_all | Lean.Elab.Tactic.evalSimpAll | Lean.Parser.Tactic.simpAll |
Mathlib.Tactic.NormNum.IsSquare | {
"line": 90,
"column": 4
} | {
"line": 90,
"column": 12
} | [
{
"pp": "case hb0\na : ℚ\nn d : ℕ\nhd : ¬IsSquare d\nha : IsNNRat a n d\nhnd : ↑d ≤ 0\n⊢ n.gcd d ≠ 1",
"usedConstants": [
"Nat.gcd",
"Eq.mpr",
"False",
"Nat.instMulZeroClass",
"Nat.gcd_zero_right",
"IsSquare.zero._simp_1",
"congrArg",
"Int.instLinearOrder",
... | simp_all | Lean.Elab.Tactic.evalSimpAll | Lean.Parser.Tactic.simpAll |
Mathlib.Tactic.NormNum.Irrational | {
"line": 183,
"column": 2
} | {
"line": 183,
"column": 10
} | [
{
"pp": "x y : ℝ\nx_num x_den y_num y_den k_den : ℕ\nhy_isNNRat : IsNNRat y y_num y_den\nhx_coprime : x_num.Coprime x_den\nhy_coprime : y_num.Coprime y_den\nhd1 : k_den ^ y_den < x_den\nhd2 : x_den < (k_den + 1) ^ y_den\nhx_inv : Invertible ↑x_den\nhx_eq : x = ↑x_num * ⅟↑x_den\nx✝ : ↑x_num = 0\n⊢ False",
"u... | simp_all | Lean.Elab.Tactic.evalSimpAll | Lean.Parser.Tactic.simpAll |
Mathlib.Tactic.NormNum.PowMod | {
"line": 74,
"column": 4
} | {
"line": 75,
"column": 56
} | [
{
"pp": "a b m : ℕ\n⊢ a ^ (2 * b + 1) % m = a ^ b % m * (a ^ b % m * a % m) % m",
"usedConstants": [
"Eq.mpr",
"NonAssocSemiring.toAddCommMonoidWithOne",
"Semigroup.toMul",
"HMul.hMul",
"Nat.mod_mod",
"Monoid.toMulOneClass",
"congrArg",
"Nat.instMonoid",
... | rw [pow_add, two_mul, pow_add, pow_one, Nat.mul_mod (a ^ b % m) a, Nat.mod_mod,
← Nat.mul_mod (a ^ b) a, ← Nat.mul_mod, mul_assoc] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.Testing.Plausible.Functions | {
"line": 112,
"column": 4
} | {
"line": 116,
"column": 38
} | [
{
"pp": "case mp\nα : Type u\nβ : Type v\ninst✝² : DecidableEq α\ninst✝¹ : Zero β\ninst✝ : DecidableEq β\na : α\nA : List ((_ : α) × β)\ny : β\n⊢ (∃ x, ⟨a, x⟩ ∈ A.dedupKeys ∧ (decide ¬x = 0) = true) → ¬(List.dlookup a A).getD 0 = 0",
"usedConstants": [
"Eq.mpr",
"instDecidableNot",
"Bool.n... | · rintro ⟨od, hval, hod⟩
have := List.mem_dlookup (List.nodupKeys_dedupKeys A) hval
rw [(_ : List.dlookup a A = od)]
· simpa using hod
· simpa [List.dlookup_dedupKeys] | Lean.Elab.Tactic.evalTacticCDot | Lean.cdot |
Mathlib.Topology.Algebra.Group.CompactOpen | {
"line": 168,
"column": 2
} | {
"line": 170,
"column": 20
} | [
{
"pp": "X : Type u_7\nY : Type u_8\ninst✝⁷ : TopologicalSpace X\ninst✝⁶ : Group X\ninst✝⁵ : IsTopologicalGroup X\ninst✝⁴ : UniformSpace Y\ninst✝³ : CommGroup Y\ninst✝² : IsUniformGroup Y\ninst✝¹ : T0Space Y\ninst✝ : CompactSpace Y\nU : Set X\nV : Set Y\nhU : IsCompact U\nhV : V ∈ 𝓝 1\nW : Set Y\nhWo : W ∈ 𝓝 ... | replace h : Equicontinuous ((↑) : S3 → X → Y) := by
rw [equicontinuous_iff_range, ← Set.image_eq_range] at h ⊢
rwa [← hS4] at h | Lean.Elab.Tactic.evalReplace | Lean.Parser.Tactic.replace |
Mathlib.Topology.Algebra.Group.CompactOpen | {
"line": 172,
"column": 18
} | {
"line": 172,
"column": 30
} | [
{
"pp": "X : Type u_7\nY : Type u_8\ninst✝⁷ : TopologicalSpace X\ninst✝⁶ : Group X\ninst✝⁵ : IsTopologicalGroup X\ninst✝⁴ : UniformSpace Y\ninst✝³ : CommGroup Y\ninst✝² : IsUniformGroup Y\ninst✝¹ : T0Space Y\ninst✝ : CompactSpace Y\nU : Set X\nV : Set Y\nhU : IsCompact U\nhV : V ∈ 𝓝 1\nW : Set Y\nhWo : W ∈ 𝓝 ... | Set.ext_iff, | Mathlib.Tactic._aux_Mathlib_Tactic_SimpRw___elabRules_Mathlib_Tactic_tacticSimp_rw____1 | null |
Mathlib.Topology.Algebra.Star.Unitary | {
"line": 35,
"column": 6
} | {
"line": 35,
"column": 10
} | [
{
"pp": "R : Type u_1\ninst✝⁵ : Monoid R\ninst✝⁴ : StarMul R\ninst✝³ : TopologicalSpace R\ninst✝² : T1Space R\ninst✝¹ : ContinuousStar R\ninst✝ : ContinuousMul R\nf : R → R × R := fun u ↦ (star u * u, u * star u)\nhf : f ⁻¹' {(1, 1)} = ↑(unitary R)\n⊢ IsClosed ↑(unitary R)",
"usedConstants": [
"Eq.mpr... | ← hf | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Topology.CWComplex.Classical.Graph | {
"line": 68,
"column": 15
} | {
"line": 68,
"column": 55
} | [
{
"pp": "X : Type u_1\ninst✝¹ : TopologicalSpace X\nC : Set X\ninst✝ : CWComplex C\ne : cell C 1\nh : (cellFrontier 1 e).Subsingleton\nx : cell C 0\nhxy : cellFrontier 1 e = {↑(map 0 x) ![], ↑(map 0 x) ![]}\n⊢ cellFrontier 1 e = closedCell 0 x",
"usedConstants": [
"Real",
"congrArg",
"Topo... | simp [hxy, closedCell_zero_eq_singleton] | Lean.Elab.Tactic.evalSimp | Lean.Parser.Tactic.simp |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.