module string | startPos dict | endPos dict | nextStartPos dict | goals list | goalsAfter list | ppTac string | elaborator string | kind string |
|---|---|---|---|---|---|---|---|---|
Mathlib.Computability.TuringMachine.ToPartrec | {
"line": 992,
"column": 20
} | {
"line": 992,
"column": 90
} | {
"line": 994,
"column": 0
} | [
{
"pp": "case ret\nk✝ : Cont'\n⊢ Λ'.ret k✝ ∈ trStmts₁ (Λ'.ret k✝)",
"ppTerm": "?ret",
"assigned": true,
"usedConstants": [
"Finset.mem_singleton_self",
"Turing.PartrecToTM2.Λ'",
"Turing.PartrecToTM2.Λ'.ret"
],
"usedFVars": [
"k✝"
],
"usedGoals": []
}
] | [] | first | apply Finset.mem_singleton_self | apply Finset.mem_insert_self | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Computability.TuringMachine.ToPartrec | {
"line": 992,
"column": 20
} | {
"line": 992,
"column": 90
} | {
"line": 994,
"column": 0
} | [
{
"pp": "case ret\nk✝ : Cont'\n⊢ Λ'.ret k✝ ∈ trStmts₁ (Λ'.ret k✝)",
"ppTerm": "?ret",
"assigned": true,
"usedConstants": [
"Finset.mem_singleton_self",
"Turing.PartrecToTM2.Λ'",
"Turing.PartrecToTM2.Λ'.ret"
],
"usedFVars": [
"k✝"
],
"usedGoals": []
}
] | [] | first | apply Finset.mem_singleton_self | apply Finset.mem_insert_self | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Topology.Category.LightProfinite.Extend | {
"line": 77,
"column": 89
} | {
"line": 81,
"column": 83
} | {
"line": 83,
"column": 0
} | [
{
"pp": "F : ℕᵒᵖ ⥤ FintypeCat\nc : Cone (F ⋙ toLightProfinite)\nhc : IsLimit c\ninst✝ : ∀ (i : ℕᵒᵖ), Epi (c.π.app i)\n⊢ (functor c).Initial",
"ppTerm": "?m.39",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"CategoryTheory.Limits.Cone.π",
"CategoryTheory.isCofiltered_op_of_isFilte... | [] | by
rw [initial_iff_comp_equivalence _ (StructuredArrow.post _ _ lightToProfinite)]
have : ∀ i, Epi ((lightToProfinite.mapCone c).π.app i) :=
fun i ↦ inferInstanceAs (Epi (lightToProfinite.map (c.π.app i)))
exact Profinite.Extend.functor_initial _ (isLimitOfPreserves lightToProfinite hc) | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Topology.Category.Profinite.Extend | {
"line": 112,
"column": 2
} | {
"line": 113,
"column": 78
} | {
"line": 114,
"column": 2
} | [
{
"pp": "I : Type u\ninst✝² : SmallCategory I\ninst✝¹ : IsCofiltered I\nF : I ⥤ FintypeCat\nc : Cone (F ⋙ toProfinite)\nhc : IsLimit c\ninst✝ : ∀ (i : I), Epi (c.π.app i)\nthis : (functor c).Initial\n⊢ (functorOp c).Final",
"ppTerm": "?m.49",
"assigned": true,
"usedConstants": [
"CategoryTheor... | [
"I : Type u\ninst✝² : SmallCategory I\ninst✝¹ : IsCofiltered I\nF : I ⥤ FintypeCat\nc : Cone (F ⋙ toProfinite)\nhc : IsLimit c\ninst✝ : ∀ (i : I), Epi (c.π.app i)\nthis✝ : (functor c).Initial\nthis : (StructuredArrow.toCostructuredArrow toProfinite c.pt).IsEquivalence\n⊢ (functorOp c).Final"
] | have : ((StructuredArrow.toCostructuredArrow toProfinite c.pt)).IsEquivalence :=
(inferInstance : (structuredArrowOpEquivalence _ _).functor.IsEquivalence) | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_tacticHave___1 | Lean.Parser.Tactic.tacticHave__ |
Mathlib.Topology.Category.Profinite.Extend | {
"line": 134,
"column": 31
} | {
"line": 134,
"column": 51
} | {
"line": 134,
"column": 51
} | [
{
"pp": "I : Type u\ninst✝² : SmallCategory I\ninst✝¹ : IsCofiltered I\nF : I ⥤ FintypeCat\nc : Cone (F ⋙ toProfinite)\nC : Type u_1\ninst✝ : Category.{v_1, u_1} C\nG : Profinite ⥤ C\nS : Profinite\nx✝¹ x✝ : StructuredArrow S toProfinite\nf : x✝¹ ⟶ x✝\n⊢ ((const (StructuredArrow S toProfinite)).obj (G.obj S)).m... | [] | by simp [← map_comp] | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Condensed.Discrete.Characterization | {
"line": 100,
"column": 2
} | {
"line": 101,
"column": 78
} | {
"line": 102,
"column": 2
} | [
{
"pp": "X : CondensedSet\ntfae_1_iff_2 : Condensed.IsDiscrete X ↔ IsIso ((discreteUnderlyingAdj (Type (u + 1))).counit.app X)\ntfae_1_iff_3 : Condensed.IsDiscrete X ↔ (discrete (Type (u + 1))).essImage X\ntfae_1_iff_4 : Condensed.IsDiscrete X ↔ LocallyConstant.functor.essImage X\ntfae_1_iff_5 : Condensed.IsDis... | [
"X : CondensedSet\ntfae_1_iff_2 : Condensed.IsDiscrete X ↔ IsIso ((discreteUnderlyingAdj (Type (u + 1))).counit.app X)\ntfae_1_iff_3 : Condensed.IsDiscrete X ↔ (discrete (Type (u + 1))).essImage X\ntfae_1_iff_4 : Condensed.IsDiscrete X ↔ LocallyConstant.functor.essImage X\ntfae_1_iff_5 : Condensed.IsDiscrete X ↔ Is... | tfae_have 7 → 4 := fun h ↦
mem_locallyConstant_essImage_of_isColimit_mapCocone X (fun S ↦ (h S).some) | Mathlib.Tactic.TFAE._aux_Mathlib_Tactic_TFAE___macroRules_Mathlib_Tactic_TFAE_tfaeHave_1 | Mathlib.Tactic.TFAE.tfaeHave |
Mathlib.Condensed.Discrete.Module | {
"line": 213,
"column": 2
} | {
"line": 214,
"column": 41
} | {
"line": 215,
"column": 2
} | [
{
"pp": "P : TopCat → Prop\nR : Type u\ninst✝ : Ring R\nM : ModuleCat R\n⊢ IsIso\n ((constantSheafAdj (coherentTopology LightProfinite) (Type u) isTerminalPUnit).counit.app\n ((sheafCompose (coherentTopology LightProfinite) (CategoryTheory.forget (ModuleCat R))).obj ((functor R).obj M)))",
"ppTerm":... | [
"P : TopCat → Prop\nR : Type u\ninst✝ : Ring R\nM : ModuleCat R\nthis : (constantSheaf (coherentTopology LightProfinite) (Type u)).Faithful\n⊢ IsIso\n ((constantSheafAdj (coherentTopology LightProfinite) (Type u) isTerminalPUnit).counit.app\n ((sheafCompose (coherentTopology LightProfinite) (CategoryTheory.... | have : (constantSheaf (coherentTopology LightProfinite.{u}) (Type u)).Faithful :=
inferInstanceAs (discrete _).Faithful | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_tacticHave___1 | Lean.Parser.Tactic.tacticHave__ |
Mathlib.Condensed.Discrete.Colimit | {
"line": 244,
"column": 6
} | {
"line": 244,
"column": 38
} | {
"line": 244,
"column": 38
} | [
{
"pp": "F : Profiniteᵒᵖ ⥤ Type (u + 1)\ninst✝² : PreservesFiniteProducts F\nX Y : Profinite\ninst✝¹ : Finite ↑X.toTop\ninst✝ : Finite ↑Y.toTop\nf : ↑Y.toTop → F.obj (Opposite.op (Profinite.of PUnit.{u + 1}))\ng : X ⟶ Y\nx : ↑X.toTop\n⊢ (f ∘ ⇑(ConcreteCategory.hom g)) x =\n (ConcreteCategory.hom (isoFinYoned... | [
"F : Profiniteᵒᵖ ⥤ Type (u + 1)\ninst✝² : PreservesFiniteProducts F\nX Y : Profinite\ninst✝¹ : Finite ↑X.toTop\ninst✝ : Finite ↑Y.toTop\nf : ↑Y.toTop → F.obj (Opposite.op (Profinite.of PUnit.{u + 1}))\ng : X ⟶ Y\nx : ↑X.toTop\n⊢ (f ∘ ⇑(ConcreteCategory.hom g)) x =\n (ConcreteCategory.hom (F.map (CompHausLike.con... | isoFinYonedaComponents_hom_apply | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Condensed.Discrete.Colimit | {
"line": 536,
"column": 6
} | {
"line": 536,
"column": 38
} | {
"line": 536,
"column": 38
} | [
{
"pp": "F : LightProfiniteᵒᵖ ⥤ Type u\ninst✝² : PreservesFiniteProducts F\nX Y : LightProfinite\ninst✝¹ : Finite ↑X.toTop\ninst✝ : Finite ↑Y.toTop\nf : ↑Y.toTop → F.obj (Opposite.op (LightProfinite.of PUnit.{u + 1}))\ng : X ⟶ Y\nx : ↑X.toTop\n⊢ (f ∘ ⇑(ConcreteCategory.hom g)) x =\n (ConcreteCategory.hom (is... | [
"F : LightProfiniteᵒᵖ ⥤ Type u\ninst✝² : PreservesFiniteProducts F\nX Y : LightProfinite\ninst✝¹ : Finite ↑X.toTop\ninst✝ : Finite ↑Y.toTop\nf : ↑Y.toTop → F.obj (Opposite.op (LightProfinite.of PUnit.{u + 1}))\ng : X ⟶ Y\nx : ↑X.toTop\n⊢ (f ∘ ⇑(ConcreteCategory.hom g)) x =\n (ConcreteCategory.hom (F.map (CompHau... | isoFinYonedaComponents_hom_apply | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Condensed.Discrete.Colimit | {
"line": 550,
"column": 4
} | {
"line": 555,
"column": 7
} | {
"line": 557,
"column": 0
} | [
{
"pp": "S : LightProfinite\nF✝ F : LightProfiniteᵒᵖ ⥤ Type u\ninst✝ : PreservesFiniteProducts F\nX✝ Y✝ : FintypeCatᵒᵖ\nx✝ : X✝ ⟶ Y✝\n⊢ (toLightProfinite.op ⋙ F).map x✝ ≫ (isoFinYonedaComponents F (toLightProfinite.obj (Opposite.unop Y✝))).hom =\n (isoFinYonedaComponents F (toLightProfinite.obj (Opposite.uno... | [] | simp only [comp_obj, op_obj, finYoneda_obj, Functor.comp_map, op_map]
ext
simp only [isoFinYonedaComponents_hom, TypeCat.Fun.toFun_apply, CategoryTheory.comp_apply,
ConcreteCategory.hom_ofHom, TypeCat.Fun.coe_mk, toLightProfinite_obj,
← Functor.map_comp_apply]
rfl | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Condensed.Discrete.Colimit | {
"line": 550,
"column": 4
} | {
"line": 555,
"column": 7
} | {
"line": 557,
"column": 0
} | [
{
"pp": "S : LightProfinite\nF✝ F : LightProfiniteᵒᵖ ⥤ Type u\ninst✝ : PreservesFiniteProducts F\nX✝ Y✝ : FintypeCatᵒᵖ\nx✝ : X✝ ⟶ Y✝\n⊢ (toLightProfinite.op ⋙ F).map x✝ ≫ (isoFinYonedaComponents F (toLightProfinite.obj (Opposite.unop Y✝))).hom =\n (isoFinYonedaComponents F (toLightProfinite.obj (Opposite.uno... | [] | simp only [comp_obj, op_obj, finYoneda_obj, Functor.comp_map, op_map]
ext
simp only [isoFinYonedaComponents_hom, TypeCat.Fun.toFun_apply, CategoryTheory.comp_apply,
ConcreteCategory.hom_ofHom, TypeCat.Fun.coe_mk, toLightProfinite_obj,
← Functor.map_comp_apply]
rfl | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Condensed.Light.InternallyProjective | {
"line": 155,
"column": 4
} | {
"line": 158,
"column": 15
} | {
"line": 160,
"column": 0
} | [
{
"pp": "case refine_2\nR : Type u\ninst✝ : CommRing R\nP : LightCondMod R\nh :\n ∀ {A B : LightCondMod R} (e : A ⟶ B) [Epi e] (S : LightProfinite) (g : (free R).obj S.toCondensed ⊗ P ⟶ B),\n ∃ S' π,\n ∃ (_ : Function.Surjective ⇑(ConcreteCategory.hom π)),\n ∃ g', (lightProfiniteToLightCondSet ⋙... | [] | specialize h e S ((β_ _ _).inv ≫ g)
obtain ⟨S', π, hπ, g', hh⟩ := h
refine ⟨S', π, hπ, (β_ _ _).hom ≫ g', ?_⟩
simp [← hh] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Condensed.Light.InternallyProjective | {
"line": 155,
"column": 4
} | {
"line": 158,
"column": 15
} | {
"line": 160,
"column": 0
} | [
{
"pp": "case refine_2\nR : Type u\ninst✝ : CommRing R\nP : LightCondMod R\nh :\n ∀ {A B : LightCondMod R} (e : A ⟶ B) [Epi e] (S : LightProfinite) (g : (free R).obj S.toCondensed ⊗ P ⟶ B),\n ∃ S' π,\n ∃ (_ : Function.Surjective ⇑(ConcreteCategory.hom π)),\n ∃ g', (lightProfiniteToLightCondSet ⋙... | [] | specialize h e S ((β_ _ _).inv ≫ g)
obtain ⟨S', π, hπ, g', hh⟩ := h
refine ⟨S', π, hπ, (β_ _ _).hom ≫ g', ?_⟩
simp [← hh] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Control.Bitraversable.Lemmas | {
"line": 80,
"column": 2
} | {
"line": 80,
"column": 41
} | {
"line": 82,
"column": 0
} | [
{
"pp": "t : Type u → Type u → Type u\ninst✝⁵ : Bitraversable t\nF G : Type u → Type u\ninst✝⁴ : Applicative F\ninst✝³ : Applicative G\ninst✝² : LawfulBitraversable t\ninst✝¹ : LawfulApplicative F\ninst✝ : LawfulApplicative G\nα₀ α₁ β₀ β₁ : Type u\nf : α₀ → F α₁\nf' : β₀ → G β₁\nx : t α₀ β₀\n⊢ bitraverse (Comp.... | [] | simp only [Function.comp_def, map_pure] | Lean.Elab.Tactic.evalSimp | Lean.Parser.Tactic.simp |
Mathlib.Control.Bitraversable.Lemmas | {
"line": 87,
"column": 2
} | {
"line": 87,
"column": 41
} | {
"line": 89,
"column": 0
} | [
{
"pp": "t : Type u → Type u → Type u\ninst✝⁵ : Bitraversable t\nF G : Type u → Type u\ninst✝⁴ : Applicative F\ninst✝³ : Applicative G\ninst✝² : LawfulBitraversable t\ninst✝¹ : LawfulApplicative F\ninst✝ : LawfulApplicative G\nα₀ α₁ β₀ β₁ : Type u\nf : α₀ → F α₁\nf' : β₀ → G β₁\nx : t α₀ β₀\n⊢ bitraverse (Comp.... | [] | simp only [Function.comp_def, map_pure] | Lean.Elab.Tactic.evalSimp | Lean.Parser.Tactic.simp |
Mathlib.Control.Bitraversable.Lemmas | {
"line": 93,
"column": 2
} | {
"line": 93,
"column": 41
} | {
"line": 94,
"column": 2
} | [
{
"pp": "t : Type u → Type u → Type u\ninst✝⁵ : Bitraversable t\nF G : Type u → Type u\ninst✝⁴ : Applicative F\ninst✝³ : Applicative G\ninst✝² : LawfulBitraversable t\ninst✝¹ : LawfulApplicative F\ninst✝ : LawfulApplicative G\nα β₀ β₁ β₂ : Type u\ng : β₀ → F β₁\ng' : β₁ → G β₂\nx : t α β₀\n⊢ bitraverse (Comp.mk... | [
"t : Type u → Type u → Type u\ninst✝⁵ : Bitraversable t\nF G : Type u → Type u\ninst✝⁴ : Applicative F\ninst✝³ : Applicative G\ninst✝² : LawfulBitraversable t\ninst✝¹ : LawfulApplicative F\ninst✝ : LawfulApplicative G\nα β₀ β₁ β₂ : Type u\ng : β₀ → F β₁\ng' : β₁ → G β₂\nx : t α β₀\n⊢ bitraverse (fun x ↦ Comp.mk (pu... | simp only [Function.comp_def, map_pure] | Lean.Elab.Tactic.evalSimp | Lean.Parser.Tactic.simp |
Mathlib.Control.Bitraversable.Instances | {
"line": 97,
"column": 2
} | {
"line": 98,
"column": 44
} | {
"line": 99,
"column": 2
} | [
{
"pp": "t : Type u → Type u → Type u\ninst✝² : Bitraversable t\nF : Type u → Type u\ninst✝¹ : Applicative F\ninst✝ : LawfulBitraversable t\nα : Type u\n⊢ LawfulTraversable (t α)",
"ppTerm": "?m.4",
"assigned": true,
"usedConstants": [
"Pure.pure",
"Traversable.toFunctor",
"congrAr... | [
"case traverse_eq_map_id\nt : Type u → Type u → Type u\ninst✝² : Bitraversable t\nF : Type u → Type u\ninst✝¹ : Applicative F\ninst✝ : LawfulBitraversable t\nα α✝ β✝ : Type u\nf✝ : α✝ → β✝\nx✝ : t α α✝\n⊢ tsnd (pure ∘ f✝) x✝ = pure (f✝ <$> x✝)",
"case naturality\nt : Type u → Type u → Type u\ninst✝⁶ : Bitraversab... | constructor <;> intros <;>
simp [traverse, comp_tsnd, functor_norm] | Lean.Parser.Tactic.«_aux_Init_Tactics___macroRules_Lean_Parser_Tactic_tactic_<;>__1» | Lean.Parser.Tactic.«tactic_<;>_» |
Mathlib.Control.Traversable.Instances | {
"line": 39,
"column": 14
} | {
"line": 39,
"column": 73
} | {
"line": 41,
"column": 0
} | [
{
"pp": "case none\nF G : Type u → Type u\ninst✝² : Applicative F\ninst✝¹ : Applicative G\ninst✝ : LawfulApplicative G\nα : Type u_1\nβ γ : Type u\nf : β → F γ\ng : α → G β\n⊢ Option.traverse (Comp.mk ∘ (fun x ↦ f <$> x) ∘ g) none = Comp.mk (Option.traverse f <$> Option.traverse g none)",
"ppTerm": "?none",... | [] | (simp [Option.traverse, Option.mapM, functor_norm] <;> rfl) | Lean.Elab.Tactic.evalParen | Lean.Parser.Tactic.paren |
Mathlib.Control.Traversable.Instances | {
"line": 39,
"column": 14
} | {
"line": 39,
"column": 73
} | {
"line": 41,
"column": 0
} | [
{
"pp": "case some\nF G : Type u → Type u\ninst✝² : Applicative F\ninst✝¹ : Applicative G\ninst✝ : LawfulApplicative G\nα : Type u_1\nβ γ : Type u\nf : β → F γ\ng : α → G β\nval✝ : α\n⊢ Option.traverse (Comp.mk ∘ (fun x ↦ f <$> x) ∘ g) (some val✝) =\n Comp.mk (Option.traverse f <$> Option.traverse g (some va... | [] | (simp [Option.traverse, Option.mapM, functor_norm] <;> rfl) | Lean.Elab.Tactic.evalParen | Lean.Parser.Tactic.paren |
Mathlib.Control.Fix | {
"line": 107,
"column": 2
} | {
"line": 107,
"column": 20
} | {
"line": 109,
"column": 0
} | [
{
"pp": "α : Type u_1\nβ : α → Type u_2\nf : ((a : α) → Part (β a)) → (a : α) → Part (β a)\nx : α\nh' : ¬∃ i, (Fix.approx f i x).Dom\n⊢ (assert (∃ i, (Fix.approx f i x).Dom) fun h ↦ ⋯.fix (fixAux f) Upto.zero x) = none",
"ppTerm": "?m.13",
"assigned": true,
"usedConstants": [
"Part",
"Eq... | [] | rw [assert_neg h'] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.Data.FinEnum.Option | {
"line": 100,
"column": 2
} | {
"line": 100,
"column": 36
} | {
"line": 101,
"column": 2
} | [
{
"pp": "P : Type u → Sort v\nfinChoice : (n : ℕ) → Fin (n + 1)\ncongr : {α β : Type u} → (x : FinEnum α) → (x_1 : FinEnum β) → card β = card α → P α → P β\nempty : P PEmpty.{u + 1}\noption : {α : Type u} → FinEnum α → P α → P (Option α)\nα : Type u\ninst✝ : FinEnum α\nh : 0 < card α\n⊢ recEmptyOption finChoice... | [
"P : Type u → Sort v\nfinChoice : (n : ℕ) → Fin (n + 1)\ncongr : {α β : Type u} → (x : FinEnum α) → (x_1 : FinEnum β) → card β = card α → P α → P β\nempty : P PEmpty.{u + 1}\noption : {α : Type u} → FinEnum α → P α → P (Option α)\nα : Type u\ninst✝ : FinEnum α\nh : 0 < card α\n⊢ (match cardeq : card α with\n | 0... | conv => lhs; unfold recEmptyOption | Lean.Elab.Tactic.Conv.evalConv | Lean.Parser.Tactic.Conv.conv |
Mathlib.Data.FinEnum | {
"line": 161,
"column": 6
} | {
"line": 161,
"column": 66
} | {
"line": 163,
"column": 0
} | [
{
"pp": "case cons\nα : Type u\ninst✝ : DecidableEq α\nx : α\nxs : List α\nih : ∀ (s : Finset α), s ∈ enum xs ↔ ∀ x ∈ s, x ∈ xs\ns : Finset α\nhs : ∀ x_1 ∈ s, ¬x_1 = x → x_1 ∈ xs\n⊢ (∀ x_1 ∈ s.erase x, x_1 ∈ xs) ∧ (s = s.erase x ∨ s = insert x (s.erase x))",
"ppTerm": "?cons",
"assigned": true,
"use... | [] | simp +contextual [eq_comm (a := s), or_iff_not_imp_left, hs] | Lean.Elab.Tactic.evalSimp | Lean.Parser.Tactic.simp |
Mathlib.Data.Multiset.Functor | {
"line": 117,
"column": 6
} | {
"line": 117,
"column": 37
} | {
"line": 117,
"column": 38
} | [
{
"pp": "case h\nG : Type u_1 → Type u_1\ninst✝¹ : Applicative G\ninst✝ : CommApplicative G\nα β γ : Type u_1\ng : α → β\nh : β → G γ\na✝ : List α\n⊢ ofList <$> Traversable.traverse h (List.map g a✝) = ofList <$> Traversable.traverse (h ∘ g) a✝",
"ppTerm": "?h",
"assigned": true,
"usedConstants": [
... | [
"case h\nG : Type u_1 → Type u_1\ninst✝¹ : Applicative G\ninst✝ : CommApplicative G\nα β γ : Type u_1\ng : α → β\nh : β → G γ\na✝ : List α\n⊢ ofList <$> Traversable.traverse h (List.map g a✝) = ofList <$> Traversable.traverse h (g <$> a✝)"
] | ← Traversable.traverse_map h g, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Data.Finmap | {
"line": 360,
"column": 20
} | {
"line": 360,
"column": 74
} | {
"line": 360,
"column": 74
} | [
{
"pp": "α : Type u\nβ : α → Type v\nf : (x : α) → β x → Bool\ns : Finmap β\nx✝³ : Bool\nx✝² : α\nx✝¹ : β x✝²\nx✝ : α\n⊢ ∀ (b₂ : β x✝), (x✝³ || f x✝² x✝¹ || f x✝ b₂) = (x✝³ || f x✝ b₂ || f x✝² x✝¹)",
"ppTerm": "?m.15",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"congrArg",
"Boo... | [] | by simp_rw [Bool.or_assoc, Bool.or_comm, imp_true_iff] | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Data.Finmap | {
"line": 562,
"column": 4
} | {
"line": 566,
"column": 63
} | {
"line": 568,
"column": 0
} | [
{
"pp": "α : Type u\nβ : α → Type v\ninst✝ : DecidableEq α\na : α\nb : β a\ns : Finmap β\nh : lookup a s = some b\nx : α\n⊢ lookup x (erase a s ∪ singleton a b) = lookup x s",
"ppTerm": "?m.21",
"assigned": true,
"usedConstants": [
"Finmap.lookup_singleton_eq",
"Finmap.erase",
"Eq.... | [] | by_cases h' : x = a
· subst a
rw [lookup_union_right notMem_erase_self, lookup_singleton_eq, h]
· have : x ∉ singleton a b := by rwa [mem_singleton]
rw [lookup_union_left_of_not_in this, lookup_erase_ne h'] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Data.Finmap | {
"line": 562,
"column": 4
} | {
"line": 566,
"column": 63
} | {
"line": 568,
"column": 0
} | [
{
"pp": "α : Type u\nβ : α → Type v\ninst✝ : DecidableEq α\na : α\nb : β a\ns : Finmap β\nh : lookup a s = some b\nx : α\n⊢ lookup x (erase a s ∪ singleton a b) = lookup x s",
"ppTerm": "?m.21",
"assigned": true,
"usedConstants": [
"Finmap.lookup_singleton_eq",
"Finmap.erase",
"Eq.... | [] | by_cases h' : x = a
· subst a
rw [lookup_union_right notMem_erase_self, lookup_singleton_eq, h]
· have : x ∉ singleton a b := by rwa [mem_singleton]
rw [lookup_union_left_of_not_in this, lookup_erase_ne h'] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Data.Finsupp.Sigma | {
"line": 107,
"column": 4
} | {
"line": 108,
"column": 8
} | {
"line": 109,
"column": 2
} | [
{
"pp": "case pos\nκ : Type u_1\nι : κ → Type u_2\nM : Type u_3\ninst✝ : AddMonoid M\nk : κ\nf g : ι k →₀ M\nk' : κ\ni : ι k'\nhk : k' = k\n⊢ (f + g).embSigma ⟨k', i⟩ = (f.embSigma + g.embSigma) ⟨k', i⟩",
"ppTerm": "?pos✝",
"assigned": true,
"usedConstants": [
"Finsupp.instFunLike",
"con... | [] | subst hk
simp | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Data.Finsupp.Sigma | {
"line": 107,
"column": 4
} | {
"line": 108,
"column": 8
} | {
"line": 109,
"column": 2
} | [
{
"pp": "case pos\nκ : Type u_1\nι : κ → Type u_2\nM : Type u_3\ninst✝ : AddMonoid M\nk : κ\nf g : ι k →₀ M\nk' : κ\ni : ι k'\nhk : k' = k\n⊢ (f + g).embSigma ⟨k', i⟩ = (f.embSigma + g.embSigma) ⟨k', i⟩",
"ppTerm": "?pos✝",
"assigned": true,
"usedConstants": [
"Finsupp.instFunLike",
"con... | [] | subst hk
simp | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Data.Int.Lemmas | {
"line": 124,
"column": 4
} | {
"line": 125,
"column": 10
} | {
"line": 126,
"column": 4
} | [
{
"pp": "case mpr.left\na b r q : ℤ\nh : b ≠ 0\nhz : 0 ≤ r\nhb : r < |b|\n⊢ (r + b * q) / b = q",
"ppTerm": "?mpr.left",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"Int.instDiv",
"instHDiv",
"HMul.hMul",
"congrArg",
"AddMonoid.toAddZeroClass",
"Int.ediv_... | [
"case mpr.right\na b r q : ℤ\nh : b ≠ 0\nhz : 0 ≤ r\nhb : r < |b|\n⊢ (r + b * q) % b = r"
] | · rw [Int.add_mul_ediv_left r q h, ediv_eq_zero_of_lt_abs hz hb]
simp | Lean.Elab.Tactic.evalTacticCDot | Lean.cdot |
Mathlib.Data.Int.CardIntervalMod | {
"line": 136,
"column": 8
} | {
"line": 136,
"column": 33
} | {
"line": 136,
"column": 34
} | [
{
"pp": "b r : ℕ\nhr : 0 < r\nv : ℕ\nhr' : 0 < ↑r\n| ⌈(↑b - ↑(v % r)) / ↑r⌉ - ↑(v / r) - (⌈(↑0 - ↑(v % r)) / ↑r⌉ - ↑(v / r))",
"ppTerm": "?m.114",
"assigned": true,
"usedConstants": [
"sub_sub_sub_cancel_right",
"instHDiv",
"congrArg",
"Rat",
"Rat.instFloorRing",
... | [
"b r : ℕ\nhr : 0 < r\nv : ℕ\nhr' : 0 < ↑r\n| ⌈(↑b - ↑(v % r)) / ↑r⌉ - ⌈(↑0 - ↑(v % r)) / ↑r⌉"
] | sub_sub_sub_cancel_right, | Lean.Elab.Tactic.Conv.evalRewrite | null |
Mathlib.Data.List.Lemmas | {
"line": 53,
"column": 8
} | {
"line": 53,
"column": 19
} | {
"line": 53,
"column": 20
} | [
{
"pp": "case cons\nα : Type u_1\nβ : Type u_2\nγ : Type u_3\nf : β → α → α\ng : γ → α → α\nhfg : Set.range f ⊆ Set.range g\na : α\nb : β\nl : List β\nc : γ\nhgf : g c = f b\nm : List γ\nhgf' : foldr g a m = foldr f a l\n⊢ foldr f a (b :: l) ∈ Set.range (foldr g a)",
"ppTerm": "?cons",
"assigned": true,... | [
"case cons\nα : Type u_1\nβ : Type u_2\nγ : Type u_3\nf : β → α → α\ng : γ → α → α\nhfg : Set.range f ⊆ Set.range g\na : α\nb : β\nl : List β\nc : γ\nhgf : g c = f b\nm : List γ\nhgf' : foldr g a m = foldr f a l\n⊢ f b (foldr f a l) ∈ Set.range (foldr g a)"
] | foldr_cons, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Data.List.PeriodicityLemma | {
"line": 48,
"column": 8
} | {
"line": 48,
"column": 17
} | {
"line": 48,
"column": 17
} | [
{
"pp": "case mp\nα : Type u_1\np : ℕ\nw : List α\n⊢ w.HasPeriod p → ∀ i < w.length - p, w[i]? = w[i + p]?",
"ppTerm": "?mp",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"congrArg",
"List.HasPeriod",
"HSub.hSub",
"List.instGetElem?NatLtLength",
"List.HasPeriod.... | [
"case mp\nα : Type u_1\np : ℕ\nw : List α\n⊢ w <+: take p w ++ w → ∀ i < w.length - p, w[i]? = w[i + p]?"
] | HasPeriod | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Data.List.PeriodicityLemma | {
"line": 49,
"column": 17
} | {
"line": 49,
"column": 20
} | {
"line": 50,
"column": 4
} | [
{
"pp": "case mp\nα : Type u_1\np : ℕ\nw : List α\npref : w <+: take p w ++ w\nj : ℕ\n⊢ j < w.length - p → w[j]? = w[j + p]?",
"ppTerm": "?mp",
"assigned": true,
"usedConstants": [
"HSub.hSub",
"instSubNat",
"instHSub",
"Nat",
"LT.lt",
"instLTNat",
"List.len... | [
"case mp\nα : Type u_1\np : ℕ\nw : List α\npref : w <+: take p w ++ w\nj : ℕ\nlen : j < w.length - p\n⊢ w[j]? = w[j + p]?"
] | len | Lean.Elab.Tactic.evalIntro | ident |
Mathlib.Data.List.Shortlex | {
"line": 168,
"column": 4
} | {
"line": 168,
"column": 16
} | {
"line": 169,
"column": 4
} | [
{
"pp": "α : Type u_1\nr : α → α → Prop\nh : WellFounded r\nn : ℕ\nih : ∀ m ≤ n, ∀ (a : List α), a.length = m → Acc (Shortlex r) a\nhead : α\ntail : List α\nlen_a : tail.length = n\nl : List α\nll : l.length < (head :: tail).length\n⊢ l.length ≤ n",
"ppTerm": "?m.104",
"assigned": true,
"usedConstan... | [
"α : Type u_1\nr : α → α → Prop\nh : WellFounded r\nn : ℕ\nih : ∀ m ≤ n, ∀ (a : List α), a.length = m → Acc (Shortlex r) a\nhead : α\ntail : List α\nlen_a : tail.length = n\nl : List α\nll : l.length < (head :: tail).length\n⊢ l.length ≤ tail.length"
] | rw [← len_a] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.Data.List.PeriodicityLemma | {
"line": 57,
"column": 8
} | {
"line": 57,
"column": 17
} | {
"line": 57,
"column": 17
} | [
{
"pp": "case mpr\nα : Type u_1\np : ℕ\nw : List α\nlhs : ∀ i < w.length - p, w[i]? = w[i + p]?\n⊢ w.HasPeriod p",
"ppTerm": "?mpr",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"congrArg",
"List.HasPeriod",
"List.HasPeriod.eq_1",
"id",
"instHAppendOfAppend",
... | [
"case mpr\nα : Type u_1\np : ℕ\nw : List α\nlhs : ∀ i < w.length - p, w[i]? = w[i + p]?\n⊢ w <+: take p w ++ w"
] | HasPeriod | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Data.List.PeriodicityLemma | {
"line": 72,
"column": 6
} | {
"line": 72,
"column": 15
} | {
"line": 72,
"column": 15
} | [
{
"pp": "α : Type u_1\nw : List α\np : ℕ\nlarge : w.length ≤ p\n⊢ w.HasPeriod p",
"ppTerm": "?m.5",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"congrArg",
"List.HasPeriod",
"List.HasPeriod.eq_1",
"id",
"instHAppendOfAppend",
"List",
"List.IsPrefix"... | [
"α : Type u_1\nw : List α\np : ℕ\nlarge : w.length ≤ p\n⊢ w <+: take p w ++ w"
] | HasPeriod | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Data.List.PeriodicityLemma | {
"line": 99,
"column": 16
} | {
"line": 99,
"column": 19
} | {
"line": 100,
"column": 4
} | [
{
"pp": "case mp\nα : Type u_1\np : ℕ\nw : List α\nper : w.HasPeriod p\ni : ℕ\n⊢ i < w.length → w[i]? = w[i % p]?",
"ppTerm": "?mp",
"assigned": true,
"usedConstants": [
"Nat",
"LT.lt",
"instLTNat",
"List.length"
],
"usedFVars": [
"i",
"α",
"w"
]... | [
"case mp\nα : Type u_1\np : ℕ\nw : List α\nper : w.HasPeriod p\ni : ℕ\nlen : i < w.length\n⊢ w[i]? = w[i % p]?"
] | len | Lean.Elab.Tactic.evalIntro | ident |
Mathlib.Data.List.PeriodicityLemma | {
"line": 110,
"column": 10
} | {
"line": 110,
"column": 13
} | {
"line": 111,
"column": 2
} | [
{
"pp": "α : Type u_1\nu v w : List α\np : ℕ\nper : (u ++ v ++ w).HasPeriod p\nj : ℕ\n⊢ j < v.length - p → v[j]? = v[j + p]?",
"ppTerm": "?m.39",
"assigned": true,
"usedConstants": [
"HSub.hSub",
"instSubNat",
"instHSub",
"Nat",
"LT.lt",
"instLTNat",
"List.l... | [
"α : Type u_1\nu v w : List α\np : ℕ\nper : (u ++ v ++ w).HasPeriod p\nj : ℕ\nlen : j < v.length - p\n⊢ v[j]? = v[j + p]?"
] | len | Lean.Elab.Tactic.evalIntro | ident |
Mathlib.Data.List.PeriodicityLemma | {
"line": 229,
"column": 8
} | {
"line": 229,
"column": 42
} | {
"line": 230,
"column": 6
} | [
{
"pp": "α : Type u_1\nw : List α\np q : ℕ\nper_p : w.HasPeriod p\nper_q : w.HasPeriod q\nlen : p + q - p.gcd q ≤ w.length\np_pos : p > 0\nq_pos : q > 0\nhyp : compare p q = Ordering.gt\nq_lt_p : q < p\ngcd_lt_p : p.gcd q < p\nper_diff : (drop q w).HasPeriod (p - q)\nper_q' : (drop q w).HasPeriod q\ngcd_stable ... | [] | rw [take_eq, take_append_drop q w] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.Data.List.PeriodicityLemma | {
"line": 229,
"column": 8
} | {
"line": 229,
"column": 42
} | {
"line": 230,
"column": 6
} | [
{
"pp": "α : Type u_1\nw : List α\np q : ℕ\nper_p : w.HasPeriod p\nper_q : w.HasPeriod q\nlen : p + q - p.gcd q ≤ w.length\np_pos : p > 0\nq_pos : q > 0\nhyp : compare p q = Ordering.gt\nq_lt_p : q < p\ngcd_lt_p : p.gcd q < p\nper_diff : (drop q w).HasPeriod (p - q)\nper_q' : (drop q w).HasPeriod q\ngcd_stable ... | [] | rw [take_eq, take_append_drop q w] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Data.List.PeriodicityLemma | {
"line": 229,
"column": 8
} | {
"line": 229,
"column": 42
} | {
"line": 230,
"column": 6
} | [
{
"pp": "α : Type u_1\nw : List α\np q : ℕ\nper_p : w.HasPeriod p\nper_q : w.HasPeriod q\nlen : p + q - p.gcd q ≤ w.length\np_pos : p > 0\nq_pos : q > 0\nhyp : compare p q = Ordering.gt\nq_lt_p : q < p\ngcd_lt_p : p.gcd q < p\nper_diff : (drop q w).HasPeriod (p - q)\nper_q' : (drop q w).HasPeriod q\ngcd_stable ... | [] | rw [take_eq, take_append_drop q w] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Data.List.SplitBy | {
"line": 188,
"column": 8
} | {
"line": 188,
"column": 17
} | {
"line": 188,
"column": 18
} | [
{
"pp": "case cons\nα : Type u_1\nr : α → α → Bool\na : List α\nl : List (List α)\nIH :\n ¬[] ∈ l →\n (∀ (m : List α), m ∈ l → IsChain (fun x y ↦ r x y = true) m) →\n IsChain (fun a b ↦ ∃ ha hb, r (a.getLast ha) (b.head hb) = false) l → splitBy r l.flatten = l\nhn : ¬[] ∈ a :: l\nhc : ∀ (m : List α), m... | [
"case cons\nα : Type u_1\nr : α → α → Bool\na : List α\nl : List (List α)\nIH :\n ¬[] ∈ l →\n (∀ (m : List α), m ∈ l → IsChain (fun x y ↦ r x y = true) m) →\n IsChain (fun a b ↦ ∃ ha hb, r (a.getLast ha) (b.head hb) = false) l → splitBy r l.flatten = l\nhn : ¬([] = a ∨ [] ∈ l)\nhc : ∀ (m : List α), m ∈ a :... | mem_cons, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Data.Multiset.DershowitzManna | {
"line": 106,
"column": 20
} | {
"line": 106,
"column": 30
} | {
"line": 106,
"column": 30
} | [
{
"pp": "case intro\nα : Type u_1\ninst✝ : Preorder α\na✝ a : α\nh✝ : ∀ (y : α), y < a → Acc LT.lt y\nha : ∀ (y : α), y < a → ∀ {M : Multiset α}, Acc OneStep M → Acc OneStep (y ::ₘ M)\n⊢ ∀ {M : Multiset α}, Acc OneStep M → Acc OneStep (a ::ₘ M)",
"ppTerm": "?intro",
"assigned": true,
"usedConstants"... | [
"case intro\nα : Type u_1\ninst✝ : Preorder α\na✝ a : α\nh✝ : ∀ (y : α), y < a → Acc LT.lt y\nha : ∀ (y : α), y < a → ∀ {M : Multiset α}, Acc OneStep M → Acc OneStep (y ::ₘ M)\n⊢ ∀ {M : Multiset α}, Acc OneStep M → Acc OneStep (a ::ₘ M)"
] | | _ a _ ha
=> | _private.Lean.Elab.Tactic.Induction.0.Lean.Elab.Tactic.evalInduction | null |
Mathlib.Data.Nat.ChineseRemainder | {
"line": 76,
"column": 4
} | {
"line": 76,
"column": 9
} | {
"line": 77,
"column": 4
} | [
{
"pp": "ι : Type u_1\na s : ι → ℕ\ni : ι\nl : List ι\nco : List.Pairwise (Coprime on s) (i :: l)\nthis : (s i).Coprime (List.map s l).prod\nih : { k // ∀ i ∈ l, k ≡ a i [MOD s i] }\nk : { k // k ≡ a i [MOD s i] ∧ k ≡ ↑ih [MOD (List.map s l).prod] }\n⊢ { k // ∀ i_1 ∈ i :: l, k ≡ a i_1 [MOD s i_1] }",
"ppTer... | [
"case property\nι : Type u_1\na s : ι → ℕ\ni : ι\nl : List ι\nco : List.Pairwise (Coprime on s) (i :: l)\nthis : (s i).Coprime (List.map s l).prod\nih : { k // ∀ i ∈ l, k ≡ a i [MOD s i] }\nk : { k // k ≡ a i [MOD s i] ∧ k ≡ ↑ih [MOD (List.map s l).prod] }\n⊢ ∀ i_1 ∈ i :: l, ↑k ≡ a i_1 [MOD s i_1]"
] | use k | Mathlib.Tactic._aux_Mathlib_Tactic_Use___elabRules_Mathlib_Tactic_useSyntax_1 | Mathlib.Tactic.useSyntax |
Mathlib.Data.Nat.Factorial.NatCast | {
"line": 39,
"column": 28
} | {
"line": 39,
"column": 41
} | {
"line": 39,
"column": 42
} | [
{
"pp": "case succ\nA : Type u_1\ninst✝ : Semiring A\nk : ℕ\nih : ∀ {m : ℕ}, IsUnit ↑(m + k)! → IsUnit ↑m !\nm : ℕ\nhn_fac : IsUnit ↑(m + 1 + k)!\nthis : IsUnit ↑((m + 1) * m !)\n⊢ IsUnit ↑m !",
"ppTerm": "?succ",
"assigned": true,
"usedConstants": [
"NonAssocSemiring.toAddCommMonoidWithOne",
... | [
"case succ\nA : Type u_1\ninst✝ : Semiring A\nk : ℕ\nih : ∀ {m : ℕ}, IsUnit ↑(m + k)! → IsUnit ↑m !\nm : ℕ\nhn_fac : IsUnit ↑(m + 1 + k)!\nthis : IsUnit (↑(m + 1) * ↑m !)\n⊢ IsUnit ↑m !"
] | Nat.cast_mul, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Data.Nat.Digits.Div | {
"line": 70,
"column": 2
} | {
"line": 70,
"column": 35
} | {
"line": 72,
"column": 0
} | [
{
"pp": "n : ℕ\np : (digits 10 n).Palindrome\ndig : List ℤ := List.map (fun n ↦ ↑n) (digits 10 n)\nh : Even dig.length\nthis : (List.map (fun n ↦ ↑n) (digits 10 n)).alternatingSum = -dig.alternatingSum\n⊢ dig.alternatingSum = 0",
"ppTerm": "?m.92",
"assigned": true,
"usedConstants": [
"Int.ins... | [] | exact eq_zero_of_neg_eq this.symm | Lean.Elab.Tactic.evalExact | Lean.Parser.Tactic.exact |
Mathlib.Data.Nat.Choose.Lucas | {
"line": 61,
"column": 80
} | {
"line": 61,
"column": 90
} | {
"line": 61,
"column": 90
} | [
{
"pp": "n k p : ℕ\ninst✝ : Fact (Nat.Prime p)\ndecompose : (X + 1) ^ n = (X + 1) ^ (n % p) * (X ^ p + 1) ^ (n / p)\nh_iff : ∀ x ∈ range (n % p + 1) ×ˢ range (n / p + 1), k = x.1 + p * x.2 ↔ (k % p, k / p) = x\n⊢ (∑ a ∈ range (n % p + 1) ×ˢ range (n / p + 1),\n if (k % p, k / p) = a then 1 * ↑((n % p).choo... | [
"n k p : ℕ\ninst✝ : Fact (Nat.Prime p)\ndecompose : (X + 1) ^ n = (X + 1) ^ (n % p) * (X ^ p + 1) ^ (n / p)\nh_iff : ∀ x ∈ range (n % p + 1) ×ˢ range (n / p + 1), k = x.1 + p * x.2 ↔ (k % p, k / p) = x\n⊢ (if (k % p, k / p) ∈ range (n % p + 1) ×ˢ range (n / p + 1) then\n 1 * ↑((n % p).choose (k % p, k / p).1 *... | sum_ite_eq | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Data.Nat.Nth | {
"line": 127,
"column": 34
} | {
"line": 127,
"column": 57
} | {
"line": 127,
"column": 57
} | [
{
"pp": "p : ℕ → Prop\nhf : (setOf p).Finite\nx : ℕ\nh : x ∈ {y | p y}\n⊢ ∃ n < #hf.toFinset, nth p n = x",
"ppTerm": "?m.18",
"assigned": true,
"usedConstants": [
"congrArg",
"setOf",
"Membership.mem",
"Eq.mp",
"Nat.instPreorder",
"Set.Finite.toFinset",
"Na... | [
"p : ℕ → Prop\nhf : (setOf p).Finite\nx : ℕ\nh : x ∈ nth p '' Set.Iio #hf.toFinset\n⊢ ∃ n < #hf.toFinset, nth p n = x"
] | ← image_nth_Iio_card hf | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Data.Nat.Nth | {
"line": 348,
"column": 4
} | {
"line": 348,
"column": 30
} | {
"line": 349,
"column": 4
} | [
{
"pp": "p : ℕ → Prop\nf : ℕ → ℕ\nhf : StrictMono f\nh0 : ∀ (k : ℕ), p k → k ∈ Set.range f\nhs : ∀ {p' : ℕ → Prop}, (∀ (k : ℕ), p' k → k ∈ Set.range f) → f '' {i | p' (f i)} = setOf p'\nh : p (nth p 0)\n⊢ {i | p (f i)}.Nonempty",
"ppTerm": "?m.134",
"assigned": true,
"usedConstants": [
"setOf"... | [
"p : ℕ → Prop\nf : ℕ → ℕ\nhf : StrictMono f\nh0 : ∀ (k : ℕ), p k → k ∈ Set.range f\nhs : ∀ {p' : ℕ → Prop}, (∀ (k : ℕ), p' k → k ∈ Set.range f) → f '' {i | p' (f i)} = setOf p'\nh : p (nth p 0)\nt : ℕ\nht : f t = nth p 0\n⊢ {i | p (f i)}.Nonempty"
] | rcases h0 _ h with ⟨t, ht⟩ | _private.Lean.Elab.Tactic.RCases.0.Lean.Elab.Tactic.RCases.evalRCases | Lean.Parser.Tactic.rcases |
Mathlib.Data.PFunctor.Univariate.M | {
"line": 422,
"column": 2
} | {
"line": 422,
"column": 43
} | {
"line": 423,
"column": 2
} | [
{
"pp": "F : PFunctor.{uA, uB}\ninst✝¹ : DecidableEq F.A\ninst✝ : Inhabited F.M\nx : ↑F F.M\ni : F.Idx\n⊢ ichildren i (M.mk x) = x.iget i",
"ppTerm": "?m.12",
"assigned": true,
"usedConstants": [
"PFunctor.M",
"id",
"PFunctor.Obj.iget",
"PFunctor.M.ichildren",
"Eq",
... | [
"F : PFunctor.{uA, uB}\ninst✝¹ : DecidableEq F.A\ninst✝ : Inhabited F.M\nx : ↑F F.M\ni : F.Idx\n⊢ (if H' : i.fst = (M.mk x).head then (M.mk x).children (cast ⋯ i.snd) else default) =\n if h : i.fst = x.fst then x.snd (cast ⋯ i.snd) else default"
] | dsimp only [ichildren, PFunctor.Obj.iget] | Lean.Elab.Tactic.evalDSimp | Lean.Parser.Tactic.dsimp |
Mathlib.Data.PNat.Factors | {
"line": 331,
"column": 6
} | {
"line": 331,
"column": 27
} | {
"line": 331,
"column": 27
} | [
{
"pp": "u v : PrimeMultiset\nh : u.prod.factorMultiset ≤ v ↔ u.prod ∣ v.prod := PNat.factorMultiset_le_iff'\n⊢ u.prod ∣ v.prod ↔ u ≤ v",
"ppTerm": "?m.7",
"assigned": true,
"usedConstants": [
"Dvd.dvd",
"instDistribLatticePrimeMultiset",
"congrArg",
"PartialOrder.toPreorder"... | [
"u v : PrimeMultiset\nh : u ≤ v ↔ u.prod ∣ v.prod\n⊢ u.prod ∣ v.prod ↔ u ≤ v"
] | u.factorMultiset_prod | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Data.PNat.Factors | {
"line": 380,
"column": 4
} | {
"line": 382,
"column": 40
} | {
"line": 384,
"column": 0
} | [
{
"pp": "case e'_3.right\nm : ℕ+\np : Nat.Primes\nk : ℕ\ne_1✝ : PrimeMultiset = Multiset Nat.Primes\n⊢ ∀ (b : Nat.Primes), b ∈ k • PrimeMultiset.ofPrime p → b = p",
"ppTerm": "?e'_3.right",
"assigned": true,
"usedConstants": [
"instHSMul",
"congrArg",
"instAddCommMonoidPrimeMultise... | [] | intro q h
rw [PrimeMultiset.ofPrime, Multiset.nsmul_singleton _ k] at h
exact Multiset.eq_of_mem_replicate h | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Data.PNat.Factors | {
"line": 380,
"column": 4
} | {
"line": 382,
"column": 40
} | {
"line": 384,
"column": 0
} | [
{
"pp": "case e'_3.right\nm : ℕ+\np : Nat.Primes\nk : ℕ\ne_1✝ : PrimeMultiset = Multiset Nat.Primes\n⊢ ∀ (b : Nat.Primes), b ∈ k • PrimeMultiset.ofPrime p → b = p",
"ppTerm": "?e'_3.right",
"assigned": true,
"usedConstants": [
"instHSMul",
"congrArg",
"instAddCommMonoidPrimeMultise... | [] | intro q h
rw [PrimeMultiset.ofPrime, Multiset.nsmul_singleton _ k] at h
exact Multiset.eq_of_mem_replicate h | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Data.PFunctor.Univariate.M | {
"line": 577,
"column": 4
} | {
"line": 577,
"column": 40
} | {
"line": 578,
"column": 4
} | [
{
"pp": "case head\nP : PFunctor.{uA, uB}\nR : P.M → P.M → Prop\nthis : Inhabited P.A\na a' : P.A\nf : P.B a → P.M\nf' : P.B a' → P.M\nih : R (M.mk ⟨a, f⟩) (M.mk ⟨a', f'⟩)\na'' : P.A\ng g' : P.B a'' → P.M\nh₁ : (M.mk ⟨a', f'⟩).dest = ⟨a'', g'⟩\nh₂ : ∀ (i : P.B a''), R (g i) (g' i)\nh₀ : (M.mk ⟨a, f⟩).dest.fst =... | [
"case head\nP : PFunctor.{uA, uB}\nR : P.M → P.M → Prop\nthis : Inhabited P.A\na a' : P.A\nf : P.B a → P.M\nf' : P.B a' → P.M\nih : R (M.mk ⟨a, f⟩) (M.mk ⟨a', f'⟩)\na'' : P.A\ng g' : P.B a'' → P.M\nh₂ : ∀ (i : P.B a''), R (g i) (g' i)\nh₀ : (M.mk ⟨a, f⟩).dest.fst = ⟨a'', g⟩.fst\nh₁ : (M.mk ⟨a', f'⟩).dest.fst = ⟨a''... | replace h₁ := congr_arg Sigma.fst h₁ | Lean.Elab.Tactic.evalReplace | Lean.Parser.Tactic.replace |
Mathlib.Data.PFunctor.Univariate.M | {
"line": 616,
"column": 45
} | {
"line": 616,
"column": 76
} | {
"line": 617,
"column": 2
} | [
{
"pp": "P : PFunctor.{uA, uB}\nα : Type u_2\ng : α → ↑P α\nf : α → P.M\nhyp : ∀ (x : α), (f x).dest = P.map f (g x)\nx : α\na✝ : True\na : P.A\nf' : P.B a → α\ngxeq : g x = ⟨a, f'⟩\n⊢ (f x).dest = ⟨a, f ∘ f'⟩",
"ppTerm": "?m.52",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"PFunctor.... | [] | rw [hyp, gxeq, PFunctor.map_eq] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.Data.Ordmap.Invariants | {
"line": 635,
"column": 12
} | {
"line": 635,
"column": 44
} | {
"line": 636,
"column": 10
} | [
{
"pp": "case pos\nα : Type u_1\nx : α\nls : ℕ\nlx : α\nrs : ℕ\nrl : Ordnode α\nrx : α\nrr : Ordnode α\nhr : (node rs rl rx rr).Balanced\nsr : (node rs rl rx rr).Sized\nh : ¬delta * ls < rs\nh_1 : delta * rs < ls\nlls : ℕ\nlll : Ordnode α\nllx : α\nllr : Ordnode α\nlrs : ℕ\nlrl : Ordnode α\nlrx : α\nlrr : Ordno... | [] | simp [node3R, node', sl.1]; abel | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Data.Ordmap.Invariants | {
"line": 635,
"column": 12
} | {
"line": 635,
"column": 44
} | {
"line": 636,
"column": 10
} | [
{
"pp": "case pos\nα : Type u_1\nx : α\nls : ℕ\nlx : α\nrs : ℕ\nrl : Ordnode α\nrx : α\nrr : Ordnode α\nhr : (node rs rl rx rr).Balanced\nsr : (node rs rl rx rr).Sized\nh : ¬delta * ls < rs\nh_1 : delta * rs < ls\nlls : ℕ\nlll : Ordnode α\nllx : α\nllr : Ordnode α\nlrs : ℕ\nlrl : Ordnode α\nlrx : α\nlrr : Ordno... | [] | simp [node3R, node', sl.1]; abel | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Data.PSigma.Order | {
"line": 107,
"column": 8
} | {
"line": 107,
"column": 39
} | {
"line": 107,
"column": 39
} | [
{
"pp": "case inr.inr\nι : Type u_1\nα : ι → Type u_2\ninst✝¹ : LinearOrder ι\ninst✝ : (i : ι) → LinearOrder (α i)\ni : ι\na : α i\nj : ι\nb : α j\nhji : j < i\n⊢ ⟨i, a⟩ ≤ ⟨j, b⟩ ∨ ⟨j, b⟩ ≤ ⟨i, a⟩",
"ppTerm": "?inr.inr",
"assigned": true,
"usedConstants": [
"Preorder.toLT",
"PSigma.Lex.l... | [] | exact Or.inr (Lex.left _ _ hji) | Lean.Elab.Tactic.evalExact | Lean.Parser.Tactic.exact |
Mathlib.Data.PSigma.Order | {
"line": 107,
"column": 8
} | {
"line": 107,
"column": 39
} | {
"line": 107,
"column": 39
} | [
{
"pp": "case inr.inr\nι : Type u_1\nα : ι → Type u_2\ninst✝¹ : LinearOrder ι\ninst✝ : (i : ι) → LinearOrder (α i)\ni : ι\na : α i\nj : ι\nb : α j\nhji : j < i\n⊢ ⟨i, a⟩ ≤ ⟨j, b⟩ ∨ ⟨j, b⟩ ≤ ⟨i, a⟩",
"ppTerm": "?inr.inr",
"assigned": true,
"usedConstants": [
"Preorder.toLT",
"PSigma.Lex.l... | [] | exact Or.inr (Lex.left _ _ hji) | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Data.PSigma.Order | {
"line": 107,
"column": 8
} | {
"line": 107,
"column": 39
} | {
"line": 107,
"column": 39
} | [
{
"pp": "case inr.inr\nι : Type u_1\nα : ι → Type u_2\ninst✝¹ : LinearOrder ι\ninst✝ : (i : ι) → LinearOrder (α i)\ni : ι\na : α i\nj : ι\nb : α j\nhji : j < i\n⊢ ⟨i, a⟩ ≤ ⟨j, b⟩ ∨ ⟨j, b⟩ ≤ ⟨i, a⟩",
"ppTerm": "?inr.inr",
"assigned": true,
"usedConstants": [
"Preorder.toLT",
"PSigma.Lex.l... | [] | exact Or.inr (Lex.left _ _ hji) | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Data.QPF.Multivariate.Constructions.Fix | {
"line": 115,
"column": 33
} | {
"line": 115,
"column": 68
} | {
"line": 116,
"column": 2
} | [
{
"pp": "case abs\nn : ℕ\nF : TypeVec.{u} (n + 1) → Type u\nq : MvQPF F\nα : TypeVec.{u} n\nx y : (P F).W α\na₀ : (P F).A\nf'₀ : (P F).drop.B a₀ ⟹ α\nf₀ : (P F).last.B a₀ → (P F).W α\na₁ : (P F).A\nf'₁ : (P F).drop.B a₁ ⟹ α\nf₁ : (P F).last.B a₁ → (P F).W α\nh : abs ⟨a₀, (P F).appendContents f'₀ f₀⟩ = abs ⟨a₁, ... | [] | exact WEquiv.abs _ _ _ _ _ _ h.symm | Lean.Elab.Tactic.evalExact | Lean.Parser.Tactic.exact |
Mathlib.Data.QPF.Multivariate.Constructions.Fix | {
"line": 115,
"column": 33
} | {
"line": 115,
"column": 68
} | {
"line": 116,
"column": 2
} | [
{
"pp": "case abs\nn : ℕ\nF : TypeVec.{u} (n + 1) → Type u\nq : MvQPF F\nα : TypeVec.{u} n\nx y : (P F).W α\na₀ : (P F).A\nf'₀ : (P F).drop.B a₀ ⟹ α\nf₀ : (P F).last.B a₀ → (P F).W α\na₁ : (P F).A\nf'₁ : (P F).drop.B a₁ ⟹ α\nf₁ : (P F).last.B a₁ → (P F).W α\nh : abs ⟨a₀, (P F).appendContents f'₀ f₀⟩ = abs ⟨a₁, ... | [] | exact WEquiv.abs _ _ _ _ _ _ h.symm | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Data.QPF.Multivariate.Constructions.Fix | {
"line": 115,
"column": 33
} | {
"line": 115,
"column": 68
} | {
"line": 116,
"column": 2
} | [
{
"pp": "case abs\nn : ℕ\nF : TypeVec.{u} (n + 1) → Type u\nq : MvQPF F\nα : TypeVec.{u} n\nx y : (P F).W α\na₀ : (P F).A\nf'₀ : (P F).drop.B a₀ ⟹ α\nf₀ : (P F).last.B a₀ → (P F).W α\na₁ : (P F).A\nf'₁ : (P F).drop.B a₁ ⟹ α\nf₁ : (P F).last.B a₁ → (P F).W α\nh : abs ⟨a₀, (P F).appendContents f'₀ f₀⟩ = abs ⟨a₁, ... | [] | exact WEquiv.abs _ _ _ _ _ _ h.symm | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Data.QPF.Multivariate.Constructions.Fix | {
"line": 296,
"column": 4
} | {
"line": 300,
"column": 21
} | {
"line": 301,
"column": 2
} | [
{
"pp": "n : ℕ\nF : TypeVec.{u} (n + 1) → Type u\nq : MvQPF F\nα : TypeVec.{u} n\n⊢ ∀ {α : TypeVec.{u} n} (x : Fix F α), Quot.mk WEquiv (fixToW x) = x",
"ppTerm": "?m.29",
"assigned": true,
"usedConstants": [
"Quot.sound",
"MvQPF.fixToW",
"MvQPF.wSetoid",
"Quot.ind",
"i... | [] | intro α
apply Quot.ind
intro a
apply Quot.sound
apply wrepr_equiv | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Data.QPF.Multivariate.Constructions.Fix | {
"line": 296,
"column": 4
} | {
"line": 300,
"column": 21
} | {
"line": 301,
"column": 2
} | [
{
"pp": "n : ℕ\nF : TypeVec.{u} (n + 1) → Type u\nq : MvQPF F\nα : TypeVec.{u} n\n⊢ ∀ {α : TypeVec.{u} n} (x : Fix F α), Quot.mk WEquiv (fixToW x) = x",
"ppTerm": "?m.29",
"assigned": true,
"usedConstants": [
"Quot.sound",
"MvQPF.fixToW",
"MvQPF.wSetoid",
"Quot.ind",
"i... | [] | intro α
apply Quot.ind
intro a
apply Quot.sound
apply wrepr_equiv | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Data.QPF.Multivariate.Constructions.Fix | {
"line": 321,
"column": 4
} | {
"line": 323,
"column": 15
} | {
"line": 324,
"column": 4
} | [
{
"pp": "n : ℕ\nF : TypeVec.{u} (n + 1) → Type u\nq : MvQPF F\nα : TypeVec.{u} n\nβ : Fix F α → Type u\ng : (x : F (α ::: Sigma β)) → β (mk ((TypeVec.id ::: Sigma.fst) <$$> x))\nx : Fix F α\ny : Sigma β := rec (fun i ↦ ⟨mk ((TypeVec.id ::: Sigma.fst) <$$> i), g i⟩) x\nx' : F (α ::: Fix F α)\nih : (TypeVec.id ::... | [
"n : ℕ\nF : TypeVec.{u} (n + 1) → Type u\nq : MvQPF F\nα : TypeVec.{u} n\nβ : Fix F α → Type u\ng : (x : F (α ::: Sigma β)) → β (mk ((TypeVec.id ::: Sigma.fst) <$$> x))\nx : Fix F α\ny : Sigma β := rec (fun i ↦ ⟨mk ((TypeVec.id ::: Sigma.fst) <$$> i), g i⟩) x\nx' : F (α ::: Fix F α)\nih : (TypeVec.id ::: fun x ↦ (r... | conv =>
rhs
rw [← ih] | Lean.Elab.Tactic.Conv.evalConv | Lean.Parser.Tactic.Conv.conv |
Mathlib.Data.Ordmap.Ordset | {
"line": 616,
"column": 4
} | {
"line": 644,
"column": 28
} | {
"line": 646,
"column": 0
} | [
{
"pp": "case node\nα : Type u_1\ninst✝¹ : Preorder α\ninst✝ : DecidableLE α\nx : α\nsize✝ : ℕ\nt_l : Ordnode α\nt_x : α\nt_r : Ordnode α\nt_ih_l : ∀ {a₁ : WithBot α} {a₂ : WithTop α}, Valid' a₁ t_l a₂ → x ∈ t_l → (erase x t_l).size = t_l.size - 1\nt_ih_r : ∀ {a₁ : WithBot α} {a₂ : WithTop α}, Valid' a₁ t_r a₂ ... | [] | have t_ih_l' := t_ih_l h.left
have t_ih_r' := t_ih_r h.right
clear t_ih_l t_ih_r
dsimp only [Membership.mem, mem] at h_mem
unfold erase
revert h_mem; cases cmpLE x t_x <;> intro h_mem <;> dsimp only at h_mem ⊢
· have t_ih_l := t_ih_l' h_mem
clear t_ih_l' t_ih_r'
have t_l_h := Valid'.... | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Data.Ordmap.Ordset | {
"line": 616,
"column": 4
} | {
"line": 644,
"column": 28
} | {
"line": 646,
"column": 0
} | [
{
"pp": "case node\nα : Type u_1\ninst✝¹ : Preorder α\ninst✝ : DecidableLE α\nx : α\nsize✝ : ℕ\nt_l : Ordnode α\nt_x : α\nt_r : Ordnode α\nt_ih_l : ∀ {a₁ : WithBot α} {a₂ : WithTop α}, Valid' a₁ t_l a₂ → x ∈ t_l → (erase x t_l).size = t_l.size - 1\nt_ih_r : ∀ {a₁ : WithBot α} {a₂ : WithTop α}, Valid' a₁ t_r a₂ ... | [] | have t_ih_l' := t_ih_l h.left
have t_ih_r' := t_ih_r h.right
clear t_ih_l t_ih_r
dsimp only [Membership.mem, mem] at h_mem
unfold erase
revert h_mem; cases cmpLE x t_x <;> intro h_mem <;> dsimp only at h_mem ⊢
· have t_ih_l := t_ih_l' h_mem
clear t_ih_l' t_ih_r'
have t_l_h := Valid'.... | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Data.Rat.Star | {
"line": 40,
"column": 95
} | {
"line": 41,
"column": 66
} | {
"line": 43,
"column": 0
} | [
{
"pp": "⊢ closure (range fun x ↦ x * x) = ⊤",
"ppTerm": "?m.12",
"assigned": true,
"usedConstants": [
"NonAssocSemiring.toAddCommMonoidWithOne",
"Nat.instMulZeroClass",
"AddSubmonoid.instTop",
"HMul.hMul",
"Monoid.toMulOneClass",
"congrArg",
"NNRat.instSemi... | [] | by
simpa only [sq] using addSubmonoid_closure_range_pow two_ne_zero | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Data.Real.Sign | {
"line": 79,
"column": 8
} | {
"line": 79,
"column": 23
} | {
"line": 79,
"column": 24
} | [
{
"pp": "case inr.inr\nr : ℝ\nhp : 0 < r\n⊢ (-r).sign = -r.sign",
"ppTerm": "?inr.inr",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"Real",
"congrArg",
"Real.sign",
"id",
"Real.instOne",
"Real.sign_of_pos",
"Real.instNeg",
"One.toOfNat1",
... | [
"case inr.inr\nr : ℝ\nhp : 0 < r\n⊢ (-r).sign = -1"
] | sign_of_pos hp, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Data.Rat.Star | {
"line": 53,
"column": 4
} | {
"line": 54,
"column": 54
} | {
"line": 55,
"column": 2
} | [
{
"pp": "case e'_2\nn : ℕ\nhn₀ : n ≠ 0\nhn : Even n\n⊢ (range fun x ↦ x ^ n) = ⇑NNRat.coeHom '' range fun x ↦ x ^ n",
"ppTerm": "?e'_2",
"assigned": true,
"usedConstants": [
"RingHom.instRingHomClass",
"IsOrderedRing",
"congrArg",
"CommSemiring.toSemiring",
"and_self",
... | [] | have (x : ℚ) : ∃ y : ℚ≥0, y ^ n = x ^ n := ⟨x.nnabs, by simp [hn.pow_abs]⟩
simp [subset_antisymm_iff, range_subset_iff, this] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Data.Rat.Star | {
"line": 53,
"column": 4
} | {
"line": 54,
"column": 54
} | {
"line": 55,
"column": 2
} | [
{
"pp": "case e'_2\nn : ℕ\nhn₀ : n ≠ 0\nhn : Even n\n⊢ (range fun x ↦ x ^ n) = ⇑NNRat.coeHom '' range fun x ↦ x ^ n",
"ppTerm": "?e'_2",
"assigned": true,
"usedConstants": [
"RingHom.instRingHomClass",
"IsOrderedRing",
"congrArg",
"CommSemiring.toSemiring",
"and_self",
... | [] | have (x : ℚ) : ∃ y : ℚ≥0, y ^ n = x ^ n := ⟨x.nnabs, by simp [hn.pow_abs]⟩
simp [subset_antisymm_iff, range_subset_iff, this] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Data.Real.Sign | {
"line": 86,
"column": 8
} | {
"line": 86,
"column": 23
} | {
"line": 86,
"column": 24
} | [
{
"pp": "case inr.inr\nr : ℝ\nhp : 0 < r\n⊢ 0 ≤ r.sign * r",
"ppTerm": "?inr.inr",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"Real.instLE",
"Real",
"HMul.hMul",
"Real.instZero",
"congrArg",
"Real.sign",
"id",
"LE.le",
"Real.instOne",
... | [
"case inr.inr\nr : ℝ\nhp : 0 < r\n⊢ 0 ≤ 1 * r"
] | sign_of_pos hp, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Data.Real.Sign | {
"line": 109,
"column": 8
} | {
"line": 109,
"column": 23
} | {
"line": 109,
"column": 24
} | [
{
"pp": "case inr.inr\nr : ℝ\nhp : 0 < r\n⊢ r⁻¹.sign = r.sign",
"ppTerm": "?inr.inr",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"Real",
"congrArg",
"Real.instInv",
"Real.sign",
"id",
"Real.instOne",
"Real.sign_of_pos",
"Inv.inv",
"One.... | [
"case inr.inr\nr : ℝ\nhp : 0 < r\n⊢ r⁻¹.sign = 1"
] | sign_of_pos hp, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Data.Set.Enumerate | {
"line": 88,
"column": 4
} | {
"line": 88,
"column": 50
} | {
"line": 89,
"column": 4
} | [
{
"pp": "case succ\nα : Type u_1\nsel : Set α → Option α\na : α\nh_sel : ∀ (s : Set α) (a : α), sel s = some a → a ∈ s\nm k : ℕ\nih : ∀ {s : Set α}, enumerate sel s k = some a → enumerate sel s (k + m) = some a → k = k + m\ns : Set α\nh₁ : enumerate sel s (k + 1) = some a\nh₂ : enumerate sel s (k + 1 + m) = som... | [
"case succ\nα : Type u_1\nsel : Set α → Option α\na : α\nh_sel : ∀ (s : Set α) (a : α), sel s = some a → a ∈ s\nm k : ℕ\nih : ∀ {s : Set α}, enumerate sel s k = some a → enumerate sel s (k + m) = some a → k = k + m\ns : Set α\nh₁ : enumerate sel s (k + 1) = some a\nh₂ : enumerate sel s (k + m + 1) = some a\n⊢ k + 1... | rw [show k + 1 + m = (k + m) + 1 by lia] at h₂ | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.Data.Seq.Parallel | {
"line": 109,
"column": 4
} | {
"line": 109,
"column": 42
} | {
"line": 110,
"column": 4
} | [
{
"pp": "α : Type u\nlem1 :\n ∀ (l : List (Computation α)) (S : WSeq (Computation α)),\n (∃ a, parallel.aux2 l = Sum.inl a) → (corec parallel.aux1 (l, S)).Terminates\nc : Computation α\nT : c.Terminates\ns : Computation α\nIH : ∀ {l : List (Computation α)} {S : WSeq (Computation α)}, s ∈ l → (corec parallel... | [
"case inl\nα : Type u\nlem1 :\n ∀ (l : List (Computation α)) (S : WSeq (Computation α)),\n (∃ a, parallel.aux2 l = Sum.inl a) → (corec parallel.aux1 (l, S)).Terminates\nc : Computation α\nT : c.Terminates\ns : Computation α\nIH : ∀ {l : List (Computation α)} {S : WSeq (Computation α)}, s ∈ l → (corec parallel.a... | rcases h : parallel.aux2 l with a | l' | _private.Lean.Elab.Tactic.RCases.0.Lean.Elab.Tactic.RCases.evalRCases | Lean.Parser.Tactic.rcases |
Mathlib.Data.WSeq.Relation | {
"line": 244,
"column": 16
} | {
"line": 244,
"column": 18
} | {
"line": 245,
"column": 2
} | [
{
"pp": "α : Type u\ns t : WSeq α\nh : s ~ʷ t\no : Option α\n⊢ o ∈ s.head → o ∈ t.head",
"ppTerm": "?m.38",
"assigned": true,
"usedConstants": [
"Membership.mem",
"Computation",
"Computation.instMembership",
"Stream'.WSeq.head",
"Option"
],
"usedFVars": [
... | [
"α : Type u\ns t : WSeq α\nh : s ~ʷ t\no : Option α\nho : o ∈ s.head\n⊢ o ∈ t.head"
] | ho | Lean.Elab.Tactic.evalIntro | ident |
Mathlib.Data.Seq.Parallel | {
"line": 133,
"column": 4
} | {
"line": 133,
"column": 42
} | {
"line": 134,
"column": 4
} | [
{
"pp": "case inr\nα : Type u\nS✝ : WSeq (Computation α)\nc✝ : Computation α\nh : c✝ ∈ S✝\nT✝ : c✝.Terminates\nl : List (Computation α)\nS : Stream'.Seq (Option (Computation α))\nc : Computation α\nT : c.Terminates\na : some (some c) = S.get? 0\nH : S.destruct = some (some c, S.tail)\n⊢ (corec parallel.aux1 (l,... | [
"case inr.inl\nα : Type u\nS✝ : WSeq (Computation α)\nc✝ : Computation α\nh✝ : c✝ ∈ S✝\nT✝ : c✝.Terminates\nl : List (Computation α)\nS : Stream'.Seq (Option (Computation α))\nc : Computation α\nT : c.Terminates\na✝ : some (some c) = S.get? 0\nH : S.destruct = some (some c, S.tail)\na : α\nh : parallel.aux2 l = Sum... | rcases h : parallel.aux2 l with a | l' | _private.Lean.Elab.Tactic.RCases.0.Lean.Elab.Tactic.RCases.evalRCases | Lean.Parser.Tactic.rcases |
Mathlib.Data.Seq.Parallel | {
"line": 151,
"column": 4
} | {
"line": 151,
"column": 42
} | {
"line": 152,
"column": 4
} | [
{
"pp": "case inr\nα : Type u\nS✝ : WSeq (Computation α)\nc✝ : Computation α\nh : c✝ ∈ S✝\nT✝ : c✝.Terminates\nn : ℕ\nIH :\n ∀ (l : List (Computation α)) (S : Stream'.Seq (Option (Computation α))) (c : Computation α),\n c ∈ l ∨ some (some c) = S.get? n → c.Terminates → (corec parallel.aux1 (l, S)).Terminate... | [
"case inr.inl\nα : Type u\nS✝ : WSeq (Computation α)\nc✝ : Computation α\nh✝ : c✝ ∈ S✝\nT✝ : c✝.Terminates\nn : ℕ\nIH :\n ∀ (l : List (Computation α)) (S : Stream'.Seq (Option (Computation α))) (c : Computation α),\n c ∈ l ∨ some (some c) = S.get? n → c.Terminates → (corec parallel.aux1 (l, S)).Terminates\nl : ... | rcases h : parallel.aux2 l with a | l' | _private.Lean.Elab.Tactic.RCases.0.Lean.Elab.Tactic.RCases.evalRCases | Lean.Parser.Tactic.rcases |
Mathlib.Data.Sigma.Order | {
"line": 156,
"column": 8
} | {
"line": 158,
"column": 92
} | {
"line": 158,
"column": 93
} | [
{
"pp": "case refine_2\nι : Type u_1\nα : ι → Type u_2\ninst✝¹ : Preorder ι\ninst✝ : (i : ι) → Preorder (α i)\na b : Σₗ (i : ι), α i\n⊢ a ≤ b ∧ ¬b ≤ a → a < b",
"ppTerm": "?refine_2",
"assigned": true,
"usedConstants": [
"LE.le.lt_of_not_ge",
"Preorder.toLT",
"Sigma.Lex",
"HE... | [] | rintro ⟨⟨a, b, hij⟩ | ⟨a, b, hab⟩, hba⟩
· exact Sigma.Lex.left _ _ hij
· exact Sigma.Lex.right _ _ (hab.lt_of_not_ge fun h => hba <| Sigma.Lex.right _ _ h) | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Data.Sigma.Order | {
"line": 156,
"column": 8
} | {
"line": 158,
"column": 92
} | {
"line": 158,
"column": 93
} | [
{
"pp": "case refine_2\nι : Type u_1\nα : ι → Type u_2\ninst✝¹ : Preorder ι\ninst✝ : (i : ι) → Preorder (α i)\na b : Σₗ (i : ι), α i\n⊢ a ≤ b ∧ ¬b ≤ a → a < b",
"ppTerm": "?refine_2",
"assigned": true,
"usedConstants": [
"LE.le.lt_of_not_ge",
"Preorder.toLT",
"Sigma.Lex",
"HE... | [] | rintro ⟨⟨a, b, hij⟩ | ⟨a, b, hab⟩, hba⟩
· exact Sigma.Lex.left _ _ hij
· exact Sigma.Lex.right _ _ (hab.lt_of_not_ge fun h => hba <| Sigma.Lex.right _ _ h) | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Data.Sigma.Order | {
"line": 226,
"column": 6
} | {
"line": 226,
"column": 46
} | {
"line": 227,
"column": 4
} | [
{
"pp": "case left\nι : Type u_1\nα : ι → Type u_2\ninst✝³ : Preorder ι\ninst✝² : (i : ι) → Preorder (α i)\ninst✝¹ : ∀ (i : ι), DenselyOrdered (α i)\ninst✝ : ∀ (i : ι), NoMinOrder (α i)\ni : ι\na : α i\nj : ι\nb : α j\nh : i < j\nc : α j\nhb : c < b\n⊢ ∃ a_1, ⟨i, a⟩ < a_1 ∧ a_1 < ⟨j, b⟩",
"ppTerm": "?left",... | [] | exact ⟨⟨j, c⟩, left _ _ h, right _ _ hb⟩ | Lean.Elab.Tactic.evalExact | Lean.Parser.Tactic.exact |
Mathlib.Data.WSeq.Basic | {
"line": 625,
"column": 2
} | {
"line": 627,
"column": 78
} | {
"line": 629,
"column": 0
} | [
{
"pp": "α : Type u\nl : List α\n⊢ l ∈ (↑l).toList",
"ppTerm": "?m.6",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"Computation.think",
"Computation.think_mem",
"congrArg",
"Stream'.WSeq.ofList",
"Stream'.WSeq.cons",
"Stream'.WSeq.toList",
"Membersh... | [] | induction l with
| nil => simp
| cons a l IH => simpa [ret_mem] using! think_mem (Computation.mem_map _ IH) | _private.Lean.Elab.Tactic.Induction.0.Lean.Elab.Tactic.evalInduction | Lean.Parser.Tactic.induction |
Mathlib.Data.WSeq.Basic | {
"line": 625,
"column": 2
} | {
"line": 627,
"column": 78
} | {
"line": 629,
"column": 0
} | [
{
"pp": "α : Type u\nl : List α\n⊢ l ∈ (↑l).toList",
"ppTerm": "?m.6",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"Computation.think",
"Computation.think_mem",
"congrArg",
"Stream'.WSeq.ofList",
"Stream'.WSeq.cons",
"Stream'.WSeq.toList",
"Membersh... | [] | induction l with
| nil => simp
| cons a l IH => simpa [ret_mem] using! think_mem (Computation.mem_map _ IH) | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Data.WSeq.Basic | {
"line": 625,
"column": 2
} | {
"line": 627,
"column": 78
} | {
"line": 629,
"column": 0
} | [
{
"pp": "α : Type u\nl : List α\n⊢ l ∈ (↑l).toList",
"ppTerm": "?m.6",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"Computation.think",
"Computation.think_mem",
"congrArg",
"Stream'.WSeq.ofList",
"Stream'.WSeq.cons",
"Stream'.WSeq.toList",
"Membersh... | [] | induction l with
| nil => simp
| cons a l IH => simpa [ret_mem] using! think_mem (Computation.mem_map _ IH) | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Data.Seq.Parallel | {
"line": 228,
"column": 4
} | {
"line": 228,
"column": 40
} | {
"line": 228,
"column": 41
} | [
{
"pp": "case h2.inr\nα : Type u\nS✝ : WSeq (Computation α)\na : α\nh : a ∈ parallel S✝\nF : List (Computation α) → α ⊕ List (Computation α) → Prop :=\n fun l a ↦ Sum.casesOn a (fun a ↦ ∃ c ∈ l, a ∈ c) fun l' ↦ ∀ (a' : α), (∃ c ∈ l', a' ∈ c) → ∃ c ∈ l, a' ∈ c\nlem1 : ∀ (l : List (Computation α)), F l (parallel... | [
"case h2.inr.none\nα : Type u\nS✝ : WSeq (Computation α)\na : α\nh : a ∈ parallel S✝\nF : List (Computation α) → α ⊕ List (Computation α) → Prop :=\n fun l a ↦ Sum.casesOn a (fun a ↦ ∃ c ∈ l, a ∈ c) fun l' ↦ ∀ (a' : α), (∃ c ∈ l', a' ∈ c) → ∃ c ∈ l, a' ∈ c\nlem1 : ∀ (l : List (Computation α)), F l (parallel.aux2 l... | rcases e : Seq.destruct S with - | a | _private.Lean.Elab.Tactic.RCases.0.Lean.Elab.Tactic.RCases.evalRCases | Lean.Parser.Tactic.rcases |
Mathlib.Dynamics.Circle.RotationNumber.TranslationNumber | {
"line": 628,
"column": 2
} | {
"line": 628,
"column": 39
} | {
"line": 629,
"column": 2
} | [
{
"pp": "f g : CircleDeg1Lift\nh : Commute f g\n⊢ Tendsto (fun x ↦ f.transnumAuxSeq x + g.transnumAuxSeq x) atTop (𝓝 (τ (f * g)))",
"ppTerm": "?m.22",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"Real",
"instHDiv",
"HMul.hMul",
"GroupWithZero.toDivInvMonoid",
... | [
"f g : CircleDeg1Lift\nh : Commute f g\n⊢ Tendsto (fun x ↦ ((f ^ 2 ^ x) 0 + (g ^ 2 ^ x) 0) / 2 ^ x) atTop (𝓝 (τ (f * g)))"
] | simp only [transnumAuxSeq, ← add_div] | Lean.Elab.Tactic.evalSimp | Lean.Parser.Tactic.simp |
Mathlib.MeasureTheory.Measure.Decomposition.RadonNikodym | {
"line": 281,
"column": 38
} | {
"line": 281,
"column": 70
} | {
"line": 281,
"column": 70
} | [
{
"pp": "α : Type u_1\nm : MeasurableSpace α\nμ ν : Measure α\ninst✝² : μ.HaveLebesgueDecomposition ν\ninst✝¹ : ν.HaveLebesgueDecomposition μ\ninst✝ : SigmaFinite μ\nhμν : μ ≪ ν\nhνμ : ν ≪ μ\n⊢ μ.withDensity (μ.rnDeriv ν)⁻¹ = ν",
"ppTerm": "?m.116",
"assigned": true,
"usedConstants": [
"Eq.mpr... | [
"α : Type u_1\nm : MeasurableSpace α\nμ ν : Measure α\ninst✝² : μ.HaveLebesgueDecomposition ν\ninst✝¹ : ν.HaveLebesgueDecomposition μ\ninst✝ : SigmaFinite μ\nhμν : μ ≪ ν\nhνμ : ν ≪ μ\n⊢ (ν.withDensity (μ.rnDeriv ν)).withDensity ((ν.withDensity (μ.rnDeriv ν)).rnDeriv ν)⁻¹ = ν"
] | ← withDensity_rnDeriv_eq _ _ hμν | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Dynamics.TopologicalEntropy.NetEntropy | {
"line": 127,
"column": 6
} | {
"line": 127,
"column": 47
} | {
"line": 128,
"column": 6
} | [
{
"pp": "X : Type u_1\nT : X → X\nF : Set X\nU : SetRel X X\nn : ℕ\nh : netMaxcard T F U n < ⊤\nk : ℕ\nk_max : ↑k = netMaxcard T F U n\n⊢ netMaxcard T F U n = sSup (WithTop.some '' Finset.card '' {s | IsDynNetIn T F U n ↑s})",
"ppTerm": "?m.51",
"assigned": true,
"usedConstants": [
"Eq.mpr",
... | [
"X : Type u_1\nT : X → X\nF : Set X\nU : SetRel X X\nn : ℕ\nh : netMaxcard T F U n < ⊤\nk : ℕ\nk_max : ↑k = netMaxcard T F U n\n⊢ ⨆ s, ⨆ (_ : IsDynNetIn T F U n ↑s), ↑s.card = ⨆ a ∈ {s | IsDynNetIn T F U n ↑s}, (WithTop.some ∘ Finset.card) a"
] | rw [netMaxcard, ← image_comp, sSup_image] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.RingTheory.Algebraic.Cardinality | {
"line": 39,
"column": 58
} | {
"line": 39,
"column": 78
} | {
"line": 40,
"column": 10
} | [
{
"pp": "R : Type u\ninst✝⁶ : CommRing R\ninst✝⁵ : IsDomain R\nL : Type v\ninst✝⁴ : CommRing L\ninst✝³ : IsDomain L\ninst✝² : Algebra R L\ninst✝¹ : IsTorsionFree R L\ninst✝ : Algebra.IsAlgebraic R L\nx : L\np : { x_1 // x_1 ≠ 0 ∧ (Polynomial.aeval x) x_1 = 0 } :=\n Classical.indefiniteDescription (fun x_1 ↦ x_... | [
"R : Type u\ninst✝⁶ : CommRing R\ninst✝⁵ : IsDomain R\nL : Type v\ninst✝⁴ : CommRing L\ninst✝³ : IsDomain L\ninst✝² : Algebra R L\ninst✝¹ : IsTorsionFree R L\ninst✝ : Algebra.IsAlgebraic R L\nx : L\np : { x_1 // x_1 ≠ 0 ∧ (Polynomial.aeval x) x_1 = 0 } :=\n Classical.indefiniteDescription (fun x_1 ↦ x_1 ≠ 0 ∧ (Pol... | Polynomial.eval_map, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.ModelTheory.Basic | {
"line": 337,
"column": 18
} | {
"line": 337,
"column": 30
} | {
"line": 339,
"column": 2
} | [
{
"pp": "L : Language\nL' : Language\nM : Type w\nN : Type w'\ninst✝³ : L.Structure M\ninst✝² : L.Structure N\nP : Type u_1\ninst✝¹ : L.Structure P\nQ : Type u_2\ninst✝ : L.Structure Q\nhnp : N →[L] P\nhmn : M →[L] N\nn✝ : ℕ\nx✝¹ : L.Functions n✝\nx✝ : Fin n✝ → M\n⊢ (⇑hnp ∘ ⇑hmn) (funMap x✝¹ x✝) = funMap x✝¹ ((... | [] | by simp; rfl | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.ModelTheory.Basic | {
"line": 464,
"column": 50
} | {
"line": 464,
"column": 58
} | {
"line": 464,
"column": 59
} | [
{
"pp": "L : Language\nL' : Language\nM : Type w\nN : Type w'\ninst✝³ : L.Structure M\ninst✝² : L.Structure N\nP : Type u_1\ninst✝¹ : L.Structure P\nQ : Type u_2\ninst✝ : L.Structure Q\nhnp : N ↪[L] P\nhmn : M ↪[L] N\nn✝ : ℕ\nr✝ : L.Relations n✝\nx✝ : Fin n✝ → M\n⊢ RelMap r✝ (⇑hnp ∘ ⇑hmn ∘ x✝) ↔ RelMap r✝ x✝",
... | [
"L : Language\nL' : Language\nM : Type w\nN : Type w'\ninst✝³ : L.Structure M\ninst✝² : L.Structure N\nP : Type u_1\ninst✝¹ : L.Structure P\nQ : Type u_2\ninst✝ : L.Structure Q\nhnp : N ↪[L] P\nhmn : M ↪[L] N\nn✝ : ℕ\nr✝ : L.Relations n✝\nx✝ : Fin n✝ → M\n⊢ RelMap r✝ (⇑hmn ∘ x✝) ↔ RelMap r✝ x✝"
] | map_rel, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.ModelTheory.Basic | {
"line": 638,
"column": 52
} | {
"line": 638,
"column": 60
} | {
"line": 638,
"column": 61
} | [
{
"pp": "L : Language\nL' : Language\nM : Type w\nN : Type w'\ninst✝³ : L.Structure M\ninst✝² : L.Structure N\nP : Type u_1\ninst✝¹ : L.Structure P\nQ : Type u_2\ninst✝ : L.Structure Q\nhnp : N ≃[L] P\nhmn : M ≃[L] N\nn✝ : ℕ\nr✝ : L.Relations n✝\nx✝ : Fin n✝ → M\n⊢ RelMap r✝ (⇑hnp ∘ ⇑hmn ∘ x✝) ↔ RelMap r✝ x✝",
... | [
"L : Language\nL' : Language\nM : Type w\nN : Type w'\ninst✝³ : L.Structure M\ninst✝² : L.Structure N\nP : Type u_1\ninst✝¹ : L.Structure P\nQ : Type u_2\ninst✝ : L.Structure Q\nhnp : N ≃[L] P\nhmn : M ≃[L] N\nn✝ : ℕ\nr✝ : L.Relations n✝\nx✝ : Fin n✝ → M\n⊢ RelMap r✝ (⇑hmn ∘ x✝) ↔ RelMap r✝ x✝"
] | map_rel, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.ModelTheory.Encoding | {
"line": 126,
"column": 2
} | {
"line": 141,
"column": 41
} | {
"line": 143,
"column": 0
} | [
{
"pp": "case refine_2\nL : Language\nα : Type u'\n⊢ max ℵ₀ #(α ⊕ (i : ℕ) × L.Functions i) ≤ #((n : ℕ) × L.Term (α ⊕ Fin n))",
"ppTerm": "?refine_2",
"assigned": true,
"usedConstants": [
"Iff.mpr",
"Eq.mpr",
"Infinite.of_injective",
"False",
"Lattice.toSemilatticeSup",
... | [] | · rw [max_le_iff, ← infinite_iff]
refine ⟨Infinite.of_injective
(fun i => ⟨i + 1, var (Sum.inr (last i))⟩) fun i j ij => ?_, ?_⟩
· cases ij
rfl
· rw [Cardinal.le_def]
refine ⟨⟨Sum.elim (fun i => ⟨0, var (Sum.inl i)⟩)
fun F => ⟨1, func F.2 fun _ => var (Sum.inr 0)⟩, ?_⟩⟩
rin... | Lean.Elab.Tactic.evalTacticCDot | Lean.cdot |
Mathlib.ModelTheory.Definability | {
"line": 562,
"column": 2
} | {
"line": 564,
"column": 48
} | {
"line": 566,
"column": 0
} | [
{
"pp": "M : Type u_1\nL : Language\ninst✝ : L.Structure M\nα : Type u_2\nA : Set M\nf g : (α → M) → M\nhf : DefinableFun L A f\nhg : DefinableFun L A g\n⊢ A.Definable L {v | f v = g v}",
"ppTerm": "?m.12",
"assigned": true,
"usedConstants": [
"Set.Definable₂._proof_1",
"congrArg",
... | [] | have hF : A.DefinableMap L (fun v => ![f v, g v]) := by
simp [DefinableMap, *]
exact (Definable.diagonal L A).preimage_map hF | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.ModelTheory.Definability | {
"line": 562,
"column": 2
} | {
"line": 564,
"column": 48
} | {
"line": 566,
"column": 0
} | [
{
"pp": "M : Type u_1\nL : Language\ninst✝ : L.Structure M\nα : Type u_2\nA : Set M\nf g : (α → M) → M\nhf : DefinableFun L A f\nhg : DefinableFun L A g\n⊢ A.Definable L {v | f v = g v}",
"ppTerm": "?m.12",
"assigned": true,
"usedConstants": [
"Set.Definable₂._proof_1",
"congrArg",
... | [] | have hF : A.DefinableMap L (fun v => ![f v, g v]) := by
simp [DefinableMap, *]
exact (Definable.diagonal L A).preimage_map hF | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.ModelTheory.Algebra.Field.IsAlgClosed | {
"line": 136,
"column": 4
} | {
"line": 138,
"column": 32
} | {
"line": 140,
"column": 0
} | [
{
"pp": "case inr\np : ℕ\nhp : p = 0\n⊢ (Theory.ACF p).IsSatisfiable",
"ppTerm": "?inr",
"assigned": true,
"usedConstants": [
"FirstOrder.Ring.compatibleRingOfRing",
"NegZeroClass.toNeg",
"FirstOrder.Language.ring",
"FirstOrder.Language.Theory.ModelType",
"AlgebraicClos... | [] | subst hp
let _ := compatibleRingOfRing (AlgebraicClosure ℚ)
exact ⟨⟨AlgebraicClosure ℚ⟩⟩ | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.ModelTheory.Algebra.Field.IsAlgClosed | {
"line": 136,
"column": 4
} | {
"line": 138,
"column": 32
} | {
"line": 140,
"column": 0
} | [
{
"pp": "case inr\np : ℕ\nhp : p = 0\n⊢ (Theory.ACF p).IsSatisfiable",
"ppTerm": "?inr",
"assigned": true,
"usedConstants": [
"FirstOrder.Ring.compatibleRingOfRing",
"NegZeroClass.toNeg",
"FirstOrder.Language.ring",
"FirstOrder.Language.Theory.ModelType",
"AlgebraicClos... | [] | subst hp
let _ := compatibleRingOfRing (AlgebraicClosure ℚ)
exact ⟨⟨AlgebraicClosure ℚ⟩⟩ | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.ModelTheory.Satisfiability | {
"line": 400,
"column": 4
} | {
"line": 403,
"column": 29
} | {
"line": 405,
"column": 0
} | [
{
"pp": "case inr\nL : Language\nT : L.Theory\nh : T.IsComplete\nφ : L.Sentence\nhφn : T ⊨ᵇ Formula.not φ\n⊢ T ⊨ᵇ Formula.not φ ↔ ¬T ⊨ᵇ φ",
"ppTerm": "?inr",
"assigned": true,
"usedConstants": [
"FirstOrder.Language.Sentence.Realize",
"Eq.mpr",
"FirstOrder.Language.Theory.ModelType... | [] | simp only [hφn, true_iff]
intro hφ
rw [models_sentence_iff] at *
exact hφn h.1.some (hφ _) | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.ModelTheory.Satisfiability | {
"line": 400,
"column": 4
} | {
"line": 403,
"column": 29
} | {
"line": 405,
"column": 0
} | [
{
"pp": "case inr\nL : Language\nT : L.Theory\nh : T.IsComplete\nφ : L.Sentence\nhφn : T ⊨ᵇ Formula.not φ\n⊢ T ⊨ᵇ Formula.not φ ↔ ¬T ⊨ᵇ φ",
"ppTerm": "?inr",
"assigned": true,
"usedConstants": [
"FirstOrder.Language.Sentence.Realize",
"Eq.mpr",
"FirstOrder.Language.Theory.ModelType... | [] | simp only [hφn, true_iff]
intro hφ
rw [models_sentence_iff] at *
exact hφn h.1.some (hφ _) | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.