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.Computability.AkraBazzi.GrowsPolynomially | {
"line": 571,
"column": 6
} | {
"line": 573,
"column": 85
} | [
{
"pp": "case lb\nf : ℝ → ℝ\np : ℝ\nhf : GrowsPolynomially f\nhf_nonneg : ∀ᶠ (x : ℝ) in atTop, 0 ≤ f x\nb : ℝ\nhb : b ∈ Set.Ioo 0 1\nc₁ : ℝ\nhc₁_mem : 0 < c₁\nc₂ : ℝ\nhc₂_mem : c₂ > 0\nhfnew : ∀ᶠ (x : ℝ) in atTop, ∀ u ∈ Set.Icc (b * x) x, f u ∈ Set.Icc (c₁ * f x) (c₂ * f x)\nhc₁p : 0 < c₁ ^ p\nhc₂p : 0 < c₂ ^ p... | case lb => calc
c₂ ^ p * (f x) ^ p = (c₂ * f x) ^ p := by rw [mul_rpow (le_of_lt hc₂_mem) (le_of_lt hf_pos)]
_ ≤ _ := rpow_le_rpow_of_nonpos (hf_pos₂ u hu.1) (hf₁ u hu).2 (le_of_lt hp) | Lean.Elab.Tactic.evalCase | Lean.Parser.Tactic.case |
Mathlib.Computability.DFA | {
"line": 212,
"column": 2
} | {
"line": 212,
"column": 30
} | [
{
"pp": "case append_singleton\nα : Type u\nσ : Type v\nM : DFA α σ\nα' : Type u_1\nf : α' → α\ns : σ\nx : List α'\na : α'\nih : (comap f M).evalFrom s x = M.evalFrom s (List.map f x)\n⊢ (comap f M).evalFrom s (x ++ [a]) = M.evalFrom s (List.map f (x ++ [a]))",
"usedConstants": [
"congrArg",
"Li... | | append_singleton x a ih => | _private.Lean.Elab.Tactic.Induction.0.Lean.Elab.Tactic.evalInduction | null |
Mathlib.Computability.DFA | {
"line": 254,
"column": 2
} | {
"line": 254,
"column": 30
} | [
{
"pp": "case append_singleton\nα : Type u\nσ : Type v\nM : DFA α σ\nσ' : Type u_2\ng : σ ≃ σ'\ns : σ'\nx : List α\na : α\nih : ((reindex g) M).evalFrom s x = g (M.evalFrom (g.symm s) x)\n⊢ ((reindex g) M).evalFrom s (x ++ [a]) = g (M.evalFrom (g.symm s) (x ++ [a]))",
"usedConstants": [
"Equiv.instEqu... | | append_singleton x a ih => | _private.Lean.Elab.Tactic.Induction.0.Lean.Elab.Tactic.evalInduction | null |
Mathlib.Computability.AkraBazzi.AkraBazzi | {
"line": 660,
"column": 6
} | {
"line": 660,
"column": 91
} | [
{
"pp": "α : Type u_1\ninst✝¹ : Fintype α\nT : ℕ → ℝ\ng : ℝ → ℝ\na b : α → ℝ\nr : α → ℕ → ℕ\ninst✝ : Nonempty α\nR : AkraBazziRecurrence T g a b r\n⊢ (fun n ↦ (1 - ε ↑n) * asympBound g a b n) =O[atTop] fun n ↦ 1 * asympBound g a b n",
"usedConstants": [
"AkraBazziRecurrence.asympBound",
"NormedC... | refine IsBigO.mul (isBigO_const_of_tendsto (y := 1) ?_ one_ne_zero) (isBigO_refl _ _) | Lean.Elab.Tactic.evalRefine | Lean.Parser.Tactic.refine |
Mathlib.Data.Nat.Bitwise | {
"line": 339,
"column": 82
} | {
"line": 339,
"column": 96
} | [
{
"pp": "case succ\nn : ℕ\nih :\n List.foldl (fun x1 x2 ↦ x1 ^^^ x2) 0 (List.range (n + 1)) =\n match Fin.ofNat 4 n with\n | 0 => n\n | 1 => 1\n | 2 => n + 1\n | 3 => 0\n⊢ List.foldl (fun x1 x2 ↦ x1 ^^^ x2)\n ((match Fin.ofNat 4 n with\n | 0 => n\n | 1 => 1\n | 2 => n +... | List.foldl_nil | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Computability.NFA | {
"line": 238,
"column": 4
} | {
"line": 238,
"column": 16
} | [
{
"pp": "case cons\nα : Type u\nσ : Type v\nM : NFA α σ\np : Prop\na : α\nx : List α\nih : ∀ {S : Set σ}, x ∈ M.acceptsFrom {s | s ∈ S ∧ p} ↔ x ∈ M.acceptsFrom S ∧ p\nS : Set σ\nh : M.stepSet {s | s ∈ S ∧ p} a = {s | s ∈ M.stepSet S a ∧ p}\n⊢ a :: x ∈ M.acceptsFrom {s | s ∈ S ∧ p} ↔ a :: x ∈ M.acceptsFrom S ∧ p... | simp [h, ih] | Lean.Elab.Tactic.evalSimp | Lean.Parser.Tactic.simp |
Mathlib.Computability.EpsilonNFA | {
"line": 115,
"column": 52
} | {
"line": 115,
"column": 66
} | [
{
"pp": "α : Type u\nσ : Type v\nM : εNFA α σ\nS : Set σ\nx : List α\na : α\n⊢ List.foldl M.stepSet (M.stepSet (List.foldl M.stepSet (M.εClosure S) x) a) [] =\n M.stepSet (List.foldl M.stepSet (M.εClosure S) x) a",
"usedConstants": [
"Eq.mpr",
"congrArg",
"εNFA.stepSet",
"id",
... | List.foldl_nil | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Computability.EpsilonNFA | {
"line": 121,
"column": 2
} | {
"line": 121,
"column": 30
} | [
{
"pp": "case append_singleton\nα : Type u\nσ : Type v\nM : εNFA α σ\nx : List α\na : α\nih : M.evalFrom ∅ x = ∅\n⊢ M.evalFrom ∅ (x ++ [a]) = ∅",
"usedConstants": [
"Eq.mpr",
"congrArg",
"εNFA.stepSet",
"id",
"εNFA.evalFrom_append_singleton",
"List.cons",
"instHAppe... | | append_singleton x a ih => | _private.Lean.Elab.Tactic.Induction.0.Lean.Elab.Tactic.evalInduction | null |
Mathlib.Computability.EpsilonNFA | {
"line": 225,
"column": 6
} | {
"line": 225,
"column": 28
} | [
{
"pp": "case nil.mpr\nα : Type u\nσ : Type v\nM : εNFA α σ\ns₁ s₂ : σ\n⊢ (∃ x', (∃ n, x' = List.replicate n none) ∧ M.IsPath s₁ s₂ x') → ∃ n, M.IsPath s₁ s₂ (List.replicate n none)",
"usedConstants": [
"List.replicate",
"Exists",
"Option.none",
"List",
"And",
"Nat",
... | intro ⟨_, ⟨n, rfl⟩, h⟩ | Lean.Elab.Tactic.evalIntro | null |
Mathlib.Computability.EpsilonNFA | {
"line": 225,
"column": 6
} | {
"line": 225,
"column": 28
} | [
{
"pp": "case nil.mpr\nα : Type u\nσ : Type v\nM : εNFA α σ\ns₁ s₂ : σ\n⊢ (∃ x', (∃ n, x' = List.replicate n none) ∧ M.IsPath s₁ s₂ x') → ∃ n, M.IsPath s₁ s₂ (List.replicate n none)",
"usedConstants": [
"List.replicate",
"Exists",
"Option.none",
"List",
"And",
"Nat",
... | intro ⟨_, ⟨n, rfl⟩, h⟩ | Lean.Elab.Tactic.evalIntro | Lean.Parser.Tactic.intro |
Mathlib.Computability.MyhillNerode | {
"line": 95,
"column": 2
} | {
"line": 95,
"column": 30
} | [
{
"pp": "case h.append_singleton\nα : Type u\nL : Language α\nx : List α\na : α\nih : ↑(L.toDFA.eval x) = L.leftQuotient x\n⊢ ↑(L.toDFA.eval (x ++ [a])) = L.leftQuotient (x ++ [a])",
"usedConstants": [
"Language.leftQuotient_append",
"congrArg",
"Membership.mem",
"Language.toDFA",
... | | append_singleton x a ih => | _private.Lean.Elab.Tactic.Induction.0.Lean.Elab.Tactic.evalInduction | null |
Mathlib.Computability.EpsilonNFA | {
"line": 227,
"column": 2
} | {
"line": 227,
"column": 30
} | [
{
"pp": "case append_singleton\nα : Type u\nσ : Type v\nM : εNFA α σ\ns₁ : σ\nx : List α\na : α\nih : ∀ {s₂ : σ}, s₂ ∈ M.evalFrom {s₁} x ↔ ∃ x', x'.reduceOption = x ∧ M.IsPath s₁ s₂ x'\ns₂ : σ\n⊢ s₂ ∈ M.evalFrom {s₁} (x ++ [a]) ↔ ∃ x', x'.reduceOption = x ++ [a] ∧ M.IsPath s₁ s₂ x'",
"usedConstants": [
... | | append_singleton x a ih => | _private.Lean.Elab.Tactic.Induction.0.Lean.Elab.Tactic.evalInduction | null |
Mathlib.Computability.RE | {
"line": 243,
"column": 12
} | {
"line": 243,
"column": 44
} | [
{
"pp": "α : Type u_1\ninst✝ : Primcodable α\np : α → Prop\n⊢ ComputablePred p ↔ REPred p ∧ REPred fun a ↦ ¬p a",
"usedConstants": [
"Classical.propDecidable",
"ComputablePred.computable_iff_re_compl_re"
]
}
] | exact computable_iff_re_compl_re | Lean.Elab.Tactic.evalExact | Lean.Parser.Tactic.exact |
Mathlib.Computability.RE | {
"line": 243,
"column": 12
} | {
"line": 243,
"column": 44
} | [
{
"pp": "α : Type u_1\ninst✝ : Primcodable α\np : α → Prop\n⊢ ComputablePred p ↔ REPred p ∧ REPred fun a ↦ ¬p a",
"usedConstants": [
"Classical.propDecidable",
"ComputablePred.computable_iff_re_compl_re"
]
}
] | exact computable_iff_re_compl_re | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Computability.RE | {
"line": 243,
"column": 12
} | {
"line": 243,
"column": 44
} | [
{
"pp": "α : Type u_1\ninst✝ : Primcodable α\np : α → Prop\n⊢ ComputablePred p ↔ REPred p ∧ REPred fun a ↦ ¬p a",
"usedConstants": [
"Classical.propDecidable",
"ComputablePred.computable_iff_re_compl_re"
]
}
] | exact computable_iff_re_compl_re | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Data.Num.Lemmas | {
"line": 777,
"column": 4
} | {
"line": 778,
"column": 22
} | [
{
"pp": "case pos.pos\nf : Num → Num → Num\ng : Bool → Bool → Bool\np : PosNum → PosNum → Num\ngff : g false false = false\nf00 : f 0 0 = 0\nf0n : ∀ (n : PosNum), f 0 (pos n) = bif g false true then pos n else 0\nfn0 : ∀ (n : PosNum), f (pos n) 0 = bif g true false then pos n else 0\nfnn : ∀ (m n : PosNum), f (... | have this' b (n : PosNum) : ↑(pos (PosNum.bit b n)) = Nat.bit b ↑n := by
cases b <;> simp | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_tacticHave___1 | Lean.Parser.Tactic.tacticHave__ |
Mathlib.Computability.TuringMachine.PostTuringMachine | {
"line": 578,
"column": 4
} | {
"line": 578,
"column": 17
} | [
{
"pp": "case right.some.some.move\nΓ : Type u_1\nΛ : Type u_2\ninst✝² : Inhabited Λ\nσ : Type u_3\ninst✝¹ : Inhabited σ\nM : Λ → TM1.Stmt Γ Λ σ\ninst✝ : Fintype σ\nS : Finset Λ\nss : TM1.Supports M S\na : Γ\ns : TM0.Stmt Γ\nv' : σ\nval✝ : TM1.Stmt Γ Λ σ\nd : Dir\nq : TM1.Stmt Γ Λ σ\na_ih✝ :\n ∀ (v : σ),\n ... | | move d q => | _private.Lean.Elab.Tactic.Induction.0.Lean.Elab.Tactic.evalInduction | null |
Mathlib.Computability.TuringMachine.PostTuringMachine | {
"line": 637,
"column": 2
} | {
"line": 644,
"column": 91
} | [
{
"pp": "Γ : Type u_1\ninst✝¹ : Inhabited Γ\ninst✝ : Finite Γ\n⊢ ∃ n enc dec, enc default = List.Vector.replicate n false ∧ ∀ (a : Γ), dec (enc a) = a",
"usedConstants": [
"Function.invFun",
"Inhabited.default",
"Function.Embedding.setValue_eq",
"Equiv.vectorEquivFin",
"instDec... | rcases Finite.exists_equiv_fin Γ with ⟨n, ⟨e⟩⟩
letI : DecidableEq Γ := e.decidableEq
let G : Fin n ↪ Fin n → Bool :=
⟨fun a b ↦ a = b, fun a b h ↦
Bool.of_decide_true <| (congr_fun h b).trans <| Bool.decide_true rfl⟩
let H := (e.toEmbedding.trans G).trans (Equiv.vectorEquivFin _ _).symm.toEmbedding
le... | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Computability.TuringMachine.PostTuringMachine | {
"line": 637,
"column": 2
} | {
"line": 644,
"column": 91
} | [
{
"pp": "Γ : Type u_1\ninst✝¹ : Inhabited Γ\ninst✝ : Finite Γ\n⊢ ∃ n enc dec, enc default = List.Vector.replicate n false ∧ ∀ (a : Γ), dec (enc a) = a",
"usedConstants": [
"Function.invFun",
"Inhabited.default",
"Function.Embedding.setValue_eq",
"Equiv.vectorEquivFin",
"instDec... | rcases Finite.exists_equiv_fin Γ with ⟨n, ⟨e⟩⟩
letI : DecidableEq Γ := e.decidableEq
let G : Fin n ↪ Fin n → Bool :=
⟨fun a b ↦ a = b, fun a b h ↦
Bool.of_decide_true <| (congr_fun h b).trans <| Bool.decide_true rfl⟩
let H := (e.toEmbedding.trans G).trans (Equiv.vectorEquivFin _ _).symm.toEmbedding
le... | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Computability.RegularExpressions | {
"line": 199,
"column": 6
} | {
"line": 199,
"column": 66
} | [
{
"pp": "case cons.cons.isFalse\nα : Type u_1\ninst✝ : DecidableEq α\na head✝ head : α\ntail : List α\nh✝ : ¬a = head✝\n⊢ (deriv 0 head).rmatch tail = true ↔ head✝ = a ∧ head :: tail = []",
"usedConstants": [
"Eq.mpr",
"False",
"RegularExpression.rmatch",
"congrArg",
"RegularEx... | · simp_rw [deriv_zero, zero_rmatch, reduceCtorEq, and_false] | Lean.Elab.Tactic.evalTacticCDot | Lean.cdot |
Mathlib.Computability.TuringMachine.PostTuringMachine | {
"line": 816,
"column": 34
} | {
"line": 816,
"column": 41
} | [
{
"pp": "Γ : Type u_1\nΛ : Type u_2\nσ : Type u_3\nn : ℕ\nenc : Γ → List.Vector Bool n\ndec : List.Vector Bool n → Γ\ninst✝ : Inhabited Γ\nenc0 : enc default = List.Vector.replicate n false\nencdec : ∀ (a : Γ), dec (enc a) = a\nf : Γ → Stmt Bool (Λ' Γ Λ σ) σ\nv : σ\nL R : ListBlank Γ\nthis :\n ∀ (f : List.Vect... | encdec, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Data.Num.Lemmas | {
"line": 860,
"column": 10
} | {
"line": 860,
"column": 27
} | [
{
"pp": "case pos.zero.bit1\nm : PosNum\n⊢ true = (↑m.bit1).testBit 0",
"usedConstants": [
"Eq.mpr",
"castPosNum",
"PosNum.cast_bit1",
"Nat.instOne",
"congrArg",
"PosNum.bit1",
"id",
"instOfNatNat",
"Bool.true",
"instHAdd",
"HAdd.hAdd",
... | PosNum.cast_bit1, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Data.Num.Lemmas | {
"line": 864,
"column": 10
} | {
"line": 864,
"column": 27
} | [
{
"pp": "n : ℕ\nIH : ∀ (m : PosNum), m.testBit n = (↑m).testBit n\nm : PosNum\n⊢ m.testBit n = (↑m.bit1).testBit (n + 1)",
"usedConstants": [
"Eq.mpr",
"castPosNum",
"PosNum.cast_bit1",
"Nat.instOne",
"congrArg",
"PosNum.bit1",
"id",
"instOfNatNat",
"ins... | PosNum.cast_bit1, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Computability.TuringMachine.StackTuringMachine | {
"line": 559,
"column": 12
} | {
"line": 559,
"column": 35
} | [
{
"pp": "case pos\nK : Type u_1\nΓ : K → Type u_2\nΛ : Type u_3\nσ : Type u_4\ninst✝ : DecidableEq K\nk : K\nq : TM1.Stmt (Γ' K Γ) (Λ' K Γ Λ σ) σ\nv : σ\nS : (k : K) → List (Γ k)\nL : ListBlank ((k : K) → Option (Γ k))\nhL : ∀ (k : K), ListBlank.map (proj k) L = ListBlank.mk (List.map some (S k)).reverse\nf : σ... | List.getI_eq_getElem _, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Computability.TuringMachine.Config | {
"line": 633,
"column": 16
} | {
"line": 633,
"column": 26
} | [
{
"pp": "case neg\nf : Code\nk : Cont\nv✝ : List ℕ\nfok : f.Ok\nx c : Cfg\nhe✝ : x ∈ eval step c\nv v' : List ℕ\nIH :\n ∀ (a' : Cfg),\n step (stepRet (Cont.fix f k) v') = some a' →\n ∀ (v : List ℕ) (c' : Cfg),\n a' = c'.then (Cont.fix f k) →\n Reaches step (stepNormal f Cont.halt v) c' ... | Cont.then, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Computability.TuringMachine.StackTuringMachine | {
"line": 580,
"column": 2
} | {
"line": 580,
"column": 12
} | [
{
"pp": "case pop\nK : Type u_1\nΓ : K → Type u_2\nΛ : Type u_3\nσ : Type u_4\ninst✝ : DecidableEq K\nk : K\nq : TM1.Stmt (Γ' K Γ) (Λ' K Γ Λ σ) σ\nv : σ\nS : (k : K) → List (Γ k)\nL : ListBlank ((k : K) → Option (Γ k))\nhL : ∀ (k : K), ListBlank.map (proj k) L = ListBlank.mk (List.map some (S k)).reverse\nf : σ... | | pop f => | _private.Lean.Elab.Tactic.Induction.0.Lean.Elab.Tactic.evalCases | null |
Mathlib.Computability.TuringMachine.StackTuringMachine | {
"line": 767,
"column": 6
} | {
"line": 767,
"column": 28
} | [
{
"pp": "case refine_1\nK : Type u_1\nΓ : K → Type u_2\nΛ : Type u_3\nσ : Type u_4\ninst✝¹ : DecidableEq K\nM : Λ → TM2.Stmt Γ Λ σ\ninst✝ : Inhabited Λ\nS : Finset Λ\nss : TM2.Supports M S\n⊢ ∀ (k : K) (s : StAct K Γ σ k) (q : TM2.Stmt Γ Λ σ),\n (TM2.SupportsStmt S q →\n (∀ x ∈ trStmts₁ q, x ∈ trSupp ... | intro _ s _ IH ss' sub | Lean.Elab.Tactic.evalIntro | Lean.Parser.Tactic.intro |
Mathlib.Topology.Category.Profinite.Basic | {
"line": 258,
"column": 2
} | {
"line": 259,
"column": 43
} | [
{
"pp": "case mpr\nX Y : Profinite\nf : X ⟶ Y\n⊢ Function.Surjective ⇑(ConcreteCategory.hom f) → Epi f",
"usedConstants": [
"Eq.mpr",
"CategoryTheory.instFaithfulForget",
"CategoryTheory.Epi",
"congrArg",
"CategoryTheory.ConcreteCategory.hom",
"ContinuousMap",
"Type... | · rw [← CategoryTheory.ofHom_epi_iff_surjective]
apply (forget Profinite).epi_of_epi_map | Lean.Elab.Tactic.evalTacticCDot | Lean.cdot |
Mathlib.Topology.ExtremallyDisconnected | {
"line": 152,
"column": 13
} | {
"line": 152,
"column": 19
} | [
{
"pp": "A D : Type u\ninst✝³ : TopologicalSpace A\ninst✝² : TopologicalSpace D\ninst✝¹ : T1Space A\ninst✝ : CompactSpace D\nX : D → A\nX_cont : Continuous X\nX_surj : Surjective X\nS : Set (Set D) := {E | IsClosed E ∧ X '' E = univ}\nthis : ∀ C ⊆ S, IsChain (fun x1 x2 ↦ x1 ⊆ x2) C → ∃ s ∈ S, ∀ c ∈ C, s ⊆ c\nE ... | E₀_min | Lean.Elab.Tactic.evalIntro | ident |
Mathlib.Topology.Category.CompHaus.Projective | {
"line": 51,
"column": 4
} | {
"line": 53,
"column": 9
} | [
{
"pp": "case h.h\nX : Type u_1\nY Z : CompHaus\nf : of (Ultrafilter X) ⟶ Z\ng : Y ⟶ Z\nhg : Surjective ⇑(ConcreteCategory.hom g)\ng' : (fun X ↦ ↑X.toTop) Z → (fun X ↦ ↑X.toTop) Y\nhg' : RightInverse g' ⇑(ConcreteCategory.hom g)\nt : X → ↑Y.toTop := g' ∘ ⇑(ConcreteCategory.hom f) ∘ pure\nh : Ultrafilter X → ↑Y.... | convert!
denseRange_pure.equalizer (g.hom.hom.continuous.comp hh) f.hom.hom.continuous
_ | Mathlib.Tactic._aux_Mathlib_Tactic_Convert___macroRules_Mathlib_Tactic_convert!_1 | Mathlib.Tactic.convert! |
Mathlib.Topology.Category.Stonean.Basic | {
"line": 169,
"column": 4
} | {
"line": 177,
"column": 29
} | [
{
"pp": "X : Stonean\n⊢ ∀ {E X_1 : Profinite} (f : toProfinite.obj X ⟶ X_1) (e : E ⟶ X_1) [Epi e], ∃ f', f' ≫ e = f",
"usedConstants": [
"ContinuousMap.continuous",
"Eq.mpr",
"Stonean.instExtremallyDisconnectedCarrierToTop",
"CompHausLike.ofHom",
"Continuous",
"CategoryTh... | intro B C φ f _
haveI : ExtremallyDisconnected (toProfinite.obj X) := X.prop
have hf : Function.Surjective f := by rwa [← Profinite.epi_iff_surjective]
obtain ⟨f', h⟩ := CompactT2.ExtremallyDisconnected.projective φ.hom.hom.continuous
f.hom.hom.continuous
hf
use ofHom _ ⟨f', h.left⟩
ext
... | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Topology.Category.Stonean.Basic | {
"line": 169,
"column": 4
} | {
"line": 177,
"column": 29
} | [
{
"pp": "X : Stonean\n⊢ ∀ {E X_1 : Profinite} (f : toProfinite.obj X ⟶ X_1) (e : E ⟶ X_1) [Epi e], ∃ f', f' ≫ e = f",
"usedConstants": [
"ContinuousMap.continuous",
"Eq.mpr",
"Stonean.instExtremallyDisconnectedCarrierToTop",
"CompHausLike.ofHom",
"Continuous",
"CategoryTh... | intro B C φ f _
haveI : ExtremallyDisconnected (toProfinite.obj X) := X.prop
have hf : Function.Surjective f := by rwa [← Profinite.epi_iff_surjective]
obtain ⟨f', h⟩ := CompactT2.ExtremallyDisconnected.projective φ.hom.hom.continuous
f.hom.hom.continuous
hf
use ofHom _ ⟨f', h.left⟩
ext
... | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Computability.TuringMachine.ToPartrec | {
"line": 1259,
"column": 4
} | {
"line": 1259,
"column": 84
} | [
{
"pp": "case cons₁\nS : Finset Λ'\nf : Code\nk : Cont'\nIH : contSupp k ⊆ S → Supports (contSupp k) S\nH : contSupp (Cont'.cons₁ f k) ⊆ S\nH₁ :\n trStmts₁\n (move₂ (fun x ↦ false) main aux\n (move₂ (fun s ↦ decide (s = Γ'.consₗ)) stack main (move₂ (fun x ↦ false) aux stack (trNormal f k.cons₂)... | exact trStmts₁_supports' (head_supports H₂.2.2) (Finset.union_subset_right h) IH | Lean.Elab.Tactic.evalExact | Lean.Parser.Tactic.exact |
Mathlib.Topology.Category.LightProfinite.Basic | {
"line": 202,
"column": 37
} | {
"line": 235,
"column": 48
} | [
{
"pp": "X Y : LightProfinite\nf : X ⟶ Y\n⊢ Epi f ↔ Function.Surjective ⇑(ConcreteCategory.hom f)",
"usedConstants": [
"ULift.topologicalSpace",
"Mathlib.Tactic.Push.not_forall_eq",
"Filter.instMembership",
"Mathlib.Tactic.Push.not_exists._simp_1",
"ContinuousMap.continuous",
... | by
constructor
· -- Note: in mathlib3 `contrapose` saw through `Function.Surjective`.
dsimp [Function.Surjective]
contrapose!
rintro ⟨y, hy⟩ hf
let C := Set.range f
have hC : IsClosed C := (isCompact_range f.hom.hom.continuous).isClosed
let U := Cᶜ
have hyU : y ∈ U := by
refine Set... | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Topology.Category.Profinite.CofilteredLimit | {
"line": 216,
"column": 4
} | {
"line": 216,
"column": 73
} | [
{
"pp": "case inr\nJ : Type v\ninst✝¹ : SmallCategory J\ninst✝ : IsCofiltered J\nF : J ⥤ Profinite\nC : Cone F\nα : Type u_1\nhC : IsLimit C\nf : LocallyConstant (↑C.pt.toTop) α\nS : DiscreteQuotient ↑C.pt.toTop := f.discreteQuotient\nff : Quotient S.toSetoid → α := ⇑f.lift\nh✝ : Nonempty (Quotient S.toSetoid)\... | let f' : LocallyConstant C.pt S := ⟨S.proj, S.proj_isLocallyConstant⟩ | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_tacticLet___1 | Lean.Parser.Tactic.tacticLet__ |
Mathlib.Condensed.Discrete.LocallyConstant | {
"line": 322,
"column": 2
} | {
"line": 324,
"column": 33
} | [
{
"pp": "case w.h.h.toFun.h\nP : TopCat → Prop\ninst✝⁴ : ∀ (S : CompHausLike P) (p : ↑S.toTop → Prop), HasProp P (Subtype p)\ninst✝³ : HasProp P PUnit.{u + 1}\ninst✝² : HasExplicitFiniteCoproducts P\ninst✝¹ : HasExplicitPullbacks P\nhs : ∀ ⦃X Y : CompHausLike P⦄ (f : X ⟶ Y), EffectiveEpi f → Surjective ⇑(Concre... | apply presheaf_ext
(X := ((functor P hs).obj X).obj) (Y := ((functor.{u, w} P hs).obj X).obj)
(f.map ((unit P hs).app X)) | Lean.Elab.Tactic.evalApply | Lean.Parser.Tactic.apply |
Mathlib.Condensed.Explicit | {
"line": 84,
"column": 6
} | {
"line": 84,
"column": 41
} | [
{
"pp": "A : Type u_1\ninst✝² : Category.{v_1, u_1} A\ninst✝¹ : ∀ (X : CompHausᵒᵖ), HasLimitsOfShape (StructuredArrow X profiniteToCompHaus.op) A\nF : Profiniteᵒᵖ ⥤ A\ninst✝ : PreservesFiniteProducts F\nhF : EqualizerCondition F\n⊢ PreservesFiniteProducts F ∧ EqualizerCondition F",
"usedConstants": [
... | exact ⟨⟨fun _ ↦ inferInstance⟩, hF⟩ | Lean.Elab.Tactic.evalExact | Lean.Parser.Tactic.exact |
Mathlib.Condensed.Explicit | {
"line": 102,
"column": 6
} | {
"line": 102,
"column": 41
} | [
{
"pp": "A : Type u_1\ninst✝⁵ : Category.{v_1, u_1} A\ninst✝⁴ : ∀ (X : CompHausᵒᵖ), HasLimitsOfShape (StructuredArrow X profiniteToCompHaus.op) A\nFA : A → A → Type u_2\nCA : A → Type u_3\ninst✝³ : (X Y : A) → FunLike (FA X Y) (CA X) (CA Y)\ninst✝² : ConcreteCategory A FA\ninst✝¹ : ReflectsFiniteLimits (Categor... | exact ⟨⟨fun _ ↦ inferInstance⟩, hF⟩ | Lean.Elab.Tactic.evalExact | Lean.Parser.Tactic.exact |
Mathlib.Condensed.Explicit | {
"line": 114,
"column": 4
} | {
"line": 114,
"column": 39
} | [
{
"pp": "A : Type u_1\ninst✝¹ : Category.{v_1, u_1} A\nF : CompHausᵒᵖ ⥤ A\ninst✝ : PreservesFiniteProducts F\nhF : EqualizerCondition F\n⊢ PreservesFiniteProducts F ∧ EqualizerCondition F",
"usedConstants": [
"Opposite",
"inferInstance",
"Finite.of_fintype",
"CategoryTheory.Limits.in... | exact ⟨⟨fun _ ↦ inferInstance⟩, hF⟩ | Lean.Elab.Tactic.evalExact | Lean.Parser.Tactic.exact |
Mathlib.Condensed.Explicit | {
"line": 129,
"column": 4
} | {
"line": 129,
"column": 39
} | [
{
"pp": "A : Type u_1\ninst✝⁴ : Category.{v_1, u_1} A\nFA : A → A → Type u_2\nCA : A → Type u_3\ninst✝³ : (X Y : A) → FunLike (FA X Y) (CA X) (CA Y)\ninst✝² : ConcreteCategory A FA\ninst✝¹ : ReflectsFiniteLimits (CategoryTheory.forget A)\nF : CompHausᵒᵖ ⥤ A\ninst✝ : PreservesFiniteProducts (F ⋙ CategoryTheory.f... | exact ⟨⟨fun _ ↦ inferInstance⟩, hF⟩ | Lean.Elab.Tactic.evalExact | Lean.Parser.Tactic.exact |
Mathlib.Condensed.Discrete.Module | {
"line": 126,
"column": 15
} | {
"line": 126,
"column": 33
} | [
{
"pp": "P : TopCat → Prop\nR : Type (u + 1)\ninst✝ : Ring R\nX✝ Y✝ : ModuleCat R\nf : X✝ ⟶ Y✝\n⊢ (functorIsoDiscreteAux₂ R X✝).hom ≫\n (discreteUnderlyingAdj (ModuleCat R)).counit.app ((functor R).obj X✝) ≫ (functor R).map f =\n (presheafToSheaf (coherentTopology CompHaus) (ModuleCat R)).map ((Functor.... | ← Iso.eq_inv_comp, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Condensed.Discrete.Module | {
"line": 242,
"column": 24
} | {
"line": 242,
"column": 42
} | [
{
"pp": "P : TopCat → Prop\nR : Type u\ninst✝ : Ring R\nX✝ Y✝ : ModuleCat R\nf : X✝ ⟶ Y✝\n⊢ (functorIsoDiscreteAux₂ R X✝).hom ≫\n (discreteUnderlyingAdj (ModuleCat R)).counit.app ((functor R).obj X✝) ≫ (functor R).map f =\n (presheafToSheaf (coherentTopology LightProfinite) (ModuleCat R)).map ((Functor.... | ← Iso.eq_inv_comp, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Condensed.Light.TopCatAdjunction | {
"line": 182,
"column": 4
} | {
"line": 182,
"column": 47
} | [
{
"pp": "case hf\nX✝ Y : LightCondSet\nf✝ : X✝ ⟶ Y\nX : TopCat\ninst✝ : SequentialSpace ↑X\nf : ℕ → ↑X\np : ↑X\nh : Filter.Tendsto f Filter.atTop (nhds p)\ng : OnePoint ℕ → ↑X.toLightCondSet.toTopCat :=\n (topCatAdjunctionCounitEquiv X).invFun ∘ ⇑(OnePoint.continuousMapMkNat f p h)\n⊢ Filter.Tendsto ((topCatAd... | change Filter.Tendsto (fun n : ℕ ↦ g n) _ _ | Lean.Elab.Tactic.evalChange | Lean.Parser.Tactic.change |
Mathlib.Condensed.Light.Explicit | {
"line": 49,
"column": 4
} | {
"line": 49,
"column": 39
} | [
{
"pp": "A : Type u_1\ninst✝¹ : Category.{v_1, u_1} A\nF : LightProfiniteᵒᵖ ⥤ A\ninst✝ : PreservesFiniteProducts F\nhF : EqualizerCondition F\n⊢ PreservesFiniteProducts F ∧ EqualizerCondition F",
"usedConstants": [
"Opposite",
"SecondCountableTopology",
"inferInstance",
"TotallyDisco... | exact ⟨⟨fun _ ↦ inferInstance⟩, hF⟩ | Lean.Elab.Tactic.evalExact | Lean.Parser.Tactic.exact |
Mathlib.Condensed.Light.Explicit | {
"line": 65,
"column": 4
} | {
"line": 65,
"column": 39
} | [
{
"pp": "A : Type u_1\ninst✝⁴ : Category.{v_1, u_1} A\nFA : A → A → Type u_2\nCA : A → Type u_3\ninst✝³ : (X Y : A) → FunLike (FA X Y) (CA X) (CA Y)\ninst✝² : ConcreteCategory A FA\ninst✝¹ : ReflectsFiniteLimits (CategoryTheory.forget A)\nF : LightProfiniteᵒᵖ ⥤ A\ninst✝ : PreservesFiniteProducts (F ⋙ CategoryTh... | exact ⟨⟨fun _ ↦ inferInstance⟩, hF⟩ | Lean.Elab.Tactic.evalExact | Lean.Parser.Tactic.exact |
Mathlib.Condensed.Discrete.Colimit | {
"line": 583,
"column": 2
} | {
"line": 583,
"column": 27
} | [
{
"pp": "case w.h.w.e_a.h.toFun.h.h\nX : LightProfiniteᵒᵖ ⥤ Type u\ninst✝ : PreservesFiniteProducts X\nhX : (S : LightProfinite) → IsColimit (X.mapCocone (coconeRightOpOfCone S.asLimitCone))\nS : LightProfiniteᵒᵖ\nY : FintypeCatᵒᵖ\nright✝ : Discrete PUnit.{1}\ng : toLightProfinite.op.obj Y ⟶ (fromPUnit S).obj r... | rw [incl_of_counitAppApp] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.Control.Traversable.Lemmas | {
"line": 90,
"column": 47
} | {
"line": 90,
"column": 67
} | [
{
"pp": "t : Type u → Type u\ninst✝⁵ : Traversable t\ninst✝⁴ : LawfulTraversable t\nF G : Type u → Type u\ninst✝³ : Applicative F\ninst✝² : LawfulApplicative F\ninst✝¹ : Applicative G\ninst✝ : LawfulApplicative G\nα : Type u\nx : t (F (G α))\n⊢ traverse Comp.mk x = Comp.mk (traverse id <$> traverse id x)",
... | rw [← comp_traverse] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.Control.Traversable.Instances | {
"line": 71,
"column": 2
} | {
"line": 71,
"column": 14
} | [
{
"pp": "α : Type u_1\nxs : List α\n⊢ List.traverse pure xs = pure xs",
"usedConstants": [
"Pure.pure",
"Monad.toApplicative",
"List.rec",
"Id",
"Applicative.toPure",
"List",
"List.traverse",
"Id.instMonad",
"Eq"
]
}
] | induction xs | _private.Lean.Elab.Tactic.Induction.0.Lean.Elab.Tactic.evalInduction | Lean.Parser.Tactic.induction |
Mathlib.Control.Fold | {
"line": 327,
"column": 2
} | {
"line": 328,
"column": 29
} | [
{
"pp": "α β : Type u\nt : Type u → Type u\ninst✝¹ : Traversable t\ninst✝ : LawfulTraversable t\nf : α → β → α\nxs : t β\nx : α\n⊢ foldl f x xs = (ConcreteCategory.hom (unop ((Foldl.ofFreeMonoid f) (FreeMonoid.ofList (toList xs))))) x",
"usedConstants": [
"CategoryTheory.End.one",
"MulOne.toOne"... | simp only [foldl, toList_spec, foldMap_hom_free, foldl.ofFreeMonoid_comp_of, Foldl.get,
FreeMonoid.ofList_toList] | Lean.Elab.Tactic.evalSimp | Lean.Parser.Tactic.simp |
Mathlib.Control.Functor.Multivariate | {
"line": 209,
"column": 4
} | {
"line": 209,
"column": 38
} | [
{
"pp": "case h₁.a\nn : ℕ\nF : TypeVec.{u} (n + 1) → Type u_1\ninst✝¹ : MvFunctor F\ninst✝ : LawfulMvFunctor F\nα : TypeVec.{u} n\nβ : Type u\nrr : β → β → Prop\nx y : F (α ::: β)\nu✝ : F fun i ↦ { p_1 // ofRepeat (α.RelLast' rr i (prod.mk i p_1.1 p_1.2)) }\n⊢ ((fun i t ↦ (↑t).1) <$$> u✝ = x ∧ (fun i t ↦ (↑t).2... | congr <;> ext i ⟨x, _⟩ <;> cases i | Lean.Parser.Tactic.«_aux_Init_Tactics___macroRules_Lean_Parser_Tactic_tactic_<;>__1» | Lean.Parser.Tactic.«tactic_<;>_» |
Mathlib.Data.Analysis.Topology | {
"line": 185,
"column": 2
} | {
"line": 185,
"column": 15
} | [
{
"pp": "α : Type u_1\nτ : Type u_4\ninst✝ : TopologicalSpace α\nF : Realizer α\nE : F.σ ≃ τ\ns : τ\n⊢ (F.ofEquiv E).F.f s = F.F.f (E.symm s)",
"usedConstants": [
"Equiv.instEquivLike",
"id",
"Equiv",
"Ctop.Realizer.σ",
"Ctop.f",
"Ctop.Realizer.ofEquiv",
"Equiv.symm... | delta ofEquiv | Lean.Elab.Tactic.evalDelta | Lean.Parser.Tactic.delta |
Mathlib.Data.DFinsupp.Interval | {
"line": 153,
"column": 18
} | {
"line": 156,
"column": 9
} | [
{
"pp": "ι : Type u_1\nα : ι → Type u_2\ninst✝⁴ : DecidableEq ι\ninst✝³ : (i : ι) → DecidableEq (α i)\ninst✝² : (i : ι) → PartialOrder (α i)\ninst✝¹ : (i : ι) → Zero (α i)\ninst✝ : (i : ι) → LocallyFiniteOrder (α i)\nf g x : Π₀ (i : ι), α i\n⊢ x ∈ (fun f g ↦ (f.support ∪ g.support).dfinsupp ⇑(f.rangeIcc g)) f g... | by
refine (mem_dfinsupp_iff_of_support_subset <| support_rangeIcc_subset).trans ?_
simp_rw [mem_rangeIcc_apply_iff, forall_and]
rfl | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Data.ENat.BigOperators | {
"line": 104,
"column": 4
} | {
"line": 104,
"column": 31
} | [
{
"pp": "case cons.h₁\nα : Type u_1\nι : Type u_2\nf : α → ι → ℕ∞\nhf : ∀ (i j : ι), ∃ k, ∀ (a : α), f a i ≤ f a k ∧ f a j ≤ f a k\na : α\ns : Finset α\nha : a ∉ s\nihs : ∑ a ∈ s, ⨆ i, f a i = ⨆ i, ∑ a ∈ s, f a i\ni j k : ι\nhk : ∀ (a : α), f a i ≤ f a k ∧ f a j ≤ f a k\n⊢ f a i ≤ f a k",
"usedConstants": [... | exacts [(hk a).1, (hk _).2] | Batteries.Tactic._aux_Batteries_Tactic_Init___elabRules_Batteries_Tactic_exacts_1 | Batteries.Tactic.exacts |
Mathlib.Data.FP.Basic | {
"line": 147,
"column": 29
} | {
"line": 147,
"column": 73
} | [
{
"pp": "C : FloatCfg\ne : ℤ\nm : ℕ\nv : ValidFinite e m\nm' : ℕ := m.succ\nss : m'.size = m.size\n⊢ ValidFinite e m'",
"usedConstants": [
"Eq.mpr",
"FP.emin",
"FP.prec",
"congrArg",
"Int.instMax",
"HSub.hSub",
"FP.emax",
"id",
"Int",
"LE.le",
... | by unfold ValidFinite at *; rw [ss]; exact v | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Condensed.Light.Sequence | {
"line": 360,
"column": 70
} | {
"line": 360,
"column": 85
} | [
{
"pp": "R : Type\ninst✝ : CommRing R\nX Y : LightCondMod R\np : X ⟶ Y\nhp : Epi p\nS : LightProfinite\nf : (free R).obj (S ⊗ ℕ∪{∞}).toCondensed ⟶ Y\nT : LightProfinite\nπ : T ⟶ S ⊗ ℕ∪{∞}\ng : (free R).obj T.toCondensed ⟶ X\nhπ : Epi π\ncomm : (lightProfiniteToLightCondSet ⋙ free R).map π ≫ f = g ≫ p\nS' T' : L... | simpa using hS' | Lean.Elab.Tactic.Simpa.evalSimpa | Lean.Parser.Tactic.simpa |
Mathlib.Condensed.Light.Sequence | {
"line": 360,
"column": 70
} | {
"line": 360,
"column": 85
} | [
{
"pp": "R : Type\ninst✝ : CommRing R\nX Y : LightCondMod R\np : X ⟶ Y\nhp : Epi p\nS : LightProfinite\nf : (free R).obj (S ⊗ ℕ∪{∞}).toCondensed ⟶ Y\nT : LightProfinite\nπ : T ⟶ S ⊗ ℕ∪{∞}\ng : (free R).obj T.toCondensed ⟶ X\nhπ : Epi π\ncomm : (lightProfiniteToLightCondSet ⋙ free R).map π ≫ f = g ≫ p\nS' T' : L... | simpa using hS' | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Condensed.Light.Sequence | {
"line": 360,
"column": 70
} | {
"line": 360,
"column": 85
} | [
{
"pp": "R : Type\ninst✝ : CommRing R\nX Y : LightCondMod R\np : X ⟶ Y\nhp : Epi p\nS : LightProfinite\nf : (free R).obj (S ⊗ ℕ∪{∞}).toCondensed ⟶ Y\nT : LightProfinite\nπ : T ⟶ S ⊗ ℕ∪{∞}\ng : (free R).obj T.toCondensed ⟶ X\nhπ : Epi π\ncomm : (lightProfiniteToLightCondSet ⋙ free R).map π ≫ f = g ≫ p\nS' T' : L... | simpa using hS' | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Data.Multiset.Functor | {
"line": 62,
"column": 6
} | {
"line": 62,
"column": 40
} | [
{
"pp": "case e_a.e_a.h.h.h\nF : Type u → Type u\ninst✝¹ : Applicative F\ninst✝ : CommApplicative F\nα' β' : Type u\nf : α' → F β'\na✝ b✝ : List α'\nx y : α'\nl✝ : List α'\na b : β'\nl : List β'\n⊢ flip (fun a b l ↦ ↑(a :: b :: l)) a b l = ↑(a :: b :: l)",
"usedConstants": [
"Eq.mpr",
"Multiset"... | simpa [flip] using Perm.swap a b l | Lean.Elab.Tactic.Simpa.evalSimpa | Lean.Parser.Tactic.simpa |
Mathlib.Data.Multiset.Functor | {
"line": 117,
"column": 2
} | {
"line": 117,
"column": 54
} | [
{
"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✝",
"usedConstants": [
"List.instLawfulTraversable",
... | rw [← Traversable.traverse_map h g, List.map_eq_map] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.Data.List.Sigma | {
"line": 254,
"column": 6
} | {
"line": 254,
"column": 38
} | [
{
"pp": "α : Type u\nα' : Type u'\nβ : Type v\nf : α → α'\nhf : Function.Injective f\nhd : (_ : α) × β\ntl : List ((_ : α) × β)\nih : tl.NodupKeys → (map (Sigma.map f fun x ↦ id) tl).NodupKeys\nnd : ¬hd.fst ∈ tl.keys ∧ tl.NodupKeys\nh : (Sigma.map f (fun x ↦ id) hd).fst ∈ map (Sigma.fst ∘ Sigma.map f fun x ↦ id... | exact mem_map.mpr ⟨x, hm, hf he⟩ | Lean.Elab.Tactic.evalExact | Lean.Parser.Tactic.exact |
Mathlib.Data.Finset.Functor | {
"line": 115,
"column": 12
} | {
"line": 115,
"column": 31
} | [
{
"pp": "case inr.h\nα β : Type u\ninst✝ : (P : Prop) → Decidable P\nα✝ β✝ : Type u_1\ns : Finset α✝\nt : Finset β✝\nhs : s.Nonempty\na : β✝\n⊢ (a ∈ if s = ∅ then ∅ else t) ↔ a ∈ (image (const α✝ id) s).sup fun f ↦ image f t",
"usedConstants": [
"Eq.mpr",
"Lattice.toSemilatticeSup",
"congr... | if_neg hs.ne_empty, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Data.List.Sigma | {
"line": 688,
"column": 56
} | {
"line": 688,
"column": 68
} | [
{
"pp": "case neg\nα : Type u\nβ : α → Type v\ninst✝ : DecidableEq α\na : α\ns : Sigma β\nl₁ : List (Sigma β)\nih : ∀ {l₂ : List (Sigma β)}, a ∈ (l₁.kunion l₂).keys ↔ a ∈ l₁.keys ∨ a ∈ l₂.keys\nl₂ : List (Sigma β)\nh : ¬a = s.fst\n⊢ a ∈ ((s :: l₁).kunion l₂).keys ↔ a ∈ (s :: l₁).keys ∨ a ∈ l₂.keys",
"usedCo... | simp [h, ih] | Lean.Elab.Tactic.evalSimp | Lean.Parser.Tactic.simp |
Mathlib.Data.Holor | {
"line": 80,
"column": 28
} | {
"line": 80,
"column": 81
} | [
{
"pp": "ds₁ ds₂ ds₃ is : List ℕ\nh : Forall₂ (fun x1 x2 ↦ x1 < x2) is (ds₁ ++ ds₂ ++ ds₃)\n⊢ ↑(assocRight ⟨is, h⟩).drop.drop = ↑(drop ⟨is, h⟩)",
"usedConstants": [
"Subtype.mk.congr_simp",
"List.drop_drop",
"List.append_assoc",
"congrArg",
"HolorIndex.assocRight",
"List.... | by simp [assocRight, drop, cast_type, List.drop_drop] | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Data.Int.Bitwise | {
"line": 206,
"column": 4
} | {
"line": 206,
"column": 20
} | [
{
"pp": "b : Bool\nn : ℕ\n⊢ (bit b -[n+1]).testBit 0 = b",
"usedConstants": [
"Nat.bit",
"Int.testBit",
"Eq.mpr",
"Bool.not",
"congrArg",
"Int.bit_negSucc",
"id",
"instOfNatNat",
"Int",
"Nat",
"Bool",
"Int.negSucc",
"OfNat.ofNat",... | rw [bit_negSucc] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.Data.Int.Bitwise | {
"line": 223,
"column": 50
} | {
"line": 223,
"column": 59
} | [
{
"pp": "case h.h.ofNat.ofNat\nm n : ℕ\n⊢ bitwise or (ofNat m) (ofNat n) = (ofNat m).lor (ofNat n)",
"usedConstants": [
"Int.bitwise",
"Int.ofNat",
"Int",
"Bool.or",
"Eq.refl"
]
}
] | try {rfl} | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_tacticTry__1 | Lean.Parser.Tactic.tacticTry_ |
Mathlib.Data.Int.Bitwise | {
"line": 223,
"column": 50
} | {
"line": 223,
"column": 59
} | [
{
"pp": "case h.h.ofNat.negSucc\nm n : ℕ\n⊢ bitwise or (ofNat m) -[n+1] = (ofNat m).lor -[n+1]",
"usedConstants": []
}
] | try {rfl} | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_tacticTry__1 | Lean.Parser.Tactic.tacticTry_ |
Mathlib.Data.Int.Bitwise | {
"line": 223,
"column": 50
} | {
"line": 223,
"column": 59
} | [
{
"pp": "case h.h.negSucc.ofNat\nm n : ℕ\n⊢ bitwise or -[m+1] (ofNat n) = -[m+1].lor (ofNat n)",
"usedConstants": []
}
] | try {rfl} | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_tacticTry__1 | Lean.Parser.Tactic.tacticTry_ |
Mathlib.Data.Int.Bitwise | {
"line": 223,
"column": 50
} | {
"line": 223,
"column": 59
} | [
{
"pp": "case h.h.negSucc.negSucc\nm n : ℕ\n⊢ bitwise or -[m+1] -[n+1] = -[m+1].lor -[n+1]",
"usedConstants": []
}
] | try {rfl} | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_tacticTry__1 | Lean.Parser.Tactic.tacticTry_ |
Mathlib.Data.Int.Bitwise | {
"line": 237,
"column": 50
} | {
"line": 237,
"column": 59
} | [
{
"pp": "case h.h.ofNat.ofNat\nm n : ℕ\n⊢ bitwise and (ofNat m) (ofNat n) = (ofNat m).land (ofNat n)",
"usedConstants": [
"Int.bitwise",
"Bool.and",
"Int.ofNat",
"Int",
"Eq.refl"
]
}
] | try {rfl} | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_tacticTry__1 | Lean.Parser.Tactic.tacticTry_ |
Mathlib.Data.Int.Bitwise | {
"line": 237,
"column": 50
} | {
"line": 237,
"column": 59
} | [
{
"pp": "case h.h.ofNat.negSucc\nm n : ℕ\n⊢ bitwise and (ofNat m) -[n+1] = (ofNat m).land -[n+1]",
"usedConstants": [
"Int.bitwise",
"Bool.and",
"Int.ofNat",
"Int",
"Eq.refl",
"Int.negSucc"
]
}
] | try {rfl} | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_tacticTry__1 | Lean.Parser.Tactic.tacticTry_ |
Mathlib.Data.Int.Bitwise | {
"line": 237,
"column": 50
} | {
"line": 237,
"column": 59
} | [
{
"pp": "case h.h.negSucc.ofNat\nm n : ℕ\n⊢ bitwise and -[m+1] (ofNat n) = -[m+1].land (ofNat n)",
"usedConstants": []
}
] | try {rfl} | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_tacticTry__1 | Lean.Parser.Tactic.tacticTry_ |
Mathlib.Data.Int.Bitwise | {
"line": 237,
"column": 50
} | {
"line": 237,
"column": 59
} | [
{
"pp": "case h.h.negSucc.negSucc\nm n : ℕ\n⊢ bitwise and -[m+1] -[n+1] = -[m+1].land -[n+1]",
"usedConstants": []
}
] | try {rfl} | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_tacticTry__1 | Lean.Parser.Tactic.tacticTry_ |
Mathlib.Data.Int.Bitwise | {
"line": 251,
"column": 50
} | {
"line": 251,
"column": 59
} | [
{
"pp": "case h.h.ofNat.ofNat\nm n : ℕ\n⊢ bitwise (fun a b ↦ a && !b) (ofNat m) (ofNat n) = (ofNat m).ldiff (ofNat n)",
"usedConstants": [
"Bool.not",
"Int.bitwise",
"Bool.and",
"Int.ofNat",
"Int",
"Bool",
"Eq.refl"
]
}
] | try {rfl} | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_tacticTry__1 | Lean.Parser.Tactic.tacticTry_ |
Mathlib.Data.Int.Bitwise | {
"line": 251,
"column": 50
} | {
"line": 251,
"column": 59
} | [
{
"pp": "case h.h.ofNat.negSucc\nm n : ℕ\n⊢ bitwise (fun a b ↦ a && !b) (ofNat m) -[n+1] = (ofNat m).ldiff -[n+1]",
"usedConstants": []
}
] | try {rfl} | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_tacticTry__1 | Lean.Parser.Tactic.tacticTry_ |
Mathlib.Data.Int.Bitwise | {
"line": 251,
"column": 50
} | {
"line": 251,
"column": 59
} | [
{
"pp": "case h.h.negSucc.ofNat\nm n : ℕ\n⊢ bitwise (fun a b ↦ a && !b) -[m+1] (ofNat n) = -[m+1].ldiff (ofNat n)",
"usedConstants": []
}
] | try {rfl} | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_tacticTry__1 | Lean.Parser.Tactic.tacticTry_ |
Mathlib.Data.Int.Bitwise | {
"line": 251,
"column": 50
} | {
"line": 251,
"column": 59
} | [
{
"pp": "case h.h.negSucc.negSucc\nm n : ℕ\n⊢ bitwise (fun a b ↦ a && !b) -[m+1] -[n+1] = -[m+1].ldiff -[n+1]",
"usedConstants": []
}
] | try {rfl} | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_tacticTry__1 | Lean.Parser.Tactic.tacticTry_ |
Mathlib.Data.Int.Bitwise | {
"line": 267,
"column": 50
} | {
"line": 267,
"column": 59
} | [
{
"pp": "case h.h.ofNat.ofNat\nm n : ℕ\n⊢ bitwise xor (ofNat m) (ofNat n) = (ofNat m).xor (ofNat n)",
"usedConstants": [
"Int.bitwise",
"Int.ofNat",
"Int",
"Bool.xor",
"Eq.refl"
]
}
] | try {rfl} | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_tacticTry__1 | Lean.Parser.Tactic.tacticTry_ |
Mathlib.Data.Int.Bitwise | {
"line": 267,
"column": 50
} | {
"line": 267,
"column": 59
} | [
{
"pp": "case h.h.ofNat.negSucc\nm n : ℕ\n⊢ bitwise xor (ofNat m) -[n+1] = (ofNat m).xor -[n+1]",
"usedConstants": []
}
] | try {rfl} | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_tacticTry__1 | Lean.Parser.Tactic.tacticTry_ |
Mathlib.Data.Int.Bitwise | {
"line": 267,
"column": 50
} | {
"line": 267,
"column": 59
} | [
{
"pp": "case h.h.negSucc.ofNat\nm n : ℕ\n⊢ bitwise xor -[m+1] (ofNat n) = -[m+1].xor (ofNat n)",
"usedConstants": []
}
] | try {rfl} | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_tacticTry__1 | Lean.Parser.Tactic.tacticTry_ |
Mathlib.Data.Int.Bitwise | {
"line": 267,
"column": 50
} | {
"line": 267,
"column": 59
} | [
{
"pp": "case h.h.negSucc.negSucc\nm n : ℕ\n⊢ bitwise xor -[m+1] -[n+1] = -[m+1].xor -[n+1]",
"usedConstants": []
}
] | try {rfl} | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_tacticTry__1 | Lean.Parser.Tactic.tacticTry_ |
Mathlib.Data.Int.CardIntervalMod | {
"line": 71,
"column": 42
} | {
"line": 71,
"column": 51
} | [
{
"pp": "a b r : ℤ\nhr : 0 < r\n⊢ ↑(#(Ioc ⌊↑a / ↑r⌋ ⌊↑b / ↑r⌋)) = max (⌊↑b / ↑r⌋ - ⌊↑a / ↑r⌋) 0",
"usedConstants": [
"Int.cast",
"Eq.mpr",
"instHDiv",
"Int.floor",
"congrArg",
"Int.instMax",
"Rat",
"PartialOrder.toPreorder",
"Rat.instFloorRing",
"H... | card_Ioc, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Data.Int.CardIntervalMod | {
"line": 117,
"column": 52
} | {
"line": 117,
"column": 68
} | [
{
"pp": "a b r : ℕ\nhr : 0 < r\nv : ℕ\n⊢ max (⌈(↑↑b - ↑↑v) / ↑↑r⌉ - ⌈(↑↑a - ↑↑v) / ↑↑r⌉) 0 = max (⌈(↑b - ↑v) / ↑r⌉ - ⌈(↑a - ↑v) / ↑r⌉) 0",
"usedConstants": [
"Int.cast",
"Rat.instSub",
"Int.cast_natCast",
"instHDiv",
"congrArg",
"Int.instMax",
"Rat",
"Rat.inst... | Int.cast_natCast | Mathlib.Tactic._aux_Mathlib_Tactic_SimpRw___elabRules_Mathlib_Tactic_tacticSimp_rw____1 | null |
Mathlib.Data.Int.CardIntervalMod | {
"line": 124,
"column": 52
} | {
"line": 124,
"column": 68
} | [
{
"pp": "a b r : ℕ\nhr : 0 < r\nv : ℕ\n⊢ max (⌊(↑↑b - ↑↑v) / ↑↑r⌋ - ⌊(↑↑a - ↑↑v) / ↑↑r⌋) 0 = max (⌊(↑b - ↑v) / ↑r⌋ - ⌊(↑a - ↑v) / ↑r⌋) 0",
"usedConstants": [
"Int.cast",
"Rat.instSub",
"Int.cast_natCast",
"instHDiv",
"Int.floor",
"congrArg",
"Int.instMax",
"Ra... | Int.cast_natCast | Mathlib.Tactic._aux_Mathlib_Tactic_SimpRw___elabRules_Mathlib_Tactic_tacticSimp_rw____1 | null |
Mathlib.Data.Int.Fib.Lemmas | {
"line": 34,
"column": 13
} | {
"line": 34,
"column": 54
} | [
{
"pp": "i : ℕ\nhn : ¬i + 1 = 0\n⊢ fib (-↑(i + 1) + 1) * fib (-↑(i + 1) - 1) - fib (-↑(i + 1)) ^ 2 = (-1) ^ (-↑(i + 1)).natAbs",
"usedConstants": [
"neg_add_rev",
"Int.instAddCommGroup",
"Eq.mpr",
"HMul.hMul",
"AddMonoid.toAddSemigroup",
"congrArg",
"AddMonoid.toAdd... | show -((i + 1 : ℕ) : ℤ) + 1 = -i by simp, | Mathlib.Tactic._aux_Mathlib_Tactic_SimpRw___elabRules_Mathlib_Tactic_tacticSimp_rw____1 | null |
Mathlib.Data.Int.Star | {
"line": 38,
"column": 19
} | {
"line": 38,
"column": 68
} | [
{
"pp": "a b : ℤ\n⊢ a ≤ b ↔ ∃ p ∈ closure (range fun s ↦ star s * s), b = a + p",
"usedConstants": [
"Int.instAddCommGroup",
"HMul.hMul",
"AddLeftCancelSemigroup.toIsLeftCancelAdd",
"CommRing.toNonUnitalCommRing",
"congrArg",
"Int.instLinearOrder",
"Int.instStarRing... | simp [eq_comm, le_iff_exists_nonneg_add (a := a)] | Lean.Elab.Tactic.evalSimp | Lean.Parser.Tactic.simp |
Mathlib.Data.Int.Star | {
"line": 38,
"column": 19
} | {
"line": 38,
"column": 68
} | [
{
"pp": "a b : ℤ\n⊢ a ≤ b ↔ ∃ p ∈ closure (range fun s ↦ star s * s), b = a + p",
"usedConstants": [
"Int.instAddCommGroup",
"HMul.hMul",
"AddLeftCancelSemigroup.toIsLeftCancelAdd",
"CommRing.toNonUnitalCommRing",
"congrArg",
"Int.instLinearOrder",
"Int.instStarRing... | simp [eq_comm, le_iff_exists_nonneg_add (a := a)] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Data.Int.Star | {
"line": 38,
"column": 19
} | {
"line": 38,
"column": 68
} | [
{
"pp": "a b : ℤ\n⊢ a ≤ b ↔ ∃ p ∈ closure (range fun s ↦ star s * s), b = a + p",
"usedConstants": [
"Int.instAddCommGroup",
"HMul.hMul",
"AddLeftCancelSemigroup.toIsLeftCancelAdd",
"CommRing.toNonUnitalCommRing",
"congrArg",
"Int.instLinearOrder",
"Int.instStarRing... | simp [eq_comm, le_iff_exists_nonneg_add (a := a)] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Data.Nat.Choose.Lucas | {
"line": 49,
"column": 4
} | {
"line": 49,
"column": 89
} | [
{
"pp": "case h.h\nn k✝ p : ℕ\ninst✝ : Fact (Nat.Prime p)\ndecompose : (X + 1) ^ n = (X + 1) ^ (n % p) * (X ^ p + 1) ^ (n / p)\nk k' : ℕ\n| X ^ k * ↑((n % p).choose k) * (X ^ (p * k') * ↑((n / p).choose k'))",
"usedConstants": [
"NonAssocSemiring.toAddCommMonoidWithOne",
"Semigroup.toMul",
... | rw [← mul_assoc, mul_right_comm _ _ (X ^ (p * k')), ← pow_add, mul_assoc, ← cast_mul] | Lean.Parser.Tactic.Conv._aux_Init_Conv___macroRules_Lean_Parser_Tactic_Conv_convRw___1 | Lean.Parser.Tactic.Conv.convRw__ |
Mathlib.Data.Nat.Factorization.Root | {
"line": 82,
"column": 2
} | {
"line": 82,
"column": 34
} | [
{
"pp": "case pos\nn a : ℕ\nh : n = 0 ∨ a = 0\n⊢ factorization 0 = a.factorization ⌊/⌋ n",
"usedConstants": [
"floorDiv_of_nonpos",
"Finsupp.smulZeroClass",
"Finsupp.instFloorDiv",
"Nat.instMulZeroClass",
"Finsupp.partialorder",
"zero_floorDiv",
"instReflLe",
... | · obtain rfl | rfl := h <;> simp | Lean.Elab.Tactic.evalTacticCDot | Lean.cdot |
Mathlib.Data.Nat.Factorization.Root | {
"line": 143,
"column": 2
} | {
"line": 143,
"column": 34
} | [
{
"pp": "case pos\nn a : ℕ\nh : n = 0 ∨ a = 0\n⊢ factorization 0 = a.factorization ⌈/⌉ n",
"usedConstants": [
"Finsupp.smulZeroClass",
"Nat.instMulZeroClass",
"Finsupp.partialorder",
"instReflLe",
"congrArg",
"instDistribSMul",
"AddMonoid.toAddZeroClass",
"Par... | · obtain rfl | rfl := h <;> simp | Lean.Elab.Tactic.evalTacticCDot | Lean.cdot |
Mathlib.Data.Nat.Factorization.Divisors | {
"line": 55,
"column": 4
} | {
"line": 55,
"column": 53
} | [
{
"pp": "case neg.refine_1\nn : ℕ\nhn : ¬n = 0\nk : ℕ\nh : k ∈ ↑n.properDivisors\nhdvd : k ∣ n\nhlt : k < n\nhk : k ≠ 0\n⊢ k ∈ {x | ∃ f < n.factorization, (f.prod fun x1 x2 ↦ x1 ^ x2) = x}",
"usedConstants": [
"Nat.instMulZeroClass",
"Preorder.toLT",
"Nat.instMonoid",
"Monoid.toPow",... | refine ⟨_, ?_, prod_factorization_pow_eq_self hk⟩ | Lean.Elab.Tactic.evalRefine | Lean.Parser.Tactic.refine |
Mathlib.Data.Ordmap.Ordnode | {
"line": 226,
"column": 2
} | {
"line": 253,
"column": 49
} | [
{
"pp": "α : Type u_1\nl : Ordnode α\nx : α\nr : Ordnode α\n⊢ Ordnode α",
"usedConstants": [
"HMul.hMul",
"Ordnode",
"id",
"instMulNat",
"instOfNatNat",
"Ordnode.size",
"Ordnode.node",
"GT.gt",
"instHAdd",
"Ordnode.singleton",
"Ordnode.delta"... | rcases id l with _ | ls
· rcases id r with _ | ⟨rs, rl, rx, rr⟩
· exact ι x
· rcases id rr with _ | rrs
· rcases rl with _ | ⟨_, _, rlx⟩
· exact node 2 nil x r
· exact node 3 (ι x) rlx ι rx
· rcases id rl with _ | ⟨rls, rll, rlx, rlr⟩
· exact node 3 (ι x) rx rr
· ex... | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Data.Ordmap.Ordnode | {
"line": 226,
"column": 2
} | {
"line": 253,
"column": 49
} | [
{
"pp": "α : Type u_1\nl : Ordnode α\nx : α\nr : Ordnode α\n⊢ Ordnode α",
"usedConstants": [
"HMul.hMul",
"Ordnode",
"id",
"instMulNat",
"instOfNatNat",
"Ordnode.size",
"Ordnode.node",
"GT.gt",
"instHAdd",
"Ordnode.singleton",
"Ordnode.delta"... | rcases id l with _ | ls
· rcases id r with _ | ⟨rs, rl, rx, rr⟩
· exact ι x
· rcases id rr with _ | rrs
· rcases rl with _ | ⟨_, _, rlx⟩
· exact node 2 nil x r
· exact node 3 (ι x) rlx ι rx
· rcases id rl with _ | ⟨rls, rll, rlx, rlr⟩
· exact node 3 (ι x) rx rr
· ex... | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Data.Nat.Nth | {
"line": 451,
"column": 7
} | {
"line": 451,
"column": 16
} | [
{
"pp": "p : ℕ → Prop\ninst✝ : DecidablePred p\nn k : ℕ\nh : k < count p n\n⊢ count p (nth p k) < count p n",
"usedConstants": [
"Eq.mpr",
"Preorder.toLT",
"congrArg",
"id",
"Nat.instPreorder",
"Nat.count_nth",
"Nat",
"LT.lt",
"Nat.count",
"Nat.nth... | count_nth | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Data.Num.ZNum | {
"line": 506,
"column": 38
} | {
"line": 506,
"column": 54
} | [
{
"pp": "α : Type u_1\ninst✝ : AddGroupWithOne α\nn : ℕ\n⊢ ↑↑n = ↑n",
"usedConstants": [
"Int.cast",
"Eq.mpr",
"Int.cast_natCast",
"congrArg",
"AddGroupWithOne.toAddMonoidWithOne",
"id",
"AddMonoidWithOne.toNatCast",
"Int",
"AddGroupWithOne.toIntCast",
... | Int.cast_natCast | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Data.Num.ZNum | {
"line": 691,
"column": 35
} | {
"line": 691,
"column": 57
} | [
{
"pp": "a b : ZNum\n⊢ (↑a.abs).gcd ↑b.abs = (↑a).gcd ↑b",
"usedConstants": [
"Nat.gcd",
"Int.gcd",
"Eq.mpr",
"castZNum",
"Nat.instMulZeroClass",
"Nat.instOne",
"congrArg",
"AddGroupWithOne.toAddMonoidWithOne",
"ZNum.abs",
"id",
"Int.instNegI... | simp only [abs_to_nat] | Lean.Elab.Tactic.evalSimp | Lean.Parser.Tactic.simp |
Mathlib.Data.Ordmap.Ordset | {
"line": 244,
"column": 2
} | {
"line": 244,
"column": 63
} | [
{
"pp": "case node\nα : Type u_1\ninst✝ : Preorder α\nl : Ordnode α\nx : α\no₁ : WithBot α\no₂ : WithTop α\nhl : Valid' o₁ l ↑x\nrs : ℕ\nrl : Ordnode α\nrx : α\nrr : Ordnode α\nhr : Valid' (↑x) (Ordnode.node rs rl rx rr) o₂\nH1 : ¬l.size + (Ordnode.node rs rl rx rr).size ≤ 1\nH2 : delta * l.size ≤ rl.size + rr.... | have H3_0 (l0 : size l = 0) : size rl + size rr ≤ 2 := by lia | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_tacticHave___1 | Lean.Parser.Tactic.tacticHave__ |
Mathlib.Data.PFunctor.Multivariate.M | {
"line": 264,
"column": 2
} | {
"line": 264,
"column": 29
} | [
{
"pp": "n : ℕ\nP : MvPFunctor.{u} (n + 1)\nα : TypeVec.{u} n\nR : P.M α → P.M α → Prop\nh₀ : Equivalence R\nx y : P.M α\nax : P.A\nfx fy : P.B ax ⟹ α ::: P.M α\nh₁ : (TypeVec.id ::: Quot.mk R) ⊚ fx ≍ (TypeVec.id ::: Quot.mk R) ⊚ fy\n⊢ ∃ a f f₁ f₂, ⟨ax, fx⟩ = ⟨a, splitFun f f₁⟩ ∧ ⟨ax, fy⟩ = ⟨a, splitFun f f₂⟩ ∧... | simp only [heq_eq_eq] at h₁ | Lean.Elab.Tactic.evalSimp | Lean.Parser.Tactic.simp |
Mathlib.Data.PFunctor.Multivariate.M | {
"line": 269,
"column": 6
} | {
"line": 269,
"column": 28
} | [
{
"pp": "n : ℕ\nP : MvPFunctor.{u} (n + 1)\nα : TypeVec.{u} n\nR : P.M α → P.M α → Prop\nh₀ : Equivalence R\nx y : P.M α\nax : P.A\nfx fy : P.B ax ⟹ α ::: P.M α\nh₁ : (TypeVec.id ::: Quot.mk R) ⊚ fx = (TypeVec.id ::: Quot.mk R) ⊚ fy\nHdrop : dropFun fx = dropFun fy\n⊢ ⟨ax, fx⟩ = ⟨ax, splitFun (dropFun fx) (last... | split_dropFun_lastFun, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Data.PNat.Interval | {
"line": 71,
"column": 41
} | {
"line": 72,
"column": 60
} | [
{
"pp": "a b : ℕ+\n⊢ #(Ioc a b) = ↑b - ↑a",
"usedConstants": [
"PNat.val",
"Eq.mpr",
"instLinearOrderPNat",
"congrArg",
"Finset",
"PartialOrder.toPreorder",
"Finset.card_map",
"HSub.hSub",
"Nat.instLocallyFiniteOrder",
"Finset.map",
"Semilatt... | by
rw [← Nat.card_Ioc, ← map_subtype_embedding_Ioc, card_map] | [anonymous] | Lean.Parser.Term.byTactic |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.