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.Order.Interval.Set.SuccOrder | {
"line": 53,
"column": 2
} | {
"line": 54,
"column": 38
} | [
{
"pp": "J : Type u_1\ninst✝¹ : PartialOrder J\ninst✝ : PredOrder J\nj : J\ni : ↑(Ici j)\nhi : ¬IsMin i\n⊢ Order.pred i = ⟨Order.pred ↑i, ⋯⟩",
"usedConstants": [
"Set.Ici",
"Set.Ici.pred_eq_of_not_isMin._proof_1",
"congrArg",
"Set.ordConnected_Ici",
"PartialOrder.toPreorder",
... | ext
simp only [coe_pred_of_not_isMin hi] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.CategoryTheory.SmallObject.Iteration.ExtendToSucc | {
"line": 79,
"column": 8
} | {
"line": 80,
"column": 73
} | [
{
"pp": "case e_i.e_val\nC : Type u_1\ninst✝² : Category.{v_1, u_1} C\nJ : Type u\ninst✝¹ : LinearOrder J\ninst✝ : SuccOrder J\nj : J\nhj : ¬IsMax j\nF : ↑(Set.Iic j) ⥤ C\nX : C\nτ : F.obj ⟨j, ⋯⟩ ⟶ X\ni₁ i₂ : J\nhi : i₁ ≤ i₂\nhi₂ : i₂ ≤ Order.succ j\nh₁ : ¬i₂ ≤ j\nh₂ : ¬i₁ ≤ j\n⊢ i₁ = i₂",
"usedConstants": ... | rw [le_antisymm hi₂ (Order.succ_le_of_lt (not_le.1 h₁)),
le_antisymm (hi.trans hi₂) (Order.succ_le_of_lt (not_le.1 h₂))] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.CategoryTheory.SmallObject.Iteration.Nonempty | {
"line": 57,
"column": 24
} | {
"line": 64,
"column": 53
} | [
{
"pp": "C : Type u_1\ninst✝⁵ : Category.{v_1, u_1} C\nΦ : SuccStruct C\nJ : Type u\ninst✝⁴ : LinearOrder J\ninst✝³ : OrderBot J\ninst✝² : SuccOrder J\ninst✝¹ : WellFoundedLT J\ninst✝ : HasIterationOfShape J C\nj : J\nhj : ¬IsMax j\niter : Φ.Iteration j\ni : J\nhi₁ : i < Order.succ j\n⊢ arrowSucc (extendToSucc ... | by
rw [Order.lt_succ_iff_of_not_isMax hj] at hi₁
obtain hi₁ | rfl := hi₁.lt_or_eq
· rw [arrowSucc_def, arrowMap_extendToSucc _ _ _ _ _ _ (Order.succ_le_of_lt hi₁),
← arrowSucc_def _ _ hi₁, iter.arrowSucc_eq i hi₁,
extendToSucc_obj_eq hj iter.F (Φ.toSucc _) i hi₁.le]
· rw [arrowSucc_exten... | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.CategoryTheory.SmallObject.Iteration.Basic | {
"line": 155,
"column": 47
} | {
"line": 161,
"column": 21
} | [
{
"pp": "C : Type u\ninst✝ : Category.{v, u} C\nΦ : SuccStruct C\nX Y : C\nf : X ⟶ Y\n⊢ Φ.prop f ↔ Arrow.mk f = Φ.toSuccArrow X",
"usedConstants": [
"Eq.mpr",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"congrArg",
"HEq.refl",
"CategoryTheory.SmallObject.SuccS... | by
constructor
· rintro ⟨_⟩
rfl
· intro h
rw [← Φ.prop.arrow_mk_mem_toSet_iff, h]
apply prop_toSucc | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.CategoryTheory.SmallObject.TransfiniteIteration | {
"line": 74,
"column": 2
} | {
"line": 75,
"column": 67
} | [
{
"pp": "C : Type u\ninst✝⁵ : Category.{v, u} C\nΦ : SuccStruct C\nJ : Type w\ninst✝⁴ : LinearOrder J\ninst✝³ : OrderBot J\ninst✝² : SuccOrder J\ninst✝¹ : WellFoundedLT J\ninst✝ : HasIterationOfShape J C\ni₁ i₂ : J\nh₁₂ : i₁ ≤ i₂\nj : J\niter : Φ.Iteration j\nhj : i₂ ≤ j\n⊢ arrowMap (Φ.iter i₂).F i₁ i₂ ⋯ ⋯ = Ar... | exact Arrow.ext (Iteration.congr_obj _ _ _ _ _)
(Iteration.congr_obj _ _ _ _ _) (Iteration.congr_map _ _ _ _ _) | Lean.Elab.Tactic.evalExact | Lean.Parser.Tactic.exact |
Mathlib.CategoryTheory.SmallObject.WellOrderInductionData | {
"line": 196,
"column": 4
} | {
"line": 208,
"column": 23
} | [
{
"pp": "J : Type u\ninst✝² : LinearOrder J\ninst✝¹ : SuccOrder J\nF : Jᵒᵖ ⥤ Type v\nd : F.WellOrderInductionData\ninst✝ : OrderBot J\nval₀ : F.obj (op ⊥)\nj : J\ne : d.Extension val₀ j\nhj : ¬IsMax j\ni : J\nhi : Order.IsSuccLimit i\nhij : i ≤ Order.succ j\n⊢ (ConcreteCategory.hom (F.map (homOfLE hij).op)) (d.... | obtain hij | rfl := hij.lt_or_eq
· have hij' : i ≤ j := (Order.lt_succ_iff_of_not_isMax hj).mp hij
have := congr_arg (F.map (homOfLE hij').op) (d.map_succ j hj e.val)
rw [e.map_limit i hi, ← comp_apply, ← map_comp, ← op_comp, homOfLE_comp] at this
rw [this]
congr
ext ⟨⟨l, hl⟩⟩
ds... | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.CategoryTheory.SmallObject.WellOrderInductionData | {
"line": 196,
"column": 4
} | {
"line": 208,
"column": 23
} | [
{
"pp": "J : Type u\ninst✝² : LinearOrder J\ninst✝¹ : SuccOrder J\nF : Jᵒᵖ ⥤ Type v\nd : F.WellOrderInductionData\ninst✝ : OrderBot J\nval₀ : F.obj (op ⊥)\nj : J\ne : d.Extension val₀ j\nhj : ¬IsMax j\ni : J\nhi : Order.IsSuccLimit i\nhij : i ≤ Order.succ j\n⊢ (ConcreteCategory.hom (F.map (homOfLE hij).op)) (d.... | obtain hij | rfl := hij.lt_or_eq
· have hij' : i ≤ j := (Order.lt_succ_iff_of_not_isMax hj).mp hij
have := congr_arg (F.map (homOfLE hij').op) (d.map_succ j hj e.val)
rw [e.map_limit i hi, ← comp_apply, ← map_comp, ← op_comp, homOfLE_comp] at this
rw [this]
congr
ext ⟨⟨l, hl⟩⟩
ds... | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.CategoryTheory.SmallObject.IsCardinalForSmallObjectArgument | {
"line": 123,
"column": 2
} | {
"line": 123,
"column": 28
} | [
{
"pp": "C : Type u\ninst✝³ : Category.{v, u} C\nI : MorphismProperty C\nκ : Cardinal.{w}\ninst✝² : Fact κ.IsRegular\ninst✝¹ : OrderBot κ.ord.ToType\ninst✝ : I.IsCardinalForSmallObjectArgument κ\nX Y : C\np : X ⟶ Y\nthis✝ : LocallySmall.{w, v, u} C\nthis : IsSmall.{w, v, u} I\n⊢ HasColimitsOfShape (Discrete (Fu... | haveI := hasCoproducts I κ | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_tacticHaveI___1 | Lean.Parser.Tactic.tacticHaveI__ |
Mathlib.CategoryTheory.SmallObject.IsCardinalForSmallObjectArgument | {
"line": 486,
"column": 2
} | {
"line": 490,
"column": 71
} | [
{
"pp": "C : Type u\ninst✝¹ : Category.{v, u} C\nI : MorphismProperty C\ninst✝ : I.IsCardinalForSmallObjectArgument Cardinal.aleph0\n⊢ I.rlp.llp = ((coproducts.{w, v, u} I).pushouts.transfiniteCompositionsOfShape ℕ).retracts",
"usedConstants": [
"Eq.mpr",
"CategoryTheory.MorphismProperty",
... | let e : ℕ ≃o Cardinal.aleph0.{w}.ord.ToType :=
ULift.orderIso.{w}.symm.trans
(OrderIso.ofRelIsoLT (Nonempty.some (by simp [← Ordinal.type_eq])))
rw [SmallObject.llp_rlp_of_isCardinalForSmallObjectArgument' _ Cardinal.aleph0,
MorphismProperty.transfiniteCompositionsOfShape_eq_of_orderIso _ e] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.CategoryTheory.SmallObject.IsCardinalForSmallObjectArgument | {
"line": 486,
"column": 2
} | {
"line": 490,
"column": 71
} | [
{
"pp": "C : Type u\ninst✝¹ : Category.{v, u} C\nI : MorphismProperty C\ninst✝ : I.IsCardinalForSmallObjectArgument Cardinal.aleph0\n⊢ I.rlp.llp = ((coproducts.{w, v, u} I).pushouts.transfiniteCompositionsOfShape ℕ).retracts",
"usedConstants": [
"Eq.mpr",
"CategoryTheory.MorphismProperty",
... | let e : ℕ ≃o Cardinal.aleph0.{w}.ord.ToType :=
ULift.orderIso.{w}.symm.trans
(OrderIso.ofRelIsoLT (Nonempty.some (by simp [← Ordinal.type_eq])))
rw [SmallObject.llp_rlp_of_isCardinalForSmallObjectArgument' _ Cardinal.aleph0,
MorphismProperty.transfiniteCompositionsOfShape_eq_of_orderIso _ e] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.CategoryTheory.Abelian.GrothendieckCategory.EnoughInjectives | {
"line": 207,
"column": 2
} | {
"line": 207,
"column": 45
} | [
{
"pp": "C : Type u\ninst✝² : Category.{v, u} C\nG : C\ninst✝¹ : Abelian C\nhG : IsSeparator G\nX : C\ninst✝ : IsGrothendieckAbelian.{w, v, u} C\nA₀ : Subobject X\nκ : Cardinal.{w} := Order.succ (Cardinal.mk (Shrink.{w, max u v} (Subobject X)))\n⊢ ∃ o j, transfiniteIterate (largerSubobject hG) j A₀ = ⊤",
"u... | have : Nonempty κ.ord.ToType := by simp [κ] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_tacticHave___1 | Lean.Parser.Tactic.tacticHave__ |
Mathlib.NumberTheory.Padics.PadicVal.Basic | {
"line": 548,
"column": 4
} | {
"line": 553,
"column": 15
} | [
{
"pp": "case succ\np m : ℕ\nhp : Fact (Nat.Prime p)\nn : ℕ\nhn : n < p → padicValNat p (p * m + n)! = padicValNat p (p * m)!\nh : n + 1 < p\n⊢ padicValNat p (p * m + (n + 1))! = padicValNat p (p * m)!",
"usedConstants": [
"Iff.mpr",
"Eq.mpr",
"Preorder.toLT",
"Nat.instIsOrderedAddMo... | rw [add_succ, factorial_succ,
padicValNat.mul (succ_ne_zero (p * m + n)) <| factorial_ne_zero (p * m + _),
hn <| lt_of_succ_lt h, ← add_succ,
padicValNat_eq_zero_of_mem_Ioo ⟨(Nat.lt_add_of_pos_right <| succ_pos n),
(Nat.mul_add _ _ _▸ Nat.mul_one _ ▸ ((add_lt_add_iff_left (p * m)).mpr h))⟩,
... | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.NumberTheory.Padics.PadicVal.Basic | {
"line": 548,
"column": 4
} | {
"line": 553,
"column": 15
} | [
{
"pp": "case succ\np m : ℕ\nhp : Fact (Nat.Prime p)\nn : ℕ\nhn : n < p → padicValNat p (p * m + n)! = padicValNat p (p * m)!\nh : n + 1 < p\n⊢ padicValNat p (p * m + (n + 1))! = padicValNat p (p * m)!",
"usedConstants": [
"Iff.mpr",
"Eq.mpr",
"Preorder.toLT",
"Nat.instIsOrderedAddMo... | rw [add_succ, factorial_succ,
padicValNat.mul (succ_ne_zero (p * m + n)) <| factorial_ne_zero (p * m + _),
hn <| lt_of_succ_lt h, ← add_succ,
padicValNat_eq_zero_of_mem_Ioo ⟨(Nat.lt_add_of_pos_right <| succ_pos n),
(Nat.mul_add _ _ _▸ Nat.mul_one _ ▸ ((add_lt_add_iff_left (p * m)).mpr h))⟩,
... | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.NumberTheory.Padics.PadicVal.Basic | {
"line": 548,
"column": 4
} | {
"line": 553,
"column": 15
} | [
{
"pp": "case succ\np m : ℕ\nhp : Fact (Nat.Prime p)\nn : ℕ\nhn : n < p → padicValNat p (p * m + n)! = padicValNat p (p * m)!\nh : n + 1 < p\n⊢ padicValNat p (p * m + (n + 1))! = padicValNat p (p * m)!",
"usedConstants": [
"Iff.mpr",
"Eq.mpr",
"Preorder.toLT",
"Nat.instIsOrderedAddMo... | rw [add_succ, factorial_succ,
padicValNat.mul (succ_ne_zero (p * m + n)) <| factorial_ne_zero (p * m + _),
hn <| lt_of_succ_lt h, ← add_succ,
padicValNat_eq_zero_of_mem_Ioo ⟨(Nat.lt_add_of_pos_right <| succ_pos n),
(Nat.mul_add _ _ _▸ Nat.mul_one _ ▸ ((add_lt_add_iff_left (p * m)).mpr h))⟩,
... | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.CategoryTheory.Abelian.GrothendieckCategory.EnoughInjectives | {
"line": 308,
"column": 25
} | {
"line": 308,
"column": 37
} | [
{
"pp": "case a\nC : Type u\ninst✝² : Category.{v, u} C\nG : C\ninst✝¹ : Abelian C\ninst✝ : IsGrothendieckAbelian.{w, v, u} C\nhG : IsSeparator G\nX Y : C\np : X ⟶ Y\nhp : (generatingMonomorphisms G).rlp p\nA B : C\ni : A ⟶ B\n⊢ monomorphisms C i → HasLiftingProperty i p",
"usedConstants": [
"Category... | (_ : Mono i) | Lean.Elab.Tactic.evalIntro | Lean.Parser.Term.typeAscription |
Mathlib.NumberTheory.Padics.PadicVal.Basic | {
"line": 669,
"column": 2
} | {
"line": 669,
"column": 21
} | [
{
"pp": "p : ℕ\na : ℤ\n⊢ ↑p ^ padicValInt p a ∣ a",
"usedConstants": [
"Dvd.dvd",
"padicValInt",
"instOfNatNat",
"Int",
"Nat.cast",
"dite",
"Int.instDvd",
"Int.instMonoid",
"Monoid.toPow",
"HPow.hPow",
"Nat",
"instDecidableEqNat",
... | by_cases hp : p = 1 | «_aux_Init_ByCases___macroRules_tacticBy_cases_:__2» | «tacticBy_cases_:_» |
Mathlib.AlgebraicGeometry.Sites.Representability | {
"line": 104,
"column": 6
} | {
"line": 107,
"column": 87
} | [
{
"pp": "case a\nF : Sheaf zariskiTopology (Type u)\nι : Type u\nX : ι → Scheme\nf : (i : ι) → yoneda.obj (X i) ⟶ F.obj\nhf : ∀ (i : ι), IsOpenImmersion.presheaf (f i)\ni✝ j✝ k : ι\ni j : (glueData hf).J\n⊢ yonedaEquiv.symm ((ConcreteCategory.hom (F.obj.map (⋯.fst' (f j)).op)) (yonedaEquiv (f i))) =\n yoneda... | rw [yonedaEquiv_naturality, Equiv.symm_apply_apply,
Functor.map_comp_apply, yonedaEquiv_naturality, yonedaEquiv_naturality,
Equiv.symm_apply_apply, ← Functor.map_comp_assoc,
Functor.relativelyRepresentable.symmetry_fst, ((hf i).rep.isPullback' (f j)).w] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.NumberTheory.Padics.PadicNumbers | {
"line": 613,
"column": 8
} | {
"line": 613,
"column": 46
} | [
{
"pp": "case hb\np : ℕ\nhp : Fact (Nat.Prime p)\nq r : ℚ_[p]\n⊢ 0 ≤ Quotient.lift PadicSeq.norm ⋯ r",
"usedConstants": [
"padicNorm.instIsAbsoluteValueRat",
"NormedCommRing.toNormedRing",
"NormedRing.toRing",
"AddMonoid.toAddZeroClass",
"Rat",
"PartialOrder.toPreorder",
... | induction r using Quotient.inductionOn | _private.Lean.Elab.Tactic.Induction.0.Lean.Elab.Tactic.evalInduction | Lean.Parser.Tactic.induction |
Mathlib.CategoryTheory.MorphismProperty.Representable | {
"line": 585,
"column": 2
} | {
"line": 598,
"column": 74
} | [
{
"pp": "C : Type u₁\ninst✝⁷ : Category.{v₁, u₁} C\nD : Type u₂\ninst✝⁶ : Category.{v₂, u₂} D\nF : C ⥤ D\ninst✝⁵ : HasBinaryProducts C\ninst✝⁴ : HasPullbacks D\ninst✝³ : HasBinaryProducts D\ninst✝² : HasTerminal D\ninst✝¹ : F.Full\ninst✝ : PreservesLimitsOfShape (Discrete WalkingPair) F\nX : D\nh : F.relatively... | rw [(by cat_disch : Limits.diag X = pullback.lift (𝟙 X) (𝟙 X) ≫ (prodIsoPullback X X).inv)] at h
intro a' g'
obtain ⟨_, ⟨left⟩⟩ := pullback_map_diagonal_isPullback g g' (terminal.from X)
let prodMap : F.obj (a ⨯ a') ⟶ X ⨯ X :=
(preservesLimitIso _ (pair _ _) ≪≫ HasLimit.isoOfNatIso (pairComp _ _ _)).hom ≫ p... | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.CategoryTheory.MorphismProperty.Representable | {
"line": 585,
"column": 2
} | {
"line": 598,
"column": 74
} | [
{
"pp": "C : Type u₁\ninst✝⁷ : Category.{v₁, u₁} C\nD : Type u₂\ninst✝⁶ : Category.{v₂, u₂} D\nF : C ⥤ D\ninst✝⁵ : HasBinaryProducts C\ninst✝⁴ : HasPullbacks D\ninst✝³ : HasBinaryProducts D\ninst✝² : HasTerminal D\ninst✝¹ : F.Full\ninst✝ : PreservesLimitsOfShape (Discrete WalkingPair) F\nX : D\nh : F.relatively... | rw [(by cat_disch : Limits.diag X = pullback.lift (𝟙 X) (𝟙 X) ≫ (prodIsoPullback X X).inv)] at h
intro a' g'
obtain ⟨_, ⟨left⟩⟩ := pullback_map_diagonal_isPullback g g' (terminal.from X)
let prodMap : F.obj (a ⨯ a') ⟶ X ⨯ X :=
(preservesLimitIso _ (pair _ _) ≪≫ HasLimit.isoOfNatIso (pairComp _ _ _)).hom ≫ p... | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.NumberTheory.Padics.PadicNumbers | {
"line": 928,
"column": 6
} | {
"line": 930,
"column": 48
} | [] | ‖(k : ℚ_[p])‖ = ‖((k : ℚ) : ℚ_[p])‖ := by norm_cast
_ = padicNorm p k := eq_padicNorm _
_ = 1 := mod_cast (int_eq_one_iff k).mpr h | Lean.Elab.Tactic._aux_Mathlib_Tactic_Widget_Calc___elabRules_Lean_calcTactic_1 | Lean.calcSteps |
Mathlib.AlgebraicTopology.DoldKan.NCompGamma | {
"line": 101,
"column": 8
} | {
"line": 101,
"column": 46
} | [
{
"pp": "case pos\nC : Type u_1\ninst✝² : Category.{v_1, u_1} C\ninst✝¹ : Preadditive C\nX : SimplicialObject C\nn : ℕ\ni : ⦋n⦌ ⟶ ⦋n + 1⦌\ninst✝ : Mono i\nh : ¬n = n + 1\nhi : Isδ₀ i\n⊢ ∑ j, PInfty.f (n + 1) ≫ ((-1) ^ ↑j • X.δ j) = PInfty.f (n + 1) ≫ X.map i.op",
"usedConstants": [
"Eq.mpr",
"in... | Finset.sum_eq_single (0 : Fin (n + 2)) | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Topology.Homotopy.Basic | {
"line": 255,
"column": 4
} | {
"line": 255,
"column": 17
} | [
{
"pp": "case pos\nX : Type u\nY : Type v\ninst✝¹ : TopologicalSpace X\ninst✝ : TopologicalSpace Y\nf₀ f₁ f₂ : C(X, Y)\nF : f₀.Homotopy f₁\nG : f₁.Homotopy f₂\nt : ↑I\nsnd✝ : X\nh₁ : 1 - ↑t ≤ 1 / 2\nh₂ : ↑t ≤ 1 / 2\nht : ↑t = 1 / 2\n⊢ F (⟨2 * (1 - ↑t), ⋯⟩, snd✝) = G (σ ⟨2 * ↑t, ⋯⟩, snd✝)",
"usedConstants": ... | norm_num [ht] | Mathlib.Tactic._aux_Mathlib_Tactic_NormNum_Core___elabRules_Mathlib_Tactic_normNum_1 | Mathlib.Tactic.normNum |
Mathlib.Topology.Homotopy.Path | {
"line": 167,
"column": 6
} | {
"line": 167,
"column": 19
} | [
{
"pp": "case inl\nX : Type u\nY : Type v\ninst✝¹ : TopologicalSpace X\ninst✝ : TopologicalSpace Y\nx₀ x₁ x₂ x₃ : X\np₀ q₀ : Path x₀ x₁\np₁ q₁ : Path x₁ x₂\nF : p₀.Homotopy q₀\nG : p₁.Homotopy q₁\nx t : ↑I\nht : t = 0\n⊢ {\n toFun := fun x_1 ↦\n if ↑(x, x_1).2 ≤ 1 / 2 then (F.eval (x, x_1).1).ex... | norm_num [ht] | Mathlib.Tactic._aux_Mathlib_Tactic_NormNum_Core___elabRules_Mathlib_Tactic_normNum_1 | Mathlib.Tactic.normNum |
Mathlib.Topology.Homotopy.Path | {
"line": 167,
"column": 6
} | {
"line": 167,
"column": 19
} | [
{
"pp": "case inl\nX : Type u\nY : Type v\ninst✝¹ : TopologicalSpace X\ninst✝ : TopologicalSpace Y\nx₀ x₁ x₂ x₃ : X\np₀ q₀ : Path x₀ x₁\np₁ q₁ : Path x₁ x₂\nF : p₀.Homotopy q₀\nG : p₁.Homotopy q₁\nx t : ↑I\nht : t = 0\n⊢ {\n toFun := fun x_1 ↦\n if ↑(x, x_1).2 ≤ 1 / 2 then (F.eval (x, x_1).1).ex... | norm_num [ht] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Topology.Homotopy.Path | {
"line": 167,
"column": 6
} | {
"line": 167,
"column": 19
} | [
{
"pp": "case inl\nX : Type u\nY : Type v\ninst✝¹ : TopologicalSpace X\ninst✝ : TopologicalSpace Y\nx₀ x₁ x₂ x₃ : X\np₀ q₀ : Path x₀ x₁\np₁ q₁ : Path x₁ x₂\nF : p₀.Homotopy q₀\nG : p₁.Homotopy q₁\nx t : ↑I\nht : t = 0\n⊢ {\n toFun := fun x_1 ↦\n if ↑(x, x_1).2 ≤ 1 / 2 then (F.eval (x, x_1).1).ex... | norm_num [ht] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Topology.Homotopy.Path | {
"line": 169,
"column": 6
} | {
"line": 169,
"column": 19
} | [
{
"pp": "case inr\nX : Type u\nY : Type v\ninst✝¹ : TopologicalSpace X\ninst✝ : TopologicalSpace Y\nx₀ x₁ x₂ x₃ : X\np₀ q₀ : Path x₀ x₁\np₁ q₁ : Path x₁ x₂\nF : p₀.Homotopy q₀\nG : p₁.Homotopy q₁\nx t : ↑I\nht : t = 1\n⊢ {\n toFun := fun x_1 ↦\n if ↑(x, x_1).2 ≤ 1 / 2 then (F.eval (x, x_1).1).ex... | norm_num [ht] | Mathlib.Tactic._aux_Mathlib_Tactic_NormNum_Core___elabRules_Mathlib_Tactic_normNum_1 | Mathlib.Tactic.normNum |
Mathlib.Topology.Homotopy.Path | {
"line": 213,
"column": 18
} | {
"line": 219,
"column": 10
} | [
{
"pp": "X : Type u\nY : Type v\ninst✝¹ : TopologicalSpace X\ninst✝ : TopologicalSpace Y\nx₀ x₁ x₂ x₃ : X\np q : Path x₀ x₁\nF : p.Homotopy q\nt x : ↑I\nhx : x ∈ {0, 1}\n⊢ { toFun := fun x ↦ F ((t, x).1, σ (t, x).2), continuous_toFun := ⋯ } x = p.symm.toContinuousMap x",
"usedConstants": [
"Real.instI... | by
rcases hx with hx | hx
· rw [hx]
simp
· rw [Set.mem_singleton_iff] at hx
rw [hx]
simp | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.AlgebraicTopology.FundamentalGroupoid.InducedMaps | {
"line": 50,
"column": 2
} | {
"line": 50,
"column": 94
} | [
{
"pp": "X : Type u_1\nY : Type u_2\ninst✝¹ : TopologicalSpace X\ninst✝ : TopologicalSpace Y\nf g : C(X, Y)\nF : f.Homotopy g\nx₁ x₂ : X\np : Path x₁ x₂\nG : C(↑I × ↑I, Y) := F.comp ((ContinuousMap.id ↑I).prodMap ↑p)\np₁ : Path (0, 0) (1, 1) := ((Path.refl 0).trans Path.id).prod (Path.id.trans (Path.refl 1))\n⊢... | set p₂ : Path ((0, 0) : I × I) (1, 1) := .prod (.trans .id (.refl _)) (.trans (.refl _) .id) | Mathlib.Tactic._aux_Mathlib_Tactic_Set___elabRules_Mathlib_Tactic_setTactic_1 | Mathlib.Tactic.setTactic |
Mathlib.AlgebraicTopology.ModelCategory.Homotopy | {
"line": 194,
"column": 31
} | {
"line": 194,
"column": 39
} | [
{
"pp": "C : Type u\ninst✝⁴ : Category.{v, u} C\ninst✝³ : ModelCategory C\nX Y Z : C\ninst✝² : IsFibrant Z\nf : X ⟶ Y\ninst✝¹ : Cofibration f\ninst✝ : WeakEquivalence f\nf₀ f₁ : Y ⟶ Z\nh✝ : RightHomotopyRel (f ≫ f₀) (f ≫ f₁)\nP : PathObject Z\nleft✝ : P.IsGood\nh : P.RightHomotopy (f ≫ f₀) (f ≫ f₁)\nsq : CommSq... | P.p_snd, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.AlgebraicTopology.ModelCategory.CofibrantObjectHomotopy | {
"line": 108,
"column": 6
} | {
"line": 108,
"column": 38
} | [
{
"pp": "C : Type u_1\ninst✝¹ : Category.{v_1, u_1} C\ninst✝ : ModelCategory C\nX Y : CofibrantObject C\nf g : X ⟶ Y\nh✝ : homRel C f g\nP : PathObject Y.obj\nleft✝ : P.IsVeryGood\nh : P.RightHomotopy f.hom g.hom\nL : CofibrantObject C ⥤ (weakEquivalences (CofibrantObject C)).Localization := (weakEquivalences (... | areEqualizedByLocalization_iff L | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.AlgebraicTopology.ModelCategory.FibrantObjectHomotopy | {
"line": 111,
"column": 6
} | {
"line": 111,
"column": 38
} | [
{
"pp": "C : Type u_1\ninst✝¹ : Category.{v_1, u_1} C\ninst✝ : ModelCategory C\nX Y : FibrantObject C\nf g : X ⟶ Y\nh✝ : homRel C f g\nP : Cylinder X.obj\nleft✝ : P.IsVeryGood\nh : P.LeftHomotopy f.hom g.hom\nL : FibrantObject C ⥤ (weakEquivalences (FibrantObject C)).Localization := (weakEquivalences (FibrantOb... | areEqualizedByLocalization_iff L | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.CategoryTheory.GuitartExact.VerticalComposition | {
"line": 182,
"column": 61
} | {
"line": 183,
"column": 83
} | [
{
"pp": "C₁ : Type u_1\nC₂ : Type u_2\nC₃ : Type u_3\nD₁ : Type u_4\nD₂ : Type u_5\nD₃ : Type u_6\ninst✝⁵ : Category.{v_1, u_1} C₁\ninst✝⁴ : Category.{v_2, u_2} C₂\ninst✝³ : Category.{v_3, u_3} C₃\ninst✝² : Category.{v_4, u_4} D₁\ninst✝¹ : Category.{v_5, u_5} D₂\ninst✝ : Category.{v_6, u_6} D₃\nH₁ : C₁ ⥤ D₁\nL₁... | by
rw [← vComp_iff_of_equivalences w E E' w', TwoSquare.vComp', whiskerVertical_iff] | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.CategoryTheory.Localization.DerivabilityStructure.Basic | {
"line": 104,
"column": 2
} | {
"line": 115,
"column": 8
} | [
{
"pp": "C₁ : Type u₁\nC₂ : Type u₂\ninst✝⁶ : Category.{v₁, u₁} C₁\ninst✝⁵ : Category.{v₂, u₂} C₂\nW₁ : MorphismProperty C₁\nW₂ : MorphismProperty C₂\nΦ : LocalizerMorphism W₁ W₂\nD₁ : Type u_1\nD₂ : Type u_2\ninst✝⁴ : Category.{v_1, u_1} D₁\ninst✝³ : Category.{v_2, u_2} D₂\nL₁ : C₁ ⥤ D₁\nL₂ : C₂ ⥤ D₂\ninst✝² :... | have : TwoSquare.vComp' e'.hom e'''.hom e₁ e₂ = e.hom := by
ext X₁
rw [TwoSquare.vComp'_app, liftNatIso_hom, liftNatTrans_app]
simp only [Functor.comp_obj, Iso.trans_hom, isoWhiskerLeft_hom, isoWhiskerRight_hom,
Iso.symm_hom, NatTrans.comp_app, Functor.associator_hom_app, whiskerLeft_app,
whiske... | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_tacticHave___1 | Lean.Parser.Tactic.tacticHave__ |
Mathlib.CategoryTheory.GuitartExact.Basic | {
"line": 277,
"column": 47
} | {
"line": 279,
"column": 10
} | [
{
"pp": "C₁ : Type u₁\nC₂ : Type u₂\nC₃ : Type u₃\nC₄ : Type u₄\ninst✝³ : Category.{v₁, u₁} C₁\ninst✝² : Category.{v₂, u₂} C₂\ninst✝¹ : Category.{v₃, u₃} C₃\ninst✝ : Category.{v₄, u₄} C₄\nT : C₁ ⥤ C₂\nL : C₁ ⥤ C₃\nR : C₂ ⥤ C₄\nB : C₃ ⥤ C₄\nw : TwoSquare T L R B\nhw : w.GuitartExact\nX₂ : C₂\n⊢ (w.structuredArro... | by
rw [guitartExact_iff_initial] at hw
apply hw | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.AlgebraicTopology.SimplicialSet.Boundary | {
"line": 93,
"column": 2
} | {
"line": 93,
"column": 9
} | [
{
"pp": "⊢ ∂Δ[0] = ⊥",
"usedConstants": [
"Lattice.toSemilatticeSup",
"Opposite",
"CompleteLattice.toLattice",
"OrderBot.toBot",
"PartialOrder.toPreorder",
"CategoryTheory.Functor.category",
"CategoryTheory.Subfunctor.ext",
"Preorder.toLE",
"CategoryTheo... | ext m x | _private.Lean.Elab.Tactic.Ext.0.Lean.Elab.Tactic.Ext.evalExt | Lean.Elab.Tactic.Ext.ext |
Mathlib.AlgebraicTopology.SimplicialSet.Boundary | {
"line": 147,
"column": 4
} | {
"line": 148,
"column": 51
} | [
{
"pp": "case mpr\nn : ℕ\nA : Δ[n].Subcomplex\n⊢ ∂Δ[n] ≤ A ∧ A ≠ ⊤ → A = ∂Δ[n]",
"usedConstants": [
"Eq.mpr",
"Lattice.toSemilatticeSup",
"Opposite",
"CompleteLattice.toLattice",
"congrArg",
"PartialOrder.toPreorder",
"CategoryTheory.Functor.category",
"Preord... | rintro ⟨h₁, h₂⟩
exact le_antisymm (by rwa [le_boundary_iff]) h₁ | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.AlgebraicTopology.SimplicialSet.Boundary | {
"line": 147,
"column": 4
} | {
"line": 148,
"column": 51
} | [
{
"pp": "case mpr\nn : ℕ\nA : Δ[n].Subcomplex\n⊢ ∂Δ[n] ≤ A ∧ A ≠ ⊤ → A = ∂Δ[n]",
"usedConstants": [
"Eq.mpr",
"Lattice.toSemilatticeSup",
"Opposite",
"CompleteLattice.toLattice",
"congrArg",
"PartialOrder.toPreorder",
"CategoryTheory.Functor.category",
"Preord... | rintro ⟨h₁, h₂⟩
exact le_antisymm (by rwa [le_boundary_iff]) h₁ | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.CategoryTheory.Limits.Types.Multicoequalizer | {
"line": 48,
"column": 77
} | {
"line": 48,
"column": 93
} | [
{
"pp": "J : MultispanShape\nd : MultispanIndex J (Type u)\nc : d.multispan.CoconeTypes\nl : J.L\nz : d.multispan.obj (WalkingMultispan.left l)\n⊢ d.multispan.ιColimitType (WalkingMultispan.right (J.fst l))\n ((ConcreteCategory.hom (d.multispan.map (WalkingMultispan.Hom.fst l))) z) =\n d.multispan.ιColi... | ιColimitType_map | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.AlgebraicTopology.SimplicialSet.Horn | {
"line": 131,
"column": 10
} | {
"line": 131,
"column": 39
} | [
{
"pp": "n : ℕ\nA : Δ[n + 1].Subcomplex\ni : Fin (n + 2)\nh : ¬stdSimplex.face {i}ᶜ ≤ A\nS : Finset (Fin (n + 1 + 1))\nhx : stdSimplex.face S ≤ A\nhd : n ≤ n\nhS : Sᶜ.card = 1\n⊢ ∃ j, S = {j}ᶜ",
"usedConstants": [
"SimplexCategory.instFintypeToTypeOrderHomFinHAddNatLenOfNat",
"Finset.card_eq_one... | rw [Finset.card_eq_one] at hS | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.AlgebraicTopology.Quasicategory.StrictSegal | {
"line": 45,
"column": 4
} | {
"line": 45,
"column": 65
} | [
{
"pp": "case h.a.h.inl\nX : SSet\nsx : X.StrictSegal\nn : ℕ\ni : Fin (n + 3)\nσ₀ : Λ[n + 2, i].toSSet ⟶ X\nh₀ : 0 < i\nhₙ : i < Fin.last (n + 2)\nj : Fin (n + 3)\nhj : j ≠ i\nk : Fin (n + 1)\nksucc : Fin (n + 1 + 1 + 1) := k.succ.castSucc\nhlt : ksucc < j\n⊢ ((horn.spineId i h₀ hₙ).map σ₀).arrow k.castSucc =\n... | dsimp only [Path.map_arrow, spine_arrow, Fin.coe_eq_castSucc] | Lean.Elab.Tactic.evalDSimp | Lean.Parser.Tactic.dsimp |
Mathlib.AlgebraicTopology.SimplicialSet.HornColimits | {
"line": 403,
"column": 2
} | {
"line": 405,
"column": 54
} | [
{
"pp": "X : SSet\nf₀ f₁ f₃ : Δ[2] ⟶ X\nh₀₂ : stdSimplex.δ 2 ≫ f₁ = stdSimplex.δ 1 ≫ f₃\nh₁₂ : stdSimplex.δ 2 ≫ f₀ = stdSimplex.δ 0 ≫ f₃\nh₂₃ : stdSimplex.δ 0 ≫ f₀ = stdSimplex.δ 0 ≫ f₁\n⊢ ι₁ ≫ desc f₀ f₁ f₃ h₀₂ h₁₂ h₂₃ = f₁",
"usedConstants": [
"SSet.Subcomplex.toSSet",
"Eq.mpr",
"Categor... | rw [← cancel_epi (stdSimplex.faceSingletonComplIso.{u} 1).inv, ← Category.assoc,
horn.faceSingletonComplIso_inv_ι]
exact (horn.isColimit 2).fac _ (.right ⟨1, by simp⟩) | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.AlgebraicTopology.SimplicialSet.HornColimits | {
"line": 403,
"column": 2
} | {
"line": 405,
"column": 54
} | [
{
"pp": "X : SSet\nf₀ f₁ f₃ : Δ[2] ⟶ X\nh₀₂ : stdSimplex.δ 2 ≫ f₁ = stdSimplex.δ 1 ≫ f₃\nh₁₂ : stdSimplex.δ 2 ≫ f₀ = stdSimplex.δ 0 ≫ f₃\nh₂₃ : stdSimplex.δ 0 ≫ f₀ = stdSimplex.δ 0 ≫ f₁\n⊢ ι₁ ≫ desc f₀ f₁ f₃ h₀₂ h₁₂ h₂₃ = f₁",
"usedConstants": [
"SSet.Subcomplex.toSSet",
"Eq.mpr",
"Categor... | rw [← cancel_epi (stdSimplex.faceSingletonComplIso.{u} 1).inv, ← Category.assoc,
horn.faceSingletonComplIso_inv_ι]
exact (horn.isColimit 2).fac _ (.right ⟨1, by simp⟩) | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.CategoryTheory.Enriched.Basic | {
"line": 518,
"column": 31
} | {
"line": 518,
"column": 66
} | [
{
"pp": "V : Type v\ninst✝² : Category.{w, v} V\ninst✝¹ : MonoidalCategory V\nC✝ : Type u₁\ninst✝ : EnrichedCategory V C✝\nC : Type u₁\n𝒞 : EnrichedCategory (Type v) C\nD : Type u₂\n𝒟 : EnrichedCategory (Type v) D\nF : C ⥤ D\nX Y Z : C\n⊢ (eComp (Type v) X Y Z ≫ ↾fun f ↦ F.map f) =\n ((↾fun f ↦ F.map f) ⊗ₘ... | by ext ⟨f, g⟩; exact F.map_comp f g | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.AlgebraicTopology.SimplicialSet.HomotopyCat | {
"line": 129,
"column": 4
} | {
"line": 130,
"column": 76
} | [
{
"pp": "X : Truncated 2\nC : Type u\ninst✝ : Category.{u, u} C\nF G : X ⟶ (truncation 2).obj (nerve C)\nh : map F = map G\nf : X.obj (op { obj := ⦋1⦌, property := ⋯ })\n⊢ (ConcreteCategory.hom (F.app (op { obj := ⦋1⦌, property := ⋯ }))) f =\n (ConcreteCategory.hom (G.app (op { obj := ⦋1⦌, property := ⋯ })))... | obtain ⟨x₀, x₁, f, rfl⟩ := Truncated.Edge.exists_of_simplex f
simpa using congr_arg Truncated.Edge.edge (ReflPrefunctor.congr_hom h f) | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.AlgebraicTopology.SimplicialSet.HomotopyCat | {
"line": 129,
"column": 4
} | {
"line": 130,
"column": 76
} | [
{
"pp": "X : Truncated 2\nC : Type u\ninst✝ : Category.{u, u} C\nF G : X ⟶ (truncation 2).obj (nerve C)\nh : map F = map G\nf : X.obj (op { obj := ⦋1⦌, property := ⋯ })\n⊢ (ConcreteCategory.hom (F.app (op { obj := ⦋1⦌, property := ⋯ }))) f =\n (ConcreteCategory.hom (G.app (op { obj := ⦋1⦌, property := ⋯ })))... | obtain ⟨x₀, x₁, f, rfl⟩ := Truncated.Edge.exists_of_simplex f
simpa using congr_arg Truncated.Edge.edge (ReflPrefunctor.congr_hom h f) | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.AlgebraicTopology.SimplexCategory.GeneratorsRelations.Basic | {
"line": 149,
"column": 4
} | {
"line": 149,
"column": 37
} | [
{
"pp": "case of.inr\nP : MorphismProperty SimplexCategoryGenRel\nid : ∀ {n : ℕ}, P (𝟙 (mk n))\ncomp_δ : ∀ {n m : ℕ} (u : mk n ⟶ mk m) (i : Fin (m + 2)), P u → P (u ≫ δ i)\ncomp_σ : ∀ {n m : ℕ} (u : mk n ⟶ mk (m + 1)) (i : Fin (m + 1)), P u → P (u ≫ σ i)\na b : SimplexCategoryGenRel\nf✝ : a ⟶ b\nX✝ Y✝ : Simple... | · simpa using (comp_σ (𝟙 _) i id) | Lean.Elab.Tactic.evalTacticCDot | Lean.cdot |
Mathlib.AlgebraicTopology.SimplexCategory.GeneratorsRelations.EpiMono | {
"line": 110,
"column": 2
} | {
"line": 110,
"column": 51
} | [
{
"pp": "n : ℕ\ni : Fin (n + 2)\ni' : Fin (n + 3)\n⊢ δ i' ≫ σ i = 𝟙 (mk (n + 1)) ∨ ∃ j j', δ i' ≫ σ i = σ j ≫ δ j'",
"usedConstants": [
"instOfNatNat",
"instHAdd",
"Fin.instLinearOrder",
"HAdd.hAdd",
"Nat",
"instAddNat",
"Fin.castSucc",
"OfNat.ofNat",
"... | obtain h | rfl | h := lt_trichotomy i.castSucc i' | _private.Lean.Elab.Tactic.RCases.0.Lean.Elab.Tactic.RCases.evalObtain | Lean.Parser.Tactic.obtain |
Mathlib.AlgebraicTopology.SimplexCategory.GeneratorsRelations.NormalForms | {
"line": 205,
"column": 2
} | {
"line": 205,
"column": 17
} | [
{
"pp": "case cons\na : ℕ\nt : List ℕ\nH :\n ∀ (L₁ : List ℕ) {m₁ m₂ m₃ : ℕ} (h : m₂ + L₁.length = m₁) (h' : m₃ + t.length = m₂),\n standardσ L₁ h ≫ standardσ t h' = standardσ (t ++ L₁) ⋯\nL₁ : List ℕ\nm₁ m₂ m₃ : ℕ\nh : m₂ + L₁.length = m₁\nh' : m₃ + (a :: t).length = m₂\n⊢ standardσ L₁ h ≫ standardσ (a :: t... | | cons a t H => | _private.Lean.Elab.Tactic.Induction.0.Lean.Elab.Tactic.evalInduction | null |
Mathlib.AlgebraicTopology.SimplexCategory.GeneratorsRelations.NormalForms | {
"line": 227,
"column": 50
} | {
"line": 227,
"column": 88
} | [
{
"pp": "case cons\nL : List ℕ\nj head✝ : ℕ\ntail✝ : List ℕ\ntail_ih✝ : (∀ k ∈ tail✝, j ≤ k) → simplicialEvalσ tail✝ j = j\nhj : ∀ k ∈ head✝ :: tail✝, j ≤ k\n⊢ simplicialEvalσ (head✝ :: tail✝) j = j",
"usedConstants": [
"Membership.mem",
"Eq.mp",
"LE.le",
"instLENat",
"List.con... | simp only [List.forall_mem_cons] at hj | Lean.Elab.Tactic.evalSimp | Lean.Parser.Tactic.simp |
Mathlib.AlgebraicTopology.SimplicialComplex.Basic | {
"line": 140,
"column": 6
} | {
"line": 140,
"column": 61
} | [
{
"pp": "case right\nι : Type u_1\nα : Type u_2\nβ : Type u_3\ninst✝ : DecidableEq β\nK : PreAbstractSimplicialComplex α\nf : α → β\ns' : Finset α\nhs' : s' ∈ K.faces\nt : Finset β\nhts : t ≤ Finset.image f s'\nht : t.Nonempty\n⊢ ∃ x ∈ K.faces, Finset.image f x = t",
"usedConstants": [
"Finset",
... | obtain ⟨t', ht', rfl⟩ := Finset.subset_image_iff.mp hts | _private.Lean.Elab.Tactic.RCases.0.Lean.Elab.Tactic.RCases.evalObtain | Lean.Parser.Tactic.obtain |
Mathlib.AlgebraicTopology.SimplexCategory.ToMkOne | {
"line": 112,
"column": 10
} | {
"line": 112,
"column": 68
} | [
{
"pp": "case pos\nn : ℕ\ni : Fin (n + 2)\nj : Fin (n + 1)\nh : j.castSucc < i\nk : Fin (⦋n + 1⦌.len + 1)\nhk : i < k\n⊢ (ConcreteCategory.hom (toMk₁ i)) (j.predAbove k) = (ConcreteCategory.hom (toMk₁ i.succ)) k",
"usedConstants": [
"_private.Mathlib.AlgebraicTopology.SimplexCategory.ToMkOne.0.Simplex... | grind [Fin.predAbove_of_castSucc_lt, toMk₁_of_le_castSucc] | Lean.Elab.Tactic.evalGrind | Lean.Parser.Tactic.grind |
Mathlib.AlgebraicTopology.SimplicialSet.AnodyneExtensions.Pairing | {
"line": 131,
"column": 2
} | {
"line": 135,
"column": 24
} | [
{
"pp": "X : SSet\nA : X.Subcomplex\nP : A.Pairing\nx : ↑P.I\ny : ↑P.II\n⊢ ↑x ≠ ↑y",
"usedConstants": [
"False",
"Set.mem_empty_iff_false._simp_1",
"congrArg",
"False.elim",
"Subtype.casesOn",
"Membership.mem",
"SSet.Subcomplex.N",
"Eq.mp",
"Set.Elem",
... | obtain ⟨x, hx⟩ := x
obtain ⟨y, hy⟩ := y
rintro rfl
have : x ∈ P.I ∩ P.II := ⟨hx, hy⟩
simp [P.inter] at this | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.AlgebraicTopology.SimplicialSet.AnodyneExtensions.Pairing | {
"line": 131,
"column": 2
} | {
"line": 135,
"column": 24
} | [
{
"pp": "X : SSet\nA : X.Subcomplex\nP : A.Pairing\nx : ↑P.I\ny : ↑P.II\n⊢ ↑x ≠ ↑y",
"usedConstants": [
"False",
"Set.mem_empty_iff_false._simp_1",
"congrArg",
"False.elim",
"Subtype.casesOn",
"Membership.mem",
"SSet.Subcomplex.N",
"Eq.mp",
"Set.Elem",
... | obtain ⟨x, hx⟩ := x
obtain ⟨y, hy⟩ := y
rintro rfl
have : x ∈ P.I ∩ P.II := ⟨hx, hy⟩
simp [P.inter] at this | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.AlgebraicTopology.SimplicialObject.ChainHomotopy | {
"line": 81,
"column": 2
} | {
"line": 81,
"column": 74
} | [
{
"pp": "C : Type u\ninst✝¹ : Category.{v, u} C\ninst✝ : Preadditive C\nX Y : SimplicialObject C\nf g : X ⟶ Y\nH : Homotopy f g\nn : ℕ\nα : Fin (n + 1) × Fin (n + 2) → (X _⦋n + 1⦌ ⟶ Y _⦋n + 1⦌) := fun x ↦ (-1) ^ (↑x.1 + ↑x.2) • X.δ x.2 ≫ H.h x.1\nβ : Fin (n + 3) × Fin (n + 2) → (X _⦋n + 1⦌ ⟶ Y _⦋n + 1⦌) := fun ... | let S : Finset (Fin (n + 1) × Fin (n + 2)) := { x | x.1.castSucc < x.2 } | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_tacticLet___1 | Lean.Parser.Tactic.tacticLet__ |
Mathlib.CategoryTheory.Presentable.Limits | {
"line": 114,
"column": 2
} | {
"line": 139,
"column": 67
} | [
{
"pp": "C : Type u\ninst✝⁴ : Category.{v, u} C\nK : Type u'\ninst✝³ : Category.{v', u'} K\nF : K ⥤ C ⥤ Type w'\nc : Cone F\nhc : (Y : C) → IsLimit (((evaluation C (Type w')).obj Y).mapCone c)\nκ : Cardinal.{w}\ninst✝² : Fact κ.IsRegular\nhK : HasCardinalLT (Arrow K) κ\nJ : Type w\ninst✝¹ : SmallCategory J\nins... | have := isFiltered_of_isCardinalFiltered J κ
let y₁ := Types.isLimitEquivSections (hc (X.obj j)) x₁
let y₂ := Types.isLimitEquivSections (hc (X.obj j)) x₂
have hy₁ : (Types.isLimitEquivSections (hc (X.obj j))).symm y₁ = x₁ := by simp [y₁]
have hy₂ : (Types.isLimitEquivSections (hc (X.obj j))).symm y₂ = x₂ := by... | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.CategoryTheory.Presentable.Limits | {
"line": 114,
"column": 2
} | {
"line": 139,
"column": 67
} | [
{
"pp": "C : Type u\ninst✝⁴ : Category.{v, u} C\nK : Type u'\ninst✝³ : Category.{v', u'} K\nF : K ⥤ C ⥤ Type w'\nc : Cone F\nhc : (Y : C) → IsLimit (((evaluation C (Type w')).obj Y).mapCone c)\nκ : Cardinal.{w}\ninst✝² : Fact κ.IsRegular\nhK : HasCardinalLT (Arrow K) κ\nJ : Type w\ninst✝¹ : SmallCategory J\nins... | have := isFiltered_of_isCardinalFiltered J κ
let y₁ := Types.isLimitEquivSections (hc (X.obj j)) x₁
let y₂ := Types.isLimitEquivSections (hc (X.obj j)) x₂
have hy₁ : (Types.isLimitEquivSections (hc (X.obj j))).symm y₁ = x₁ := by simp [y₁]
have hy₂ : (Types.isLimitEquivSections (hc (X.obj j))).symm y₂ = x₂ := by... | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.CategoryTheory.Presentable.StrongGenerator | {
"line": 169,
"column": 2
} | {
"line": 174,
"column": 15
} | [
{
"pp": "case refine_2\nC : Type u\ninst✝³ : Category.{v, u} C\nκ : Cardinal.{w}\ninst✝² : Fact κ.IsRegular\ninst✝¹ : HasColimitsOfSize.{w, w, v, u} C\ninst✝ : LocallySmall.{w, v, u} C\nx✝ : ∃ P, ∃ (_ : ObjectProperty.Small.{w, v, u} P), P.IsStrongGenerator ∧ P ≤ isCardinalPresentable C κ\nP : ObjectProperty C\... | · have := hS₁.isDense_colimitsCardinalClosure_ι hS₂
have : HasCardinalFilteredGenerator C κ :=
{ exists_generator := ⟨(P.colimitsCardinalClosure κ), inferInstance,
IsCardinalFilteredGenerator.of_isDense_ι _ _
(P.colimitsCardinalClosure_le_isCardinalPresentable hS₂)⟩ }
constructor | Lean.Elab.Tactic.evalTacticCDot | Lean.cdot |
Mathlib.AlgebraicTopology.SimplicialSet.Homology.Nondegenerate | {
"line": 214,
"column": 2
} | {
"line": 217,
"column": 85
} | [
{
"pp": "C : Type u\ninst✝² : Category.{v, u} C\ninst✝¹ : HasCoproducts C\ninst✝ : Preadditive C\nX Y : SSet\nf : X ⟶ Y\nR : C\nn : ℕ\nx : X _⦋n⦌\n⊢ X.ιNormalizedChainComplex x ≫ (normalizedChainComplexMap f R).f n =\n Y.ιNormalizedChainComplex ((ConcreteCategory.hom (f.app (Opposite.op ⦋n⦌))) x)",
"used... | simpa only [comp_f, eval_map, ιNormalizedChainComplex,
ιChainComplex_toNormalizedChainComplex_f_assoc, ι_chainComplexMap_f_assoc] using
X.ιChainComplex x ≫=
(eval _ _ n).congr_map (toNormalizedChainComplex_normalizedChainComplexMap f R) | Lean.Elab.Tactic.Simpa.evalSimpa | Lean.Parser.Tactic.simpa |
Mathlib.AlgebraicTopology.SimplicialSet.Homology.Nondegenerate | {
"line": 214,
"column": 2
} | {
"line": 217,
"column": 85
} | [
{
"pp": "C : Type u\ninst✝² : Category.{v, u} C\ninst✝¹ : HasCoproducts C\ninst✝ : Preadditive C\nX Y : SSet\nf : X ⟶ Y\nR : C\nn : ℕ\nx : X _⦋n⦌\n⊢ X.ιNormalizedChainComplex x ≫ (normalizedChainComplexMap f R).f n =\n Y.ιNormalizedChainComplex ((ConcreteCategory.hom (f.app (Opposite.op ⦋n⦌))) x)",
"used... | simpa only [comp_f, eval_map, ιNormalizedChainComplex,
ιChainComplex_toNormalizedChainComplex_f_assoc, ι_chainComplexMap_f_assoc] using
X.ιChainComplex x ≫=
(eval _ _ n).congr_map (toNormalizedChainComplex_normalizedChainComplexMap f R) | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.AlgebraicTopology.SimplicialSet.Homology.Nondegenerate | {
"line": 214,
"column": 2
} | {
"line": 217,
"column": 85
} | [
{
"pp": "C : Type u\ninst✝² : Category.{v, u} C\ninst✝¹ : HasCoproducts C\ninst✝ : Preadditive C\nX Y : SSet\nf : X ⟶ Y\nR : C\nn : ℕ\nx : X _⦋n⦌\n⊢ X.ιNormalizedChainComplex x ≫ (normalizedChainComplexMap f R).f n =\n Y.ιNormalizedChainComplex ((ConcreteCategory.hom (f.app (Opposite.op ⦋n⦌))) x)",
"used... | simpa only [comp_f, eval_map, ιNormalizedChainComplex,
ιChainComplex_toNormalizedChainComplex_f_assoc, ι_chainComplexMap_f_assoc] using
X.ιChainComplex x ≫=
(eval _ _ n).congr_map (toNormalizedChainComplex_normalizedChainComplexMap f R) | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.AlgebraicTopology.SimplicialSet.Skeleton | {
"line": 323,
"column": 4
} | {
"line": 324,
"column": 29
} | [
{
"pp": "X Y : SSet\ni : X ⟶ Y\nd : ℕ\nx✝ : SimplexCategoryᵒᵖ\nn : ℕ\n⊢ IsLimit (evaluation SimplexCategoryᵒᵖ (Type u) _⦋n⦌.mapCone (PullbackCone.mk (t i d) (l i d) ⋯))",
"usedConstants": [
"SSet.Subcomplex.toSSet",
"CategoryTheory.Functor",
"SSet.relativeCellComplexOfMono.b",
"Oppos... | refine (isLimitMapConePullbackConeEquiv _ _).2
(IsPullback.isLimit ?_) | Lean.Elab.Tactic.evalRefine | Lean.Parser.Tactic.refine |
Mathlib.CategoryTheory.Limits.Shapes.Pullback.PullbackObjObj | {
"line": 175,
"column": 4
} | {
"line": 175,
"column": 53
} | [
{
"pp": "C₁ : Type u₁\nC₂ : Type u₂\nC₃ : Type u₃\ninst✝⁴ : Category.{v₁, u₁} C₁\ninst✝³ : Category.{v₂, u₂} C₂\ninst✝² : Category.{v₃, u₃} C₃\nF : C₁ ⥤ C₂ ⥤ C₃\nG : C₁ᵒᵖ ⥤ C₃ ⥤ C₂\nX₁ Y₁ : C₁\nf₁ : X₁ ⟶ Y₁\nX₂ Y₂ : C₂\nf₂ : X₂ ⟶ Y₂\nsq : F.PushoutObjObj f₁ f₂\ninst✝¹ : PreservesColimitsOfShape (Discrete PEmpty... | apply +allowSynthFailures IsPushout.of_vert_isIso | Mathlib.Tactic._aux_Mathlib_Tactic_ApplyWith___elabRules_Mathlib_Tactic_applyWith_1 | Mathlib.Tactic.applyWith |
Mathlib.CategoryTheory.Limits.Shapes.Pullback.PullbackObjObj | {
"line": 588,
"column": 10
} | {
"line": 588,
"column": 71
} | [
{
"pp": "C₁ : Type u₁\nC₂ : Type u₂\nC₃ : Type u₃\ninst✝⁴ : Category.{v₁, u₁} C₁\ninst✝³ : Category.{v₂, u₂} C₂\ninst✝² : Category.{v₃, u₃} C₃\nF : C₁ ⥤ C₂ ⥤ C₃\nG : C₁ᵒᵖ ⥤ C₃ ⥤ C₂\nadj₂ : F ⊣₂ G\nX₁ : Arrow C₁\ninst✝¹ : HasPullbacks C₂\ninst✝ : HasPushouts C₃\nX₂ : Arrow C₂\n⊢ adj₂.homEquiv (pushout.inr ((F.ma... | simp [← homEquiv_naturality_one, ← homEquiv_naturality_three] | Lean.Elab.Tactic.evalSimp | Lean.Parser.Tactic.simp |
Mathlib.CategoryTheory.Limits.Shapes.Pullback.PullbackObjObj | {
"line": 588,
"column": 10
} | {
"line": 588,
"column": 71
} | [
{
"pp": "C₁ : Type u₁\nC₂ : Type u₂\nC₃ : Type u₃\ninst✝⁴ : Category.{v₁, u₁} C₁\ninst✝³ : Category.{v₂, u₂} C₂\ninst✝² : Category.{v₃, u₃} C₃\nF : C₁ ⥤ C₂ ⥤ C₃\nG : C₁ᵒᵖ ⥤ C₃ ⥤ C₂\nadj₂ : F ⊣₂ G\nX₁ : Arrow C₁\ninst✝¹ : HasPullbacks C₂\ninst✝ : HasPushouts C₃\nX₂ : Arrow C₂\n⊢ adj₂.homEquiv (pushout.inr ((F.ma... | simp [← homEquiv_naturality_one, ← homEquiv_naturality_three] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.CategoryTheory.Limits.Shapes.Pullback.PullbackObjObj | {
"line": 588,
"column": 10
} | {
"line": 588,
"column": 71
} | [
{
"pp": "C₁ : Type u₁\nC₂ : Type u₂\nC₃ : Type u₃\ninst✝⁴ : Category.{v₁, u₁} C₁\ninst✝³ : Category.{v₂, u₂} C₂\ninst✝² : Category.{v₃, u₃} C₃\nF : C₁ ⥤ C₂ ⥤ C₃\nG : C₁ᵒᵖ ⥤ C₃ ⥤ C₂\nadj₂ : F ⊣₂ G\nX₁ : Arrow C₁\ninst✝¹ : HasPullbacks C₂\ninst✝ : HasPushouts C₃\nX₂ : Arrow C₂\n⊢ adj₂.homEquiv (pushout.inr ((F.ma... | simp [← homEquiv_naturality_one, ← homEquiv_naturality_three] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.CategoryTheory.Limits.Shapes.Pullback.PullbackObjObj | {
"line": 592,
"column": 27
} | {
"line": 595,
"column": 94
} | [
{
"pp": "C₁ : Type u₁\nC₂ : Type u₂\nC₃ : Type u₃\ninst✝⁴ : Category.{v₁, u₁} C₁\ninst✝³ : Category.{v₂, u₂} C₂\ninst✝² : Category.{v₃, u₃} C₃\nF : C₁ ⥤ C₂ ⥤ C₃\nG : C₁ᵒᵖ ⥤ C₃ ⥤ C₂\nadj₂ : F ⊣₂ G\nX₁ : Arrow C₁\ninst✝¹ : HasPullbacks C₂\ninst✝ : HasPushouts C₃\nx✝² x✝¹ : Arrow C₂\nx✝ : x✝² ⟶ x✝¹\n⊢ (𝟭 (Arrow C... | by
ext
· simp [← homEquiv_naturality_two, ← homEquiv_naturality_three]
· apply pullback.hom_ext <;> simp [← homEquiv_naturality_two, ← homEquiv_naturality_three] | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.CategoryTheory.Limits.Shapes.Pullback.PullbackObjObj | {
"line": 629,
"column": 6
} | {
"line": 629,
"column": 67
} | [
{
"pp": "case w.h.h₁\nC₁ : Type u₁\nC₂ : Type u₂\nC₃ : Type u₃\ninst✝⁴ : Category.{v₁, u₁} C₁\ninst✝³ : Category.{v₂, u₂} C₂\ninst✝² : Category.{v₃, u₃} C₃\nF : C₁ ⥤ C₂ ⥤ C₃\nG : C₁ᵒᵖ ⥤ C₃ ⥤ C₂\nadj₂ : F ⊣₂ G\ninst✝¹ : HasPullbacks C₂\ninst✝ : HasPushouts C₃\nX₁✝ Y₁✝ : Arrow C₁\nx✝¹ : X₁✝ ⟶ Y₁✝\nx✝ : Arrow C₂\n... | simp [← homEquiv_naturality_one, ← homEquiv_naturality_three] | Lean.Elab.Tactic.evalSimp | Lean.Parser.Tactic.simp |
Mathlib.CategoryTheory.Limits.Shapes.Pullback.PullbackObjObj | {
"line": 629,
"column": 6
} | {
"line": 629,
"column": 67
} | [
{
"pp": "case w.h.h₁\nC₁ : Type u₁\nC₂ : Type u₂\nC₃ : Type u₃\ninst✝⁴ : Category.{v₁, u₁} C₁\ninst✝³ : Category.{v₂, u₂} C₂\ninst✝² : Category.{v₃, u₃} C₃\nF : C₁ ⥤ C₂ ⥤ C₃\nG : C₁ᵒᵖ ⥤ C₃ ⥤ C₂\nadj₂ : F ⊣₂ G\ninst✝¹ : HasPullbacks C₂\ninst✝ : HasPushouts C₃\nX₁✝ Y₁✝ : Arrow C₁\nx✝¹ : X₁✝ ⟶ Y₁✝\nx✝ : Arrow C₂\n... | simp [← homEquiv_naturality_one, ← homEquiv_naturality_three] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.CategoryTheory.Limits.Shapes.Pullback.PullbackObjObj | {
"line": 629,
"column": 6
} | {
"line": 629,
"column": 67
} | [
{
"pp": "case w.h.h₁\nC₁ : Type u₁\nC₂ : Type u₂\nC₃ : Type u₃\ninst✝⁴ : Category.{v₁, u₁} C₁\ninst✝³ : Category.{v₂, u₂} C₂\ninst✝² : Category.{v₃, u₃} C₃\nF : C₁ ⥤ C₂ ⥤ C₃\nG : C₁ᵒᵖ ⥤ C₃ ⥤ C₂\nadj₂ : F ⊣₂ G\ninst✝¹ : HasPullbacks C₂\ninst✝ : HasPushouts C₃\nX₁✝ Y₁✝ : Arrow C₁\nx✝¹ : X₁✝ ⟶ Y₁✝\nx✝ : Arrow C₂\n... | simp [← homEquiv_naturality_one, ← homEquiv_naturality_three] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.CategoryTheory.Limits.Shapes.Pullback.PullbackObjObj | {
"line": 630,
"column": 33
} | {
"line": 630,
"column": 94
} | [
{
"pp": "case w.h.h₂.h₀\nC₁ : Type u₁\nC₂ : Type u₂\nC₃ : Type u₃\ninst✝⁴ : Category.{v₁, u₁} C₁\ninst✝³ : Category.{v₂, u₂} C₂\ninst✝² : Category.{v₃, u₃} C₃\nF : C₁ ⥤ C₂ ⥤ C₃\nG : C₁ᵒᵖ ⥤ C₃ ⥤ C₂\nadj₂ : F ⊣₂ G\ninst✝¹ : HasPullbacks C₂\ninst✝ : HasPushouts C₃\nX₁✝ Y₁✝ : Arrow C₁\nx✝¹ : X₁✝ ⟶ Y₁✝\nx✝ : Arrow C... | simp [← homEquiv_naturality_one, ← homEquiv_naturality_three] | Lean.Elab.Tactic.evalSimp | Lean.Parser.Tactic.simp |
Mathlib.CategoryTheory.Limits.Shapes.Pullback.PullbackObjObj | {
"line": 630,
"column": 33
} | {
"line": 630,
"column": 94
} | [
{
"pp": "case w.h.h₂.h₁\nC₁ : Type u₁\nC₂ : Type u₂\nC₃ : Type u₃\ninst✝⁴ : Category.{v₁, u₁} C₁\ninst✝³ : Category.{v₂, u₂} C₂\ninst✝² : Category.{v₃, u₃} C₃\nF : C₁ ⥤ C₂ ⥤ C₃\nG : C₁ᵒᵖ ⥤ C₃ ⥤ C₂\nadj₂ : F ⊣₂ G\ninst✝¹ : HasPullbacks C₂\ninst✝ : HasPushouts C₃\nX₁✝ Y₁✝ : Arrow C₁\nx✝¹ : X₁✝ ⟶ Y₁✝\nx✝ : Arrow C... | simp [← homEquiv_naturality_one, ← homEquiv_naturality_three] | Lean.Elab.Tactic.evalSimp | Lean.Parser.Tactic.simp |
Mathlib.AlgebraicTopology.SimplicialSet.NerveAdjunction | {
"line": 161,
"column": 13
} | {
"line": 161,
"column": 42
} | [
{
"pp": "case refine_1.succ.zero.«1».h.toFun.h\nX Y : Truncated 2\nf₀ : X.obj (op { obj := ⦋0⦌, property := _proof_11 }) → Y.obj (op { obj := ⦋0⦌, property := _proof_11 })\nf₁ : X.obj (op { obj := ⦋1⦌, property := _proof_12 }) → Y.obj (op { obj := ⦋1⦌, property := _proof_12 })\nhδ₁ :\n ∀ (x : X.obj (op { obj :... | apply hδ'₁ f₀ f₁ hδ₁ hδ₀ H hY | Lean.Elab.Tactic.evalApply | Lean.Parser.Tactic.apply |
Mathlib.Topology.Algebra.Module.Cardinality | {
"line": 56,
"column": 2
} | {
"line": 57,
"column": 66
} | [
{
"pp": "𝕜 : Type u\nE : Type v\ninst✝⁴ : NontriviallyNormedField 𝕜\ninst✝³ : CompleteSpace 𝕜\ninst✝² : AddCommGroup E\ninst✝¹ : Module 𝕜 E\ninst✝ : Nontrivial E\n⊢ 𝔠 ≤ #E",
"usedConstants": [
"Eq.mpr",
"Cardinal",
"congrArg",
"Cardinal.lift",
"Cardinal.continuum_le_lift._... | have A : lift.{v} (𝔠 : Cardinal.{u}) ≤ lift.{v} (#𝕜) := by
simpa using continuum_le_cardinal_of_nontriviallyNormedField 𝕜 | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_tacticHave___1 | Lean.Parser.Tactic.tacticHave__ |
Mathlib.Analysis.Calculus.IteratedDeriv.ConvergenceOnBall | {
"line": 39,
"column": 2
} | {
"line": 39,
"column": 53
} | [
{
"pp": "𝕜 : Type u_1\ninst✝ : RCLike 𝕜\nf : 𝕜 → 𝕜\nx : 𝕜\nr : ENNReal\nhr_pos : 0 < r\nh : AnalyticOnNhd 𝕜 f (Metric.eball x r)\np : FormalMultilinearSeries 𝕜 𝕜 𝕜 := FormalMultilinearSeries.ofScalars 𝕜 fun n ↦ iteratedDeriv n f x / ↑n.factorial\nhr : r ≤ p.radius\ng : 𝕜 → 𝕜 := fun t ↦ p.sum (t - x)... | apply h.eqOn_of_preconnected_of_eventuallyEq at hg' | Mathlib.Tactic._aux_Mathlib_Tactic_ApplyAt___elabRules_Mathlib_Tactic_tacticApply_At__1 | Mathlib.Tactic.tacticApply_At_ |
Mathlib.Analysis.SpecialFunctions.OrdinaryHypergeometric | {
"line": 158,
"column": 2
} | {
"line": 158,
"column": 90
} | [
{
"pp": "𝕂 : Type u_1\n𝔸 : Type u_2\ninst✝² : RCLike 𝕂\ninst✝¹ : NormedDivisionRing 𝔸\ninst✝ : NormedAlgebra 𝕂 𝔸\na b : 𝕂\nk n : ℕ\n⊢ ordinaryHypergeometricSeries 𝔸 a b (-↑k) (n + (1 + k)) = 0",
"usedConstants": [
"NormedCommRing.toNormedRing",
"Eq.mpr",
"NegZeroClass.toNeg",
... | exact ordinaryHypergeometricSeries_eq_zero_of_neg_nat a b (-(k : 𝕂)) (by aesop) (by lia) | Lean.Elab.Tactic.evalExact | Lean.Parser.Tactic.exact |
Mathlib.Analysis.Analytic.Order | {
"line": 232,
"column": 2
} | {
"line": 232,
"column": 55
} | [
{
"pp": "𝕜 : Type u_1\nE : Type u_2\ninst✝² : NontriviallyNormedField 𝕜\ninst✝¹ : NormedAddCommGroup E\ninst✝ : NormedSpace 𝕜 E\ng : 𝕜 → E\nz₀ : 𝕜\nf : 𝕜 → 𝕜\nhf : analyticOrderAt f z₀ = ⊤\n⊢ analyticOrderAt (f • g) z₀ = ⊤",
"usedConstants": [
"Eq.mpr",
"NormedCommRing.toSeminormedCommRin... | rw [analyticOrderAt_eq_top, eventually_nhds_iff] at * | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.Analysis.Analytic.Order | {
"line": 238,
"column": 2
} | {
"line": 238,
"column": 55
} | [
{
"pp": "𝕜 : Type u_1\nE : Type u_2\ninst✝² : NontriviallyNormedField 𝕜\ninst✝¹ : NormedAddCommGroup E\ninst✝ : NormedSpace 𝕜 E\ng : 𝕜 → E\nz₀ : 𝕜\nf : 𝕜 → 𝕜\nhg : analyticOrderAt g z₀ = ⊤\n⊢ analyticOrderAt (f • g) z₀ = ⊤",
"usedConstants": [
"Eq.mpr",
"NormedCommRing.toSeminormedCommRin... | rw [analyticOrderAt_eq_top, eventually_nhds_iff] at * | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.Analysis.Meromorphic.Basic | {
"line": 125,
"column": 2
} | {
"line": 125,
"column": 26
} | [
{
"pp": "𝕜 : Type u_1\n𝕜' : Type u_2\ninst✝² : NontriviallyNormedField 𝕜\ninst✝¹ : NontriviallyNormedField 𝕜'\ninst✝ : NormedAlgebra 𝕜 𝕜'\nι : Type u_4\ns : Finset ι\nF : ι → 𝕜 → 𝕜'\nx : 𝕜\nh : ∀ σ ∈ s, MeromorphicAt (F σ) x\n⊢ MeromorphicAt (fun z ↦ ∏ n ∈ s, F n z) x",
"usedConstants": [
"Eq... | convert! prod h (s := s) | Mathlib.Tactic._aux_Mathlib_Tactic_Convert___macroRules_Mathlib_Tactic_convert!_1 | Mathlib.Tactic.convert! |
Mathlib.Analysis.Meromorphic.Basic | {
"line": 161,
"column": 2
} | {
"line": 161,
"column": 44
} | [
{
"pp": "𝕜 : Type u_1\n𝕜' : Type u_2\ninst✝² : NontriviallyNormedField 𝕜\ninst✝¹ : NontriviallyNormedField 𝕜'\ninst✝ : NormedAlgebra 𝕜 𝕜'\nι : Type u_4\nF : ι → 𝕜 → 𝕜'\nx : 𝕜\nhF : ∀ (i : ι), MeromorphicAt (F i) x\n⊢ MeromorphicAt (∑ᶠ (i : ι), F i) x",
"usedConstants": [
"NormedCommRing.toSem... | by_cases h₂f : Function.HasFiniteSupport F | «_aux_Init_ByCases___macroRules_tacticBy_cases_:__2» | «tacticBy_cases_:_» |
Mathlib.Analysis.Meromorphic.Basic | {
"line": 317,
"column": 12
} | {
"line": 317,
"column": 63
} | [
{
"pp": "case zero\n𝕜 : Type u_1\n𝕜' : Type u_2\ninst✝² : NontriviallyNormedField 𝕜\ninst✝¹ : NontriviallyNormedField 𝕜'\ninst✝ : NormedAlgebra 𝕜 𝕜'\nx : 𝕜\nf : 𝕜 → 𝕜'\nhf : MeromorphicAt f x\n⊢ MeromorphicAt (f ^ 0) x",
"usedConstants": [
"NormedCommRing.toNormedRing",
"Eq.mpr",
... | simpa only [pow_zero] using MeromorphicAt.const 1 x | Lean.Elab.Tactic.Simpa.evalSimpa | Lean.Parser.Tactic.simpa |
Mathlib.Analysis.Meromorphic.Basic | {
"line": 317,
"column": 12
} | {
"line": 317,
"column": 63
} | [
{
"pp": "case zero\n𝕜 : Type u_1\n𝕜' : Type u_2\ninst✝² : NontriviallyNormedField 𝕜\ninst✝¹ : NontriviallyNormedField 𝕜'\ninst✝ : NormedAlgebra 𝕜 𝕜'\nx : 𝕜\nf : 𝕜 → 𝕜'\nhf : MeromorphicAt f x\n⊢ MeromorphicAt (f ^ 0) x",
"usedConstants": [
"NormedCommRing.toNormedRing",
"Eq.mpr",
... | simpa only [pow_zero] using MeromorphicAt.const 1 x | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Analysis.Meromorphic.Basic | {
"line": 317,
"column": 12
} | {
"line": 317,
"column": 63
} | [
{
"pp": "case zero\n𝕜 : Type u_1\n𝕜' : Type u_2\ninst✝² : NontriviallyNormedField 𝕜\ninst✝¹ : NontriviallyNormedField 𝕜'\ninst✝ : NormedAlgebra 𝕜 𝕜'\nx : 𝕜\nf : 𝕜 → 𝕜'\nhf : MeromorphicAt f x\n⊢ MeromorphicAt (f ^ 0) x",
"usedConstants": [
"NormedCommRing.toNormedRing",
"Eq.mpr",
... | simpa only [pow_zero] using MeromorphicAt.const 1 x | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Analysis.Meromorphic.Basic | {
"line": 333,
"column": 2
} | {
"line": 333,
"column": 61
} | [
{
"pp": "case h\n𝕜 : Type u_1\ninst✝² : NontriviallyNormedField 𝕜\nE : Type u_3\ninst✝¹ : NormedAddCommGroup E\ninst✝ : NormedSpace 𝕜 E\nx : 𝕜\nf : 𝕜 → E\nn : ℕ\nh : AnalyticAt 𝕜 (fun z ↦ (z - x) ^ n • f z) x\nthis : ∀ᶠ (y : 𝕜) in 𝓝[≠] x, ContinuousAt (fun z ↦ (z - x) ^ n • f z) y\ny : 𝕜\nhy : Continuo... | simp only [Set.mem_compl_iff, Set.mem_singleton_iff] at h'y | Lean.Elab.Tactic.evalSimp | Lean.Parser.Tactic.simp |
Mathlib.Analysis.Calculus.InverseFunctionTheorem.ApproximatesLinearOn | {
"line": 315,
"column": 2
} | {
"line": 315,
"column": 43
} | [
{
"pp": "case inl\n𝕜 : Type u_1\ninst✝⁴ : NontriviallyNormedField 𝕜\nE : Type u_2\ninst✝³ : NormedAddCommGroup E\ninst✝² : NormedSpace 𝕜 E\nF : Type u_3\ninst✝¹ : NormedAddCommGroup F\ninst✝ : NormedSpace 𝕜 F\nf : E → F\nf' : E ≃L[𝕜] F\ns : Set E\nc : ℝ≥0\nhf : ApproximatesLinearOn f (↑f') s c\nhE : Subsin... | · exact AntilipschitzWith.of_subsingleton | Lean.Elab.Tactic.evalTacticCDot | Lean.cdot |
Mathlib.Analysis.Calculus.FDeriv.Extend | {
"line": 136,
"column": 8
} | {
"line": 136,
"column": 47
} | [
{
"pp": "E : Type u_1\ninst✝¹ : NormedAddCommGroup E\ninst✝ : NormedSpace ℝ E\ns : Set ℝ\ne : E\na : ℝ\nf : ℝ → E\nf_diff : DifferentiableOn ℝ f s\nf_lim : ContinuousWithinAt f s a\nhs : s ∈ 𝓝[>] a\nf_lim' : Tendsto (fun x ↦ deriv f x) (𝓝[>] a) (𝓝 e)\nb : ℝ\nab : a < b\nsab : Ioc a b ⊆ s\nt : Set ℝ := Ioo a ... | hasDerivWithinAt_iff_hasFDerivWithinAt, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Analysis.Calculus.FDeriv.Extend | {
"line": 171,
"column": 8
} | {
"line": 171,
"column": 47
} | [
{
"pp": "E : Type u_1\ninst✝¹ : NormedAddCommGroup E\ninst✝ : NormedSpace ℝ E\ns : Set ℝ\ne : E\na : ℝ\nf : ℝ → E\nf_diff : DifferentiableOn ℝ f s\nf_lim : ContinuousWithinAt f s a\nhs : s ∈ 𝓝[<] a\nf_lim' : Tendsto (fun x ↦ deriv f x) (𝓝[<] a) (𝓝 e)\nb : ℝ\nba : b ∈ Iio a\nsab : Ico b a ⊆ s\nt : Set ℝ := Io... | hasDerivWithinAt_iff_hasFDerivWithinAt, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Analysis.Meromorphic.Basic | {
"line": 633,
"column": 58
} | {
"line": 639,
"column": 11
} | [
{
"pp": "𝕜 : Type u_1\ninst✝³ : NontriviallyNormedField 𝕜\nE : Type u_3\ninst✝² : NormedAddCommGroup E\ninst✝¹ : NormedSpace 𝕜 E\nU : Set 𝕜\ninst✝ : CompleteSpace E\nf : 𝕜 → E\nh : MeromorphicOn f U\n⊢ ∀ᶠ (y : 𝕜) in codiscreteWithin U, AnalyticAt 𝕜 f y",
"usedConstants": [
"Filter.instMembershi... | by
rw [eventually_iff, mem_codiscreteWithin]
intro x hx
rw [disjoint_principal_right]
apply Filter.mem_of_superset ((h x hx).eventually_analyticAt)
intro x hx
simp [hx] | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.RingTheory.Binomial | {
"line": 154,
"column": 63
} | {
"line": 159,
"column": 52
} | [
{
"pp": "R : Type u_2\ninst✝³ : NonAssocSemiring R\ninst✝² : Pow R ℕ\ninst✝¹ : NatPowAssoc R\ninst✝ : BinomialRing R\nk : ℕ\n⊢ multichoose 1 k = 1",
"usedConstants": [
"Eq.mpr",
"NonAssocSemiring.toAddCommMonoidWithOne",
"Nat.recAux",
"congrArg",
"AddMonoid.toAddZeroClass",
... | by
induction k with
| zero => exact multichoose_zero_right 1
| succ n ih =>
rw [show (1 : R) = 0 + 1 by exact (@zero_add R _ 1).symm, multichoose_succ_succ,
multichoose_zero_succ, zero_add, zero_add, ih] | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.RingTheory.Binomial | {
"line": 316,
"column": 13
} | {
"line": 318,
"column": 15
} | [
{
"pp": "n k : ℕ\n⊢ (ascPochhammer ℕ (n + (k + 1) + 1)).smeval (-↑n) = 0",
"usedConstants": [
"Eq.mpr",
"Int.instAddCommMonoid",
"Algebra.to_smulCommClass",
"HMul.hMul",
"IsScalarTower.right",
"MulZeroClass.toMul",
"congrArg",
"add_assoc",
"MulZeroClass.... | by
rw [ascPochhammer_succ_right, smeval_mul, ← add_assoc, smeval_ascPochhammer_neg_add n k,
zero_mul] | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Analysis.SpecialFunctions.Pow.Deriv | {
"line": 292,
"column": 6
} | {
"line": 292,
"column": 53
} | [
{
"pp": "case h.e'_9\nx : ℝ\nhx✝ : x ≠ 0\nr : ℂ\nhr : r + 1 ≠ 0\nhx : x < 0\nthis : ∀ᶠ (y : ℝ) in 𝓝 x, ↑y ^ (r + 1) / (r + 1) = (-↑y) ^ (r + 1) * cexp (↑π * I * (r + 1)) / (r + 1)\n⊢ (r + 1) * ↑(-x) ^ r = (r + 1 - 1 + 1) * ↑(-x) ^ (r + 1 - 1 + 1 - 1) * ?inr.convert_2",
"usedConstants": [
"Eq.mpr",
... | rw [add_sub_cancel_right, add_sub_cancel_right] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.RingTheory.Binomial | {
"line": 391,
"column": 64
} | {
"line": 397,
"column": 49
} | [
{
"pp": "R : Type u_1\ninst✝³ : NonAssocRing R\ninst✝² : Pow R ℕ\ninst✝¹ : BinomialRing R\ninst✝ : NatPowAssoc R\nr : R\nn : ℕ\n⊢ (descPochhammer ℤ n).smeval r = n.factorial • choose r n",
"usedConstants": [
"Int.cast",
"Eq.mpr",
"Polynomial.C",
"NonAssocSemiring.toAddCommMonoidWithO... | by
rw [choose, factorial_nsmul_multichoose_eq_ascPochhammer, descPochhammer_eq_ascPochhammer,
smeval_comp, add_comm_sub, smeval_add, smeval_X, npow_one]
have h : smeval (1 - n : Polynomial ℤ) r = 1 - n := by
rw [← C_eq_natCast, ← C_1, ← C_sub, smeval_C]
simp only [npow_zero, zsmul_one, Int.cast_sub, Int... | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Analysis.Analytic.Polynomial | {
"line": 35,
"column": 2
} | {
"line": 36,
"column": 55
} | [
{
"pp": "case refine_3\n𝕜 : Type u_1\nE : Type u_2\nA : Type u_3\nB : Type u_4\ninst✝⁶ : NontriviallyNormedField 𝕜\ninst✝⁵ : NormedAddCommGroup E\ninst✝⁴ : NormedSpace 𝕜 E\ninst✝³ : CommSemiring A\nz : E\ns : Set E\ninst✝² : NormedRing B\ninst✝¹ : NormedAlgebra 𝕜 B\ninst✝ : Algebra A B\nf : E → B\nhf : Anal... | · convert! hp.mul hf
simp_rw [pow_succ, aeval_mul, ← mul_assoc, aeval_X] | Lean.Elab.Tactic.evalTacticCDot | Lean.cdot |
Mathlib.Analysis.AperiodicOrder.Delone.Basic | {
"line": 174,
"column": 4
} | {
"line": 175,
"column": 34
} | [
{
"pp": "case carrier.h\nX : Type u_1\nY : Type u_2\ninst✝² : MetricSpace X\ninst✝¹ : MetricSpace Y\nZ : Type u_3\ninst✝ : MetricSpace Z\nD : DeloneSet X\nf : X ≃ Y\ng : Y ≃ Z\nK₁f K₂f K₁g K₂g : ℝ≥0\nhf₁_pos : 0 < K₁f\nhf₂_pos : 0 < K₂f\nhg₁_pos : 0 < K₁g\nhg₂_pos : 0 < K₂g\nhf_anti : AntilipschitzWith K₁f ⇑f\n... | simp only [mapBilipschitz_carrier, Equiv.trans_apply, Set.mem_image]
exact exists_exists_and_eq_and | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Analysis.AperiodicOrder.Delone.Basic | {
"line": 174,
"column": 4
} | {
"line": 175,
"column": 34
} | [
{
"pp": "case carrier.h\nX : Type u_1\nY : Type u_2\ninst✝² : MetricSpace X\ninst✝¹ : MetricSpace Y\nZ : Type u_3\ninst✝ : MetricSpace Z\nD : DeloneSet X\nf : X ≃ Y\ng : Y ≃ Z\nK₁f K₂f K₁g K₂g : ℝ≥0\nhf₁_pos : 0 < K₁f\nhf₂_pos : 0 < K₂f\nhg₁_pos : 0 < K₁g\nhg₂_pos : 0 < K₂g\nhf_anti : AntilipschitzWith K₁f ⇑f\n... | simp only [mapBilipschitz_carrier, Equiv.trans_apply, Set.mem_image]
exact exists_exists_and_eq_and | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Analysis.Analytic.Binomial | {
"line": 88,
"column": 60
} | {
"line": 88,
"column": 79
} | [
{
"pp": "𝕂 : Type v\ninst✝² : RCLike 𝕂\n𝔸 : Type u\ninst✝¹ : NormedDivisionRing 𝔸\ninst✝ : NormedAlgebra 𝕂 𝔸\na : 𝕂\nha : ∀ (k : ℕ), ↑k ≠ a\n⊢ ∀ (kn : ℕ), ↑kn ≠ - -a ∧ ↑kn ≠ -1 ∧ ↑kn ≠ -1",
"usedConstants": [
"_private.Mathlib.Analysis.Analytic.Binomial.0.binomialSeries_radius_eq_one._proof_1_2... | by norm_cast; grind | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Analysis.Analytic.IteratedFDeriv | {
"line": 187,
"column": 2
} | {
"line": 196,
"column": 28
} | [
{
"pp": "𝕜 : Type u_1\ninst✝⁴ : NontriviallyNormedField 𝕜\nE : Type u_2\ninst✝³ : NormedAddCommGroup E\ninst✝² : NormedSpace 𝕜 E\nF : Type u_3\ninst✝¹ : NormedAddCommGroup F\ninst✝ : NormedSpace 𝕜 F\nf : E → F\np : FormalMultilinearSeries 𝕜 E F\ns : Set E\nx : E\nr : ℝ≥0∞\nh : HasFPowerSeriesWithinOnBall f... | have : iteratedFDerivWithin 𝕜 n f s x
= iteratedFDerivWithin 𝕜 n f (s ∩ Metric.eball x r) x :=
(iteratedFDerivWithin_inter_open Metric.isOpen_eball (Metric.mem_eball_self h.r_pos)).symm
rw [this]
apply HasFPowerSeriesWithinOnBall.iteratedFDerivWithin_eq_sum_of_subset
· exact h.mono inter_subset_left
... | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Analysis.Analytic.IteratedFDeriv | {
"line": 187,
"column": 2
} | {
"line": 196,
"column": 28
} | [
{
"pp": "𝕜 : Type u_1\ninst✝⁴ : NontriviallyNormedField 𝕜\nE : Type u_2\ninst✝³ : NormedAddCommGroup E\ninst✝² : NormedSpace 𝕜 E\nF : Type u_3\ninst✝¹ : NormedAddCommGroup F\ninst✝ : NormedSpace 𝕜 F\nf : E → F\np : FormalMultilinearSeries 𝕜 E F\ns : Set E\nx : E\nr : ℝ≥0∞\nh : HasFPowerSeriesWithinOnBall f... | have : iteratedFDerivWithin 𝕜 n f s x
= iteratedFDerivWithin 𝕜 n f (s ∩ Metric.eball x r) x :=
(iteratedFDerivWithin_inter_open Metric.isOpen_eball (Metric.mem_eball_self h.r_pos)).symm
rw [this]
apply HasFPowerSeriesWithinOnBall.iteratedFDerivWithin_eq_sum_of_subset
· exact h.mono inter_subset_left
... | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Analysis.Asymptotics.LinearGrowth | {
"line": 299,
"column": 71
} | {
"line": 302,
"column": 32
} | [
{
"pp": "α : Type u_1\nu : α → ℕ → EReal\ns : Set α\nhs : s.Finite\n⊢ linearGrowthInf (⨅ x ∈ s, u x) = ⨅ x ∈ s, linearGrowthInf (u x)",
"usedConstants": [
"instAddCommMonoidWithOneEReal",
"EReal.instDivInvMonoid",
"iInf",
"CompleteLattice.toLattice",
"Iff.of_eq",
"congrAr... | by
have := map_finset_inf linearGrowthInfTopHom hs.toFinset u
simpa only [linearGrowthInfTopHom, InfTopHom.coe_mk, InfHom.coe_mk, Finset.inf_eq_iInf,
hs.mem_toFinset, comp_apply] | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Analysis.Asymptotics.LinearGrowth | {
"line": 306,
"column": 6
} | {
"line": 306,
"column": 18
} | [
{
"pp": "ι : Type u_1\ninst✝ : Finite ι\nu : ι → ℕ → EReal\n⊢ linearGrowthInf (⨅ i, u i) = ⨅ i, linearGrowthInf (u i)",
"usedConstants": [
"instAddCommMonoidWithOneEReal",
"Eq.mpr",
"EReal.instDivInvMonoid",
"instInfSetEReal",
"iInf",
"congrArg",
"CompletelyDistribL... | ← iInf_univ, | Lean.Elab.Tactic.evalRewriteSeq | null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.