module string | startPos dict | endPos dict | nextStartPos dict | goals list | goalsAfter list | ppTac string | elaborator string | kind string |
|---|---|---|---|---|---|---|---|---|
Mathlib.Computability.AkraBazzi.GrowsPolynomially | {
"line": 169,
"column": 4
} | {
"line": 169,
"column": 49
} | {
"line": 170,
"column": 4
} | [
{
"pp": "f : ℝ → ℝ\nhf : GrowsPolynomially f\nc₁ : ℝ\nleft✝¹ : c₁ > 0\nc₂ : ℝ\nleft✝ : c₂ > 0\nh : ∀ᶠ (x : ℝ) in atTop, ∀ u ∈ Set.Icc (1 / 2 * x) x, f u ∈ Set.Icc (c₁ * f x) (c₂ * f x)\nhlt : c₁ < c₂\nx : ℝ\nhx : ∀ u ∈ Set.Icc (1 / 2 * x) x, f u ∈ Set.Icc (c₁ * f x) (c₂ * f x)\nhx_nonneg : 0 ≤ x\nh' : 3 / 4 * x... | [
"f : ℝ → ℝ\nhf : GrowsPolynomially f\nc₁ : ℝ\nleft✝¹ : c₁ > 0\nc₂ : ℝ\nleft✝ : c₂ > 0\nh : ∀ᶠ (x : ℝ) in atTop, ∀ u ∈ Set.Icc (1 / 2 * x) x, f u ∈ Set.Icc (c₁ * f x) (c₂ * f x)\nhlt : c₁ < c₂\nx : ℝ\nhx : ∀ u ∈ Set.Icc (1 / 2 * x) x, f u ∈ Set.Icc (c₁ * f x) (c₂ * f x)\nhx_nonneg : 0 ≤ x\nh' : 3 / 4 * x ∈ Set.Icc (... | have hu' : 0 ≤ (c₂ - c₁) * f x := by linarith | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_tacticHave___1 | Lean.Parser.Tactic.tacticHave__ |
Mathlib.Computability.AkraBazzi.SumTransform | {
"line": 467,
"column": 56
} | {
"line": 467,
"column": 84
} | {
"line": 469,
"column": 0
} | [
{
"pp": "α : Type u_1\ninst✝¹ : Fintype α\nT : ℕ → ℝ\ng : ℝ → ℝ\na b : α → ℝ\nr : α → ℕ → ℕ\ninst✝ : Nonempty α\nR : AkraBazziRecurrence T g a b r\ni : α\n⊢ (fun n ↦ -log (b i) / (log ↑n * log ↑n)) = fun n ↦ -log (b i) / log ↑n ^ 2",
"ppTerm": "?m.187",
"assigned": true,
"usedConstants": [
"Eq... | [] | ext; congr 1; rw [← pow_two] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Computability.AkraBazzi.SumTransform | {
"line": 467,
"column": 56
} | {
"line": 467,
"column": 84
} | {
"line": 469,
"column": 0
} | [
{
"pp": "α : Type u_1\ninst✝¹ : Fintype α\nT : ℕ → ℝ\ng : ℝ → ℝ\na b : α → ℝ\nr : α → ℕ → ℕ\ninst✝ : Nonempty α\nR : AkraBazziRecurrence T g a b r\ni : α\n⊢ (fun n ↦ -log (b i) / (log ↑n * log ↑n)) = fun n ↦ -log (b i) / log ↑n ^ 2",
"ppTerm": "?m.187",
"assigned": true,
"usedConstants": [
"Eq... | [] | ext; congr 1; rw [← pow_two] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Computability.AkraBazzi.AkraBazzi | {
"line": 225,
"column": 2
} | {
"line": 225,
"column": 51
} | {
"line": 226,
"column": 2
} | [
{
"pp": "α : Type u_1\ninst✝¹ : Fintype α\nT : ℕ → ℝ\ng : ℝ → ℝ\na b : α → ℝ\nr : α → ℕ → ℕ\ninst✝ : Nonempty α\nR : AkraBazziRecurrence T g a b r\nq : ℝ → ℝ\nhq_diff : DifferentiableOn ℝ q (Set.Ioi 1)\nhq_poly : GrowsPolynomially fun x ↦ ‖deriv q x‖\ni : α\nb' : ℝ := b (min_bi b) / 2\nhb_pos : 0 < b'\nhb_lt_on... | [
"α : Type u_1\ninst✝¹ : Fintype α\nT : ℕ → ℝ\ng : ℝ → ℝ\na b : α → ℝ\nr : α → ℕ → ℕ\ninst✝ : Nonempty α\nR : AkraBazziRecurrence T g a b r\nq : ℝ → ℝ\nhq_diff : DifferentiableOn ℝ q (Set.Ioi 1)\nhq_poly : GrowsPolynomially fun x ↦ ‖deriv q x‖\ni : α\nb' : ℝ := b (min_bi b) / 2\nhb_pos : 0 < b'\nhb_lt_one : b' < 1\n... | have hb : b' ∈ Set.Ioo 0 1 := ⟨hb_pos, hb_lt_one⟩ | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_tacticHave___1 | Lean.Parser.Tactic.tacticHave__ |
Mathlib.Computability.AkraBazzi.SumTransform | {
"line": 581,
"column": 8
} | {
"line": 584,
"column": 82
} | {
"line": 586,
"column": 0
} | [
{
"pp": "α : Type u_1\ninst✝¹ : Fintype α\nT : ℕ → ℝ\ng : ℝ → ℝ\na b : α → ℝ\nr : α → ℕ → ℕ\ninst✝ : Nonempty α\nR : AkraBazziRecurrence T g a b r\nn : ℕ\nhn : 0 < n\n⊢ ↑n ^ p a b * (1 + 0) ≤ asympBound g a b n",
"ppTerm": "?m.44",
"assigned": true,
"usedConstants": [
"AkraBazziRecurrence.asym... | [] | simp only [asympBound_def']
gcongr n ^ p a b * (1 + ?_)
have := R.g_nonneg
aesop (add safe Real.rpow_nonneg, safe div_nonneg, safe Finset.sum_nonneg) | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Computability.AkraBazzi.SumTransform | {
"line": 581,
"column": 8
} | {
"line": 584,
"column": 82
} | {
"line": 586,
"column": 0
} | [
{
"pp": "α : Type u_1\ninst✝¹ : Fintype α\nT : ℕ → ℝ\ng : ℝ → ℝ\na b : α → ℝ\nr : α → ℕ → ℕ\ninst✝ : Nonempty α\nR : AkraBazziRecurrence T g a b r\nn : ℕ\nhn : 0 < n\n⊢ ↑n ^ p a b * (1 + 0) ≤ asympBound g a b n",
"ppTerm": "?m.44",
"assigned": true,
"usedConstants": [
"AkraBazziRecurrence.asym... | [] | simp only [asympBound_def']
gcongr n ^ p a b * (1 + ?_)
have := R.g_nonneg
aesop (add safe Real.rpow_nonneg, safe div_nonneg, safe Finset.sum_nonneg) | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Computability.PartrecCode | {
"line": 421,
"column": 2
} | {
"line": 428,
"column": 52
} | {
"line": 429,
"column": 2
} | [
{
"pp": "α : Type u_1\nσ : Type u_2\ninst✝¹ : Primcodable α\ninst✝ : Primcodable σ\nc : α → Code\nhc : Computable c\nz : α → σ\nhz : Computable z\ns : α → σ\nhs : Computable s\nl : α → σ\nhl : Computable l\nr : α → σ\nhr : Computable r\npr : α → Code × Code × σ × σ → σ\nhpr : Computable₂ pr\nco : α → Code × Cod... | [
"α : Type u_1\nσ : Type u_2\ninst✝¹ : Primcodable α\ninst✝ : Primcodable σ\nc : α → Code\nhc : Computable c\nz : α → σ\nhz : Computable z\ns : α → σ\nhs : Computable s\nl : α → σ\nhl : Computable l\nr : α → σ\nhr : Computable r\npr : α → Code × Code × σ × σ → σ\nhpr : Computable₂ pr\nco : α → Code × Code × σ × σ → ... | have : Computable₂ G := .mk <|
nat_casesOn (list_length.comp snd) (option_some_iff.2 (hz.comp fst)) <| .mk <|
nat_casesOn snd (option_some_iff.2 (hs.comp (fst.comp fst))) <| .mk <|
nat_casesOn snd (option_some_iff.2 (hl.comp (fst.comp <| fst.comp fst))) <| .mk <|
nat_casesOn snd (option_some_iff.2 (hr.c... | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_tacticHave___1 | Lean.Parser.Tactic.tacticHave__ |
Mathlib.Computability.AkraBazzi.AkraBazzi | {
"line": 219,
"column": 93
} | {
"line": 248,
"column": 33
} | {
"line": 250,
"column": 0
} | [
{
"pp": "α : Type u_1\ninst✝¹ : Fintype α\nT : ℕ → ℝ\ng : ℝ → ℝ\na b : α → ℝ\nr : α → ℕ → ℕ\ninst✝ : Nonempty α\nR : AkraBazziRecurrence T g a b r\nq : ℝ → ℝ\nhq_diff : DifferentiableOn ℝ q (Set.Ioi 1)\nhq_poly : GrowsPolynomially fun x ↦ ‖deriv q x‖\ni : α\n⊢ (fun n ↦ q ↑(r i n) - q (b i * ↑n)) =O[atTop] fun n... | [] | by
let b' := b (min_bi b) / 2
have hb_pos : 0 < b' := by have := R.b_pos (min_bi b); positivity
have hb_lt_one : b' < 1 := calc b (min_bi b) / 2
_ < b (min_bi b) := div_two_lt_of_pos (R.b_pos (min_bi b))
_ < 1 := R.b_lt_one (min_bi b)
have hb : b' ∈ Set.Ioo 0 1 := ⟨hb_pos, hb_lt_one⟩
have hb' (i) : b'... | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Computability.AkraBazzi.SumTransform | {
"line": 631,
"column": 14
} | {
"line": 631,
"column": 26
} | {
"line": 631,
"column": 27
} | [
{
"pp": "α : Type u_1\ninst✝¹ : Fintype α\nT : ℕ → ℝ\ng : ℝ → ℝ\na b : α → ℝ\nr : α → ℕ → ℕ\ninst✝ : Nonempty α\nR : AkraBazziRecurrence T g a b r\nc₁ : ℝ\nhc₁_mem : c₁ ∈ Set.Ioo 0 1\nhc₁ : ∀ᶠ (n : ℕ) in atTop, ∀ (i : α), c₁ * ↑n ≤ ↑(r i n)\nc₂ : ℝ\nhc₂_mem : c₂ > 0\nhc₂ : ∀ᶠ (n : ℕ) in atTop, ∀ u ∈ Set.Icc (c₁... | [
"α : Type u_1\ninst✝¹ : Fintype α\nT : ℕ → ℝ\ng : ℝ → ℝ\na b : α → ℝ\nr : α → ℕ → ℕ\ninst✝ : Nonempty α\nR : AkraBazziRecurrence T g a b r\nc₁ : ℝ\nhc₁_mem : c₁ ∈ Set.Ioo 0 1\nhc₁ : ∀ᶠ (n : ℕ) in atTop, ∀ (i : α), c₁ * ↑n ≤ ↑(r i n)\nc₂ : ℝ\nhc₂_mem : c₂ > 0\nhc₂ : ∀ᶠ (n : ℕ) in atTop, ∀ u ∈ Set.Icc (c₁ * ↑n) ↑n, g... | mul_comm c₁, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Computability.AkraBazzi.GrowsPolynomially | {
"line": 355,
"column": 14
} | {
"line": 355,
"column": 37
} | {
"line": 356,
"column": 14
} | [
{
"pp": "case hbc\nf g : ℝ → ℝ\nhf✝¹ : GrowsPolynomially f\nhg✝¹ : GrowsPolynomially g\nhf'✝ : 0 ≤ᶠ[atTop] f\nhg'✝ : 0 ≤ᶠ[atTop] g\nb : ℝ\nhb : b ∈ Set.Ioo 0 1\nc₁ : ℝ\nhc₁_mem : c₁ > 0\nc₂ : ℝ\nhc₂_mem : c₂ > 0\nhf✝ : ∀ᶠ (x : ℝ) in atTop, ∀ u ∈ Set.Icc (b * x) x, f u ∈ Set.Icc (c₁ * f x) (c₂ * f x)\nc₃ : ℝ\nhc... | [
"case hbc\nf g : ℝ → ℝ\nhf✝¹ : GrowsPolynomially f\nhg✝¹ : GrowsPolynomially g\nhf'✝ : 0 ≤ᶠ[atTop] f\nhg'✝ : 0 ≤ᶠ[atTop] g\nb : ℝ\nhb : b ∈ Set.Ioo 0 1\nc₁ : ℝ\nhc₁_mem : c₁ > 0\nc₂ : ℝ\nhc₂_mem : c₂ > 0\nhf✝ : ∀ᶠ (x : ℝ) in atTop, ∀ u ∈ Set.Icc (b * x) x, f u ∈ Set.Icc (c₁ * f x) (c₂ * f x)\nc₃ : ℝ\nhc₃_mem : c₃ >... | · exact min_le_left _ _ | Lean.Elab.Tactic.evalTacticCDot | Lean.cdot |
Mathlib.Computability.AkraBazzi.SumTransform | {
"line": 675,
"column": 33
} | {
"line": 675,
"column": 50
} | {
"line": 675,
"column": 50
} | [
{
"pp": "α : Type u_1\ninst✝¹ : Fintype α\nT : ℕ → ℝ\ng : ℝ → ℝ\na b : α → ℝ\nr : α → ℕ → ℕ\ninst✝ : Nonempty α\nR : AkraBazziRecurrence T g a b r\nc₁ : ℝ\nhc₁_mem : c₁ ∈ Set.Ioo 0 1\nhc₁ : ∀ᶠ (n : ℕ) in atTop, ∀ (i : α), c₁ * ↑n ≤ ↑(r i n)\nc₂ : ℝ\nhc₂_mem : c₂ > 0\nhc₂ : ∀ᶠ (n : ℕ) in atTop, ∀ u ∈ Set.Icc (c₁... | [
"α : Type u_1\ninst✝¹ : Fintype α\nT : ℕ → ℝ\ng : ℝ → ℝ\na b : α → ℝ\nr : α → ℕ → ℕ\ninst✝ : Nonempty α\nR : AkraBazziRecurrence T g a b r\nc₁ : ℝ\nhc₁_mem : c₁ ∈ Set.Ioo 0 1\nhc₁ : ∀ᶠ (n : ℕ) in atTop, ∀ (i : α), c₁ * ↑n ≤ ↑(r i n)\nc₂ : ℝ\nhc₂_mem : c₂ > 0\nhc₂ : ∀ᶠ (n : ℕ) in atTop, ∀ u ∈ Set.Icc (c₁ * ↑n) ↑n, c... | have := hc₃_mem.2 | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_tacticHave___1 | Lean.Parser.Tactic.tacticHave__ |
Mathlib.Computability.PartrecCode | {
"line": 544,
"column": 6
} | {
"line": 545,
"column": 29
} | {
"line": 546,
"column": 4
} | [
{
"pp": "case refine_1.comp\nf f✝ g✝ : ℕ →. ℕ\npf : Nat.Partrec f✝\npg : Nat.Partrec g✝\nhf : ∃ c, c.eval = f✝\nhg : ∃ c, c.eval = g✝\n⊢ ∃ c, c.eval = fun n ↦ g✝ n >>= f✝",
"ppTerm": "?refine_1.comp",
"assigned": true,
"usedConstants": [
"Part",
"Nat.Partrec",
"PFun",
"Exists... | [] | rcases hf with ⟨cf, rfl⟩; rcases hg with ⟨cg, rfl⟩
exact ⟨comp cf cg, rfl⟩ | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Computability.PartrecCode | {
"line": 544,
"column": 6
} | {
"line": 545,
"column": 29
} | {
"line": 546,
"column": 4
} | [
{
"pp": "case refine_1.comp\nf f✝ g✝ : ℕ →. ℕ\npf : Nat.Partrec f✝\npg : Nat.Partrec g✝\nhf : ∃ c, c.eval = f✝\nhg : ∃ c, c.eval = g✝\n⊢ ∃ c, c.eval = fun n ↦ g✝ n >>= f✝",
"ppTerm": "?refine_1.comp",
"assigned": true,
"usedConstants": [
"Part",
"Nat.Partrec",
"PFun",
"Exists... | [] | rcases hf with ⟨cf, rfl⟩; rcases hg with ⟨cg, rfl⟩
exact ⟨comp cf cg, rfl⟩ | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Computability.PartrecCode | {
"line": 609,
"column": 4
} | {
"line": 609,
"column": 41
} | {
"line": 609,
"column": 42
} | [
{
"pp": "k : ℕ\nc : Code\nn x : ℕ\nh : x ∈ evaln (k + 1) c n\n⊢ ∀ {o : Option ℕ},\n (x ∈ do\n guard (n ≤ k)\n o) →\n n < k + 1",
"ppTerm": "?m.78",
"assigned": true,
"usedConstants": [
"guard",
"Eq.mpr",
"instAlternativeOption",
"congrArg",
"Option... | [
"k : ℕ\nc : Code\nn x : ℕ\nh : x ∈ evaln (k + 1) c n\n⊢ n ≤ k → n < k + 1"
] | simpa using | Lean.Elab.Tactic.Simpa.evalSimpa | null |
Mathlib.Computability.PartrecCode | {
"line": 656,
"column": 14
} | {
"line": 656,
"column": 52
} | {
"line": 656,
"column": 53
} | [
{
"pp": "case zero\nk n x : ℕ\nleft✝ : n ≤ k\nh : 0 = x\n⊢ x ∈ pure 0 n",
"ppTerm": "?zero",
"assigned": true,
"usedConstants": [
"Pure.pure",
"Part",
"Eq.mpr",
"PFun",
"Monad.toApplicative",
"Membership.mem",
"PFun.monad",
"id",
"Part.instMember... | [
"case zero\nk n x : ℕ\nleft✝ : n ≤ k\nh : 0 = x\n⊢ x = 0"
] | simpa using | Lean.Elab.Tactic.Simpa.evalSimpa | null |
Mathlib.Computability.PartrecCode | {
"line": 656,
"column": 14
} | {
"line": 656,
"column": 52
} | {
"line": 656,
"column": 53
} | [
{
"pp": "case succ\nk n x : ℕ\nleft✝ : n ≤ k\nh : n + 1 = x\n⊢ x = n + 1",
"ppTerm": "?succ",
"assigned": false,
"usedConstants": [],
"usedFVars": [],
"usedGoals": []
}
] | [
"case succ\nk n x : ℕ\nleft✝ : n ≤ k\nh : n + 1 = x\n⊢ x = n + 1"
] | simpa using | Lean.Elab.Tactic.Simpa.evalSimpa | null |
Mathlib.Computability.PartrecCode | {
"line": 656,
"column": 14
} | {
"line": 656,
"column": 52
} | {
"line": 656,
"column": 53
} | [
{
"pp": "case left\nk n x : ℕ\nleft✝ : n ≤ k\nh : (unpair n).1 = x\n⊢ x = (unpair n).1",
"ppTerm": "?left",
"assigned": false,
"usedConstants": [],
"usedFVars": [],
"usedGoals": []
}
] | [
"case left\nk n x : ℕ\nleft✝ : n ≤ k\nh : (unpair n).1 = x\n⊢ x = (unpair n).1"
] | simpa using | Lean.Elab.Tactic.Simpa.evalSimpa | null |
Mathlib.Computability.PartrecCode | {
"line": 656,
"column": 14
} | {
"line": 656,
"column": 52
} | {
"line": 656,
"column": 53
} | [
{
"pp": "case right\nk n x : ℕ\nleft✝ : n ≤ k\nh : (unpair n).2 = x\n⊢ x = (unpair n).2",
"ppTerm": "?right",
"assigned": false,
"usedConstants": [],
"usedFVars": [],
"usedGoals": []
}
] | [
"case right\nk n x : ℕ\nleft✝ : n ≤ k\nh : (unpair n).2 = x\n⊢ x = (unpair n).2"
] | simpa using | Lean.Elab.Tactic.Simpa.evalSimpa | null |
Mathlib.Computability.PartrecCode | {
"line": 677,
"column": 18
} | {
"line": 677,
"column": 34
} | {
"line": 677,
"column": 35
} | [
{
"pp": "k : ℕ\ncf : Code\nhf : ∀ (n x : ℕ), x ∈ evaln (k + 1) cf n → x ∈ cf.eval n\nn x : ℕ\nleft✝ : n ≤ k\nm : ℕ\nh₁ : evaln (k + 1) cf n = some m\nm0 : m = 0\nh₂ : (unpair n).2 = x\n⊢ 0 ∈ cf.eval (Nat.pair (unpair n).1 (0 + (unpair n).2))",
"ppTerm": "?m.420",
"assigned": true,
"usedConstants": [... | [
"k : ℕ\ncf : Code\nhf : ∀ (n x : ℕ), x ∈ evaln (k + 1) cf n → x ∈ cf.eval n\nn x : ℕ\nleft✝ : n ≤ k\nm : ℕ\nh₁ : evaln (k + 1) cf n = some m\nm0 : m = 0\nh₂ : (unpair n).2 = x\n⊢ 0 ∈ cf.eval n"
] | simpa using | Lean.Elab.Tactic.Simpa.evalSimpa | null |
Mathlib.Computability.PartrecCode | {
"line": 682,
"column": 22
} | {
"line": 682,
"column": 59
} | {
"line": 682,
"column": 60
} | [
{
"pp": "k : ℕ\ncf : Code\nhf : ∀ (n x : ℕ), x ∈ evaln (k + 1) cf n → x ∈ cf.eval n\nn : ℕ\nleft✝ : n ≤ k\nm : ℕ\nh₁ : evaln (k + 1) cf n = some m\nm0 : ¬m = 0\ny : ℕ\nhy₁ : 0 ∈ cf.eval (Nat.pair (unpair n).1 (y + ((unpair n).2 + 1)))\nhy₂ : ∀ {m : ℕ}, m < y → ∃ a ∈ cf.eval (Nat.pair (unpair n).1 (m + ((unpair ... | [
"k : ℕ\ncf : Code\nhf : ∀ (n x : ℕ), x ∈ evaln (k + 1) cf n → x ∈ cf.eval n\nn : ℕ\nleft✝ : n ≤ k\nm : ℕ\nh₁ : evaln (k + 1) cf n = some m\nm0 : ¬m = 0\ny : ℕ\nhy₁ : 0 ∈ cf.eval (Nat.pair (unpair n).1 (y + ((unpair n).2 + 1)))\nhy₂ : ∀ {m : ℕ}, m < y → ∃ a ∈ cf.eval (Nat.pair (unpair n).1 (m + ((unpair n).2 + 1))),... | simpa using | Lean.Elab.Tactic.Simpa.evalSimpa | null |
Mathlib.Computability.PartrecCode | {
"line": 685,
"column": 23
} | {
"line": 685,
"column": 34
} | {
"line": 685,
"column": 35
} | [
{
"pp": "k : ℕ\ncf : Code\nhf : ∀ (n x : ℕ), x ∈ evaln (k + 1) cf n → x ∈ cf.eval n\nn : ℕ\nleft✝ : n ≤ k\nm : ℕ\nh₁ : evaln (k + 1) cf n = some m\nm0 : ¬m = 0\ny : ℕ\nhy₁ : 0 ∈ cf.eval (Nat.pair (unpair n).1 (y + ((unpair n).2 + 1)))\nhy₂ : ∀ {m : ℕ}, m < y → ∃ a ∈ cf.eval (Nat.pair (unpair n).1 (m + ((unpair ... | [
"k : ℕ\ncf : Code\nhf : ∀ (n x : ℕ), x ∈ evaln (k + 1) cf n → x ∈ cf.eval n\nn : ℕ\nleft✝ : n ≤ k\nm : ℕ\nh₁ : evaln (k + 1) cf n = some m\nm0 : ¬m = 0\ny : ℕ\nhy₁ : 0 ∈ cf.eval (Nat.pair (unpair n).1 (y + ((unpair n).2 + 1)))\nhy₂ : ∀ {m : ℕ}, m < y → ∃ a ∈ cf.eval (Nat.pair (unpair n).1 (m + ((unpair n).2 + 1))),... | simpa using | Lean.Elab.Tactic.Simpa.evalSimpa | null |
Mathlib.Computability.PartrecCode | {
"line": 687,
"column": 23
} | {
"line": 687,
"column": 60
} | {
"line": 687,
"column": 61
} | [
{
"pp": "k : ℕ\ncf : Code\nhf : ∀ (n x : ℕ), x ∈ evaln (k + 1) cf n → x ∈ cf.eval n\nn : ℕ\nleft✝ : n ≤ k\nm : ℕ\nh₁ : evaln (k + 1) cf n = some m\nm0 : ¬m = 0\ny : ℕ\nhy₁ : 0 ∈ cf.eval (Nat.pair (unpair n).1 (y + ((unpair n).2 + 1)))\nhy₂ : ∀ {m : ℕ}, m < y → ∃ a ∈ cf.eval (Nat.pair (unpair n).1 (m + ((unpair ... | [
"k : ℕ\ncf : Code\nhf : ∀ (n x : ℕ), x ∈ evaln (k + 1) cf n → x ∈ cf.eval n\nn : ℕ\nleft✝ : n ≤ k\nm : ℕ\nh₁ : evaln (k + 1) cf n = some m\nm0 : ¬m = 0\ny : ℕ\nhy₁ : 0 ∈ cf.eval (Nat.pair (unpair n).1 (y + ((unpair n).2 + 1)))\nhy₂ : ∀ {m : ℕ}, m < y → ∃ a ∈ cf.eval (Nat.pair (unpair n).1 (m + ((unpair n).2 + 1))),... | simpa using | Lean.Elab.Tactic.Simpa.evalSimpa | null |
Mathlib.Computability.Language | {
"line": 257,
"column": 10
} | {
"line": 257,
"column": 25
} | {
"line": 257,
"column": 25
} | [
{
"pp": "case succ.mpr.cons.refl\nα : Type u_1\nl : Language α\na : List α\nS : List (List α)\nhS : ∀ y ∈ a :: S, y ∈ l\nihn : ∀ {x : List α}, x ∈ l ^ S.length ↔ ∃ S_1, x = S_1.flatten ∧ S_1.length = S.length ∧ ∀ y ∈ S_1, y ∈ l\n⊢ ∃ a_1 ∈ l, ∃ b, (∃ S_1, b = S_1.flatten ∧ S_1.length = S.length ∧ ∀ y ∈ S_1, y ∈ ... | [
"case succ.mpr.cons.refl\nα : Type u_1\nl : Language α\na : List α\nS : List (List α)\nhS : a ∈ l ∧ ∀ x ∈ S, x ∈ l\nihn : ∀ {x : List α}, x ∈ l ^ S.length ↔ ∃ S_1, x = S_1.flatten ∧ S_1.length = S.length ∧ ∀ y ∈ S_1, y ∈ l\n⊢ ∃ a_1 ∈ l, ∃ b, (∃ S_1, b = S_1.flatten ∧ S_1.length = S.length ∧ ∀ y ∈ S_1, y ∈ l) ∧ a_1 ... | forall_mem_cons | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Computability.PartrecCode | {
"line": 715,
"column": 4
} | {
"line": 715,
"column": 38
} | {
"line": 715,
"column": 39
} | [
{
"pp": "case prec\ncf cg : Code\nhf : ∀ {n x : ℕ}, x ∈ cf.eval n → ∃ k, x ∈ evaln (k + 1) cf n\nhg : ∀ {n x : ℕ}, x ∈ cg.eval n → ∃ k, x ∈ evaln (k + 1) cg n\nn x n₁ n₂ : ℕ\n⊢ x ∈ Nat.rec (cf.eval n₁) (fun y IH ↦ IH.bind fun i ↦ cg.eval (Nat.pair n₁ (Nat.pair y i))) n₂ →\n ∃ k,\n n ≤ k ∧\n Nat.r... | [] | induction n₂ generalizing x n with | _private.Lean.Elab.Tactic.Induction.0.Lean.Elab.Tactic.evalInduction | null |
Mathlib.Computability.PartrecCode | {
"line": 748,
"column": 27
} | {
"line": 748,
"column": 85
} | {
"line": 748,
"column": 86
} | [
{
"pp": "cf : Code\nhf : ∀ {n x : ℕ}, x ∈ cf.eval n → ∃ k, x ∈ evaln (k + 1) cf n\nn y : ℕ\nIH :\n ∀ (m : ℕ),\n 0 ∈ cf.eval (Nat.pair (unpair n).1 (y + m)) →\n (∀ {m_1 : ℕ}, m_1 < y → ∃ a ∈ cf.eval (Nat.pair (unpair n).1 (m_1 + m)), ¬a = 0) →\n ∃ k, y + m ∈ evaln (k + 1) cf.rfind' (Nat.pair (unp... | [
"cf : Code\nhf : ∀ {n x : ℕ}, x ∈ cf.eval n → ∃ k, x ∈ evaln (k + 1) cf n\nn y : ℕ\nIH :\n ∀ (m : ℕ),\n 0 ∈ cf.eval (Nat.pair (unpair n).1 (y + m)) →\n (∀ {m_1 : ℕ}, m_1 < y → ∃ a ∈ cf.eval (Nat.pair (unpair n).1 (m_1 + m)), ¬a = 0) →\n ∃ k, y + m ∈ evaln (k + 1) cf.rfind' (Nat.pair (unpair n).1 m)\... | simpa using | Lean.Elab.Tactic.Simpa.evalSimpa | null |
Mathlib.Computability.PartrecCode | {
"line": 750,
"column": 10
} | {
"line": 750,
"column": 68
} | {
"line": 751,
"column": 12
} | [
{
"pp": "cf : Code\nhf : ∀ {n x : ℕ}, x ∈ cf.eval n → ∃ k, x ∈ evaln (k + 1) cf n\nn y : ℕ\nIH :\n ∀ (m : ℕ),\n 0 ∈ cf.eval (Nat.pair (unpair n).1 (y + m)) →\n (∀ {m_1 : ℕ}, m_1 < y → ∃ a ∈ cf.eval (Nat.pair (unpair n).1 (m_1 + m)), ¬a = 0) →\n ∃ k, y + m ∈ evaln (k + 1) cf.rfind' (Nat.pair (unp... | [
"cf : Code\nhf : ∀ {n x : ℕ}, x ∈ cf.eval n → ∃ k, x ∈ evaln (k + 1) cf n\nn y : ℕ\nIH :\n ∀ (m : ℕ),\n 0 ∈ cf.eval (Nat.pair (unpair n).1 (y + m)) →\n (∀ {m_1 : ℕ}, m_1 < y → ∃ a ∈ cf.eval (Nat.pair (unpair n).1 (m_1 + m)), ¬a = 0) →\n ∃ k, y + m ∈ evaln (k + 1) cf.rfind' (Nat.pair (unpair n).1 m)\... | simpa using | Lean.Elab.Tactic.Simpa.evalSimpa | null |
Mathlib.Computability.Language | {
"line": 305,
"column": 4
} | {
"line": 317,
"column": 58
} | {
"line": 318,
"column": 4
} | [
{
"pp": "case a\nα : Type u_1\nl m n : Language α\nhm : [] ∉ m\nh : l = m * l + n\n⊢ l ≤ m∗ * n",
"ppTerm": "?a✝",
"assigned": true,
"usedConstants": [
"Iff.mpr",
"Eq.mpr",
"MulOne.toOne",
"Semigroup.toMul",
"Language.instOne",
"HMul.hMul",
"Language.instAdd... | [
"case a\nα : Type u_1\nl m n : Language α\nhm : [] ∉ m\nh : l = m * l + n\n⊢ m∗ * n ≤ l"
] | · intro x hx
induction hlen : x.length using Nat.strong_induction_on generalizing x with | _ _ ih
subst hlen
rw [h] at hx
obtain hx | hx := hx
· obtain ⟨a, ha, b, hb, rfl⟩ := mem_mul.mp hx
rw [length_append] at ih
have hal : 0 < a.length := length_pos_iff.mpr <| ne_of_mem_o... | Lean.Elab.Tactic.evalTacticCDot | Lean.cdot |
Mathlib.Computability.ContextFreeGrammar | {
"line": 71,
"column": 2
} | {
"line": 78,
"column": 8
} | {
"line": 80,
"column": 0
} | [
{
"pp": "T : Type u_1\nN : Type u_2\nr : ContextFreeRule T N\nu v : List (Symbol T N)\nhr : r.Rewrites u v\n⊢ ∃ p q, u = p ++ [Symbol.nonterminal r.input] ++ q ∧ v = p ++ r.output ++ q",
"ppTerm": "?m.43",
"assigned": true,
"usedConstants": [
"ContextFreeRule.Rewrites",
"Symbol",
"... | [] | induction hr with
| head s =>
use [], s
simp
| cons x _ ih =>
rcases ih with ⟨p', q', rfl, rfl⟩
use x :: p', q'
simp | _private.Lean.Elab.Tactic.Induction.0.Lean.Elab.Tactic.evalInduction | Lean.Parser.Tactic.induction |
Mathlib.Computability.ContextFreeGrammar | {
"line": 71,
"column": 2
} | {
"line": 78,
"column": 8
} | {
"line": 80,
"column": 0
} | [
{
"pp": "T : Type u_1\nN : Type u_2\nr : ContextFreeRule T N\nu v : List (Symbol T N)\nhr : r.Rewrites u v\n⊢ ∃ p q, u = p ++ [Symbol.nonterminal r.input] ++ q ∧ v = p ++ r.output ++ q",
"ppTerm": "?m.43",
"assigned": true,
"usedConstants": [
"ContextFreeRule.Rewrites",
"Symbol",
"... | [] | induction hr with
| head s =>
use [], s
simp
| cons x _ ih =>
rcases ih with ⟨p', q', rfl, rfl⟩
use x :: p', q'
simp | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Computability.ContextFreeGrammar | {
"line": 71,
"column": 2
} | {
"line": 78,
"column": 8
} | {
"line": 80,
"column": 0
} | [
{
"pp": "T : Type u_1\nN : Type u_2\nr : ContextFreeRule T N\nu v : List (Symbol T N)\nhr : r.Rewrites u v\n⊢ ∃ p q, u = p ++ [Symbol.nonterminal r.input] ++ q ∧ v = p ++ r.output ++ q",
"ppTerm": "?m.43",
"assigned": true,
"usedConstants": [
"ContextFreeRule.Rewrites",
"Symbol",
"... | [] | induction hr with
| head s =>
use [], s
simp
| cons x _ ih =>
rcases ih with ⟨p', q', rfl, rfl⟩
use x :: p', q'
simp | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Computability.ContextFreeGrammar | {
"line": 81,
"column": 2
} | {
"line": 81,
"column": 13
} | {
"line": 81,
"column": 14
} | [
{
"pp": "T : Type u_1\nN : Type u_2\nr : ContextFreeRule T N\n⊢ r.Rewrites [Symbol.nonterminal r.input] r.output",
"ppTerm": "?m.11",
"assigned": false,
"usedConstants": [],
"usedFVars": [],
"usedGoals": []
}
] | [
"T : Type u_1\nN : Type u_2\nr : ContextFreeRule T N\n⊢ r.Rewrites [Symbol.nonterminal r.input] r.output"
] | simpa using | Lean.Elab.Tactic.Simpa.evalSimpa | null |
Mathlib.Computability.PartrecCode | {
"line": 758,
"column": 6
} | {
"line": 758,
"column": 47
} | {
"line": 759,
"column": 8
} | [
{
"pp": "case right\ncf : Code\nhf : ∀ {n x : ℕ}, x ∈ cf.eval n → ∃ k, x ∈ evaln (k + 1) cf n\nn y : ℕ\nIH :\n ∀ (m : ℕ),\n 0 ∈ cf.eval (Nat.pair (unpair n).1 (y + m)) →\n (∀ {m_1 : ℕ}, m_1 < y → ∃ a ∈ cf.eval (Nat.pair (unpair n).1 (m_1 + m)), ¬a = 0) →\n ∃ k, y + m ∈ evaln (k + 1) cf.rfind' (N... | [
"case right\ncf : Code\nhf : ∀ {n x : ℕ}, x ∈ cf.eval n → ∃ k, x ∈ evaln (k + 1) cf n\nn y : ℕ\nIH :\n ∀ (m : ℕ),\n 0 ∈ cf.eval (Nat.pair (unpair n).1 (y + m)) →\n (∀ {m_1 : ℕ}, m_1 < y → ∃ a ∈ cf.eval (Nat.pair (unpair n).1 (m_1 + m)), ¬a = 0) →\n ∃ k, y + m ∈ evaln (k + 1) cf.rfind' (Nat.pair (unp... | simpa using | Lean.Elab.Tactic.Simpa.evalSimpa | null |
Mathlib.Computability.ContextFreeGrammar | {
"line": 268,
"column": 23
} | {
"line": 268,
"column": 34
} | {
"line": 268,
"column": 35
} | [
{
"pp": "T : Type u_1\nN : Type u_2\nr : ContextFreeRule T N\ns : List (Symbol T N)\n⊢ r.reverse.Rewrites (Symbol.nonterminal r.input :: s).reverse (r.output ++ s).reverse",
"ppTerm": "?m.22",
"assigned": true,
"usedConstants": [
"ContextFreeRule.Rewrites",
"Eq.mpr",
"Symbol",
... | [
"T : Type u_1\nN : Type u_2\nr : ContextFreeRule T N\ns : List (Symbol T N)\n⊢ r.reverse.Rewrites (s.reverse ++ [Symbol.nonterminal r.input]) (s.reverse ++ r.output.reverse)"
] | simpa using | Lean.Elab.Tactic.Simpa.evalSimpa | null |
Mathlib.Computability.ContextFreeGrammar | {
"line": 269,
"column": 36
} | {
"line": 269,
"column": 47
} | {
"line": 269,
"column": 48
} | [
{
"pp": "T : Type u_1\nN : Type u_2\nr : ContextFreeRule T N\nx : Symbol T N\nu v : List (Symbol T N)\nh : r.Rewrites u v\n⊢ r.reverse.Rewrites (x :: u).reverse (x :: v).reverse",
"ppTerm": "?m.35",
"assigned": true,
"usedConstants": [
"ContextFreeRule.Rewrites",
"Eq.mpr",
"Symbol"... | [
"T : Type u_1\nN : Type u_2\nr : ContextFreeRule T N\nx : Symbol T N\nu v : List (Symbol T N)\nh : r.Rewrites u v\n⊢ r.reverse.Rewrites (u.reverse ++ [x]) (v.reverse ++ [x])"
] | simpa using | Lean.Elab.Tactic.Simpa.evalSimpa | null |
Mathlib.Computability.ContextFreeGrammar | {
"line": 272,
"column": 14
} | {
"line": 272,
"column": 25
} | {
"line": 272,
"column": 26
} | [
{
"pp": "T : Type u_1\nN : Type u_2\nr : ContextFreeRule T N\nu v : List (Symbol T N)\nh : r.reverse.Rewrites u.reverse v.reverse\n⊢ r.Rewrites u v",
"ppTerm": "?m.12",
"assigned": false,
"usedConstants": [],
"usedFVars": [],
"usedGoals": []
}
] | [
"T : Type u_1\nN : Type u_2\nr : ContextFreeRule T N\nu v : List (Symbol T N)\nh : r.reverse.Rewrites u.reverse v.reverse\n⊢ r.Rewrites u v"
] | simpa using | Lean.Elab.Tactic.Simpa.evalSimpa | null |
Mathlib.Computability.ContextFreeGrammar | {
"line": 349,
"column": 2
} | {
"line": 349,
"column": 13
} | {
"line": 349,
"column": 14
} | [
{
"pp": "T : Type u_1\nL : Language T\nh : L.reverse.IsContextFree\n⊢ L.IsContextFree",
"ppTerm": "?m.4",
"assigned": false,
"usedConstants": [],
"usedFVars": [],
"usedGoals": []
}
] | [
"T : Type u_1\nL : Language T\nh : L.reverse.IsContextFree\n⊢ L.IsContextFree"
] | simpa using | Lean.Elab.Tactic.Simpa.evalSimpa | null |
Mathlib.Computability.PartrecCode | {
"line": 918,
"column": 4
} | {
"line": 918,
"column": 15
} | {
"line": 918,
"column": 16
} | [
{
"pp": "case neg\nk : ℕ\nc : Code\nn : ℕ\nkn : ¬n < k\n⊢ (List.range k).length ≤ n",
"ppTerm": "?neg✝",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"congrArg",
"List.length_range",
"id",
"List.range",
"LE.le",
"instLENat",
"Nat",
"congrFun'",... | [
"case neg\nk : ℕ\nc : Code\nn : ℕ\nkn : ¬n < k\n⊢ k ≤ n"
] | simpa using | Lean.Elab.Tactic.Simpa.evalSimpa | null |
Mathlib.Data.Nat.Bitwise | {
"line": 158,
"column": 25
} | {
"line": 158,
"column": 36
} | {
"line": 158,
"column": 37
} | [
{
"pp": "b : Bool\nn : ℕ\nhn : (∀ (i : ℕ), n.testBit i = false) → n = 0\nh : ∀ (i : ℕ), (bit b n).testBit i = false\n⊢ b = false",
"ppTerm": "?m.24",
"assigned": false,
"usedConstants": [],
"usedFVars": [],
"usedGoals": []
}
] | [
"b : Bool\nn : ℕ\nhn : (∀ (i : ℕ), n.testBit i = false) → n = 0\nh : ∀ (i : ℕ), (bit b n).testBit i = false\n⊢ b = false"
] | simpa using | Lean.Elab.Tactic.Simpa.evalSimpa | null |
Mathlib.Data.Nat.Size | {
"line": 80,
"column": 94
} | {
"line": 88,
"column": 72
} | {
"line": 88,
"column": 72
} | [
{
"pp": "m n : ℕ\nh : m < 2 ^ n\n⊢ m.size ≤ n",
"ppTerm": "?m.24",
"assigned": true,
"usedConstants": [
"Nat.bit",
"instPowNat",
"Eq.mpr",
"congrArg",
"False.elim",
"Eq.mp",
"id",
"Nat.binaryRec'",
"Ne",
"instOfNatNat",
"LE.le",
... | [] | by
induction m using binaryRec' generalizing n with
| zero => simp
| bit b m e IH =>
rw [← Nat.bit_ne_zero_iff] at e
rw [size_bit e]
cases n with
| zero => exact (e (Nat.lt_one_iff.mp h)).elim
| succ n => exact succ_le_succ (IH (bit_lt_two_pow_succ_iff.mp h)) | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Data.Nat.Size | {
"line": 96,
"column": 2
} | {
"line": 96,
"column": 58
} | {
"line": 96,
"column": 59
} | [
{
"pp": "n : ℕ\n⊢ n.size = 0 ↔ n = 0",
"ppTerm": "?m.7",
"assigned": false,
"usedConstants": [],
"usedFVars": [],
"usedGoals": []
}
] | [
"n : ℕ\n⊢ n.size = 0 ↔ n = 0"
] | simpa using | Lean.Elab.Tactic.Simpa.evalSimpa | null |
Mathlib.Data.Nat.Size | {
"line": 99,
"column": 2
} | {
"line": 99,
"column": 42
} | {
"line": 99,
"column": 43
} | [
{
"pp": "n : ℕ\n⊢ (2 ^ n).size = n + 1",
"ppTerm": "?m.14",
"assigned": false,
"usedConstants": [],
"usedFVars": [],
"usedGoals": []
}
] | [
"n : ℕ\n⊢ (2 ^ n).size = n + 1"
] | simpa using | Lean.Elab.Tactic.Simpa.evalSimpa | null |
Mathlib.Data.Nat.Bitwise | {
"line": 312,
"column": 2
} | {
"line": 312,
"column": 38
} | {
"line": 313,
"column": 2
} | [
{
"pp": "m n : ℕ\n⊢ Even (m ^^^ n) ↔ (Even m ↔ Even n)",
"ppTerm": "?m.11",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"Nat.instXorOp",
"congrArg",
"_private.Mathlib.Data.Nat.Bitwise.0.Nat.even_xor._simp_1_1",
"id",
"Nat.instMod",
"instHMod",
"inst... | [
"m n : ℕ\n⊢ (m + n) % 2 = 0 ↔ (m % 2 = 0 ↔ n % 2 = 0)"
] | simp only [even_iff, xor_mod_two_eq] | Lean.Elab.Tactic.evalSimp | Lean.Parser.Tactic.simp |
Mathlib.Computability.Encoding | {
"line": 125,
"column": 6
} | {
"line": 125,
"column": 24
} | {
"line": 125,
"column": 24
} | [
{
"pp": "case pos\nn : PosNum\n⊢ (if\n (match Num.pos n with\n | Num.zero => []\n | Num.pos n => encodePosNum n) =\n [] then\n Num.zero\n else ↑n) =\n Num.pos n",
"ppTerm": "?pos",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"castPosNum",
... | [
"case pos\nn : PosNum\n⊢ (if\n (match Num.pos n with\n | Num.zero => []\n | Num.pos n => encodePosNum n) =\n [] then\n Num.zero\n else Num.pos n) =\n Num.pos n"
] | PosNum.cast_to_num | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Computability.NFA | {
"line": 212,
"column": 4
} | {
"line": 212,
"column": 18
} | {
"line": 213,
"column": 2
} | [
{
"pp": "case mp.inr\nα : Type u\nσ : Type v\nM : NFA α σ\nS T : Set σ\nx : List α\ns : σ\nhs : s ∈ M.accept\nh : s ∈ M.evalFrom T x\n⊢ x ∈ M.acceptsFrom S ∪ M.acceptsFrom T",
"ppTerm": "?mp.inr",
"assigned": true,
"usedConstants": [
"NFA.evalFrom",
"Membership.mem",
"NFA.accept",
... | [] | · right; tauto | Lean.Elab.Tactic.evalTacticCDot | Lean.cdot |
Mathlib.Data.Num.Lemmas | {
"line": 88,
"column": 12
} | {
"line": 88,
"column": 29
} | {
"line": 89,
"column": 2
} | [
{
"pp": "b : PosNum\n⊢ 1 + b.succ = (1 + b).succ",
"ppTerm": "?m.15",
"assigned": true,
"usedConstants": [
"congrArg",
"PosNum.instAdd",
"instOnePosNum",
"PosNum.succ",
"instHAdd",
"HAdd.hAdd",
"congr",
"True",
"eq_self",
"of_eq_true",
... | [] | by simp [one_add] | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Computability.PartrecCode | {
"line": 1038,
"column": 61
} | {
"line": 1038,
"column": 72
} | {
"line": 1038,
"column": 73
} | [
{
"pp": "x✝¹ x✝ : { f // Computable f }\nh : (fun f ↦ ⟨↑↑f, ⋯⟩) x✝¹ = (fun f ↦ ⟨↑↑f, ⋯⟩) x✝\n⊢ ↑↑x✝¹ = ↑↑x✝",
"ppTerm": "?m.37",
"assigned": false,
"usedConstants": [],
"usedFVars": [],
"usedGoals": []
}
] | [
"x✝¹ x✝ : { f // Computable f }\nh : (fun f ↦ ⟨↑↑f, ⋯⟩) x✝¹ = (fun f ↦ ⟨↑↑f, ⋯⟩) x✝\n⊢ ↑↑x✝¹ = ↑↑x✝"
] | simpa using | Lean.Elab.Tactic.Simpa.evalSimpa | null |
Mathlib.Data.List.ReduceOption | {
"line": 41,
"column": 17
} | {
"line": 41,
"column": 96
} | {
"line": 41,
"column": 97
} | [
{
"pp": "case cons.none\nα : Type u_1\nβ : Type u_2\nf : α → β\ntl : List (Option α)\nhl : (map (Option.map f) tl).reduceOption = map f tl.reduceOption\n⊢ (map (Option.map f) (none :: tl)).reduceOption = map f (none :: tl).reduceOption",
"ppTerm": "?cons.none",
"assigned": true,
"usedConstants": [
... | [
"case cons.none\nα : Type u_1\nβ : Type u_2\nf : α → β\ntl : List (Option α)\nhl : (map (Option.map f) tl).reduceOption = map f tl.reduceOption\n⊢ (map (Option.map f) tl).reduceOption = map f tl.reduceOption"
] | simpa using | Lean.Elab.Tactic.Simpa.evalSimpa | null |
Mathlib.Data.List.ReduceOption | {
"line": 41,
"column": 17
} | {
"line": 41,
"column": 96
} | {
"line": 41,
"column": 97
} | [
{
"pp": "case cons.some\nα : Type u_1\nβ : Type u_2\nf : α → β\ntl : List (Option α)\nhl : (map (Option.map f) tl).reduceOption = map f tl.reduceOption\nval✝ : α\n⊢ (map (Option.map f) (some val✝ :: tl)).reduceOption = map f (some val✝ :: tl).reduceOption",
"ppTerm": "?cons.some",
"assigned": true,
... | [
"case cons.some\nα : Type u_1\nβ : Type u_2\nf : α → β\ntl : List (Option α)\nhl : (map (Option.map f) tl).reduceOption = map f tl.reduceOption\nval✝ : α\n⊢ (map (Option.map f) tl).reduceOption = map f tl.reduceOption"
] | simpa using | Lean.Elab.Tactic.Simpa.evalSimpa | null |
Mathlib.Data.List.ReduceOption | {
"line": 54,
"column": 2
} | {
"line": 59,
"column": 9
} | {
"line": 61,
"column": 0
} | [
{
"pp": "α : Type u_1\nl : List (Option α)\n⊢ l.reduceOption = [] ↔ ∃ n, l = replicate n none",
"ppTerm": "?m.9",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"List.replicate",
"List.filterMap_eq_nil_iff",
"congrArg",
"List.eq_replicate_of_mem",
"Membership.mem"... | [] | dsimp [reduceOption]
rw [filterMap_eq_nil_iff]
constructor
· intro h
exact ⟨l.length, eq_replicate_of_mem h⟩
· grind | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Data.List.ReduceOption | {
"line": 54,
"column": 2
} | {
"line": 59,
"column": 9
} | {
"line": 61,
"column": 0
} | [
{
"pp": "α : Type u_1\nl : List (Option α)\n⊢ l.reduceOption = [] ↔ ∃ n, l = replicate n none",
"ppTerm": "?m.9",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"List.replicate",
"List.filterMap_eq_nil_iff",
"congrArg",
"List.eq_replicate_of_mem",
"Membership.mem"... | [] | dsimp [reduceOption]
rw [filterMap_eq_nil_iff]
constructor
· intro h
exact ⟨l.length, eq_replicate_of_mem h⟩
· grind | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Computability.NFA | {
"line": 306,
"column": 25
} | {
"line": 306,
"column": 43
} | {
"line": 306,
"column": 44
} | [
{
"pp": "α : Type u\nσ : Type v\nM : NFA α σ\ns✝ t✝ : σ\nx✝ : List α\np : Nonempty (M.Path s✝ t✝ x✝)\nt s s' : σ\na : α\nx : List α\nh₁ : s' ∈ M.step s a\nh₂ : M.Path s' t x\n⊢ t ∈ M.evalFrom (M.stepSet {s} a) x",
"ppTerm": "?m.307",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"NFA.st... | [
"α : Type u\nσ : Type v\nM : NFA α σ\ns✝ t✝ : σ\nx✝ : List α\np : Nonempty (M.Path s✝ t✝ x✝)\nt s s' : σ\na : α\nx : List α\nh₁ : s' ∈ M.step s a\nh₂ : M.Path s' t x\n⊢ t ∈ M.evalFrom (M.step s a) x"
] | stepSet_singleton, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Data.Num.Lemmas | {
"line": 147,
"column": 6
} | {
"line": 147,
"column": 56
} | {
"line": 148,
"column": 4
} | [
{
"pp": "case lt\na b : PosNum\nthis : ↑a < ↑b\n⊢ ↑a + ↑a < ↑b + ↑b + 1",
"ppTerm": "?lt",
"assigned": true,
"usedConstants": [
"castPosNum",
"Nat.instOne",
"Nat.add_lt_add",
"instHAdd",
"HAdd.hAdd",
"Nat",
"instAddNat",
"Nat.le_succ_of_le",
"Nat... | [] | exact Nat.le_succ_of_le (Nat.add_lt_add this this) | Lean.Elab.Tactic.evalExact | Lean.Parser.Tactic.exact |
Mathlib.Data.Num.Lemmas | {
"line": 147,
"column": 6
} | {
"line": 147,
"column": 56
} | {
"line": 148,
"column": 4
} | [
{
"pp": "case lt\na b : PosNum\nthis : ↑a < ↑b\n⊢ ↑a + ↑a < ↑b + ↑b + 1",
"ppTerm": "?lt",
"assigned": true,
"usedConstants": [
"castPosNum",
"Nat.instOne",
"Nat.add_lt_add",
"instHAdd",
"HAdd.hAdd",
"Nat",
"instAddNat",
"Nat.le_succ_of_le",
"Nat... | [] | exact Nat.le_succ_of_le (Nat.add_lt_add this this) | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Data.Num.Lemmas | {
"line": 147,
"column": 6
} | {
"line": 147,
"column": 56
} | {
"line": 148,
"column": 4
} | [
{
"pp": "case lt\na b : PosNum\nthis : ↑a < ↑b\n⊢ ↑a + ↑a < ↑b + ↑b + 1",
"ppTerm": "?lt",
"assigned": true,
"usedConstants": [
"castPosNum",
"Nat.instOne",
"Nat.add_lt_add",
"instHAdd",
"HAdd.hAdd",
"Nat",
"instAddNat",
"Nat.le_succ_of_le",
"Nat... | [] | exact Nat.le_succ_of_le (Nat.add_lt_add this this) | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Data.Num.Lemmas | {
"line": 157,
"column": 6
} | {
"line": 157,
"column": 56
} | {
"line": 158,
"column": 2
} | [
{
"pp": "case gt\na b : PosNum\nthis : ↑b < ↑a\n⊢ ↑b + ↑b < ↑a + ↑a + 1",
"ppTerm": "?gt",
"assigned": true,
"usedConstants": [
"castPosNum",
"Nat.instOne",
"Nat.add_lt_add",
"instHAdd",
"HAdd.hAdd",
"Nat",
"instAddNat",
"Nat.le_succ_of_le",
"Nat... | [] | exact Nat.le_succ_of_le (Nat.add_lt_add this this) | Lean.Elab.Tactic.evalExact | Lean.Parser.Tactic.exact |
Mathlib.Data.Num.Lemmas | {
"line": 157,
"column": 6
} | {
"line": 157,
"column": 56
} | {
"line": 158,
"column": 2
} | [
{
"pp": "case gt\na b : PosNum\nthis : ↑b < ↑a\n⊢ ↑b + ↑b < ↑a + ↑a + 1",
"ppTerm": "?gt",
"assigned": true,
"usedConstants": [
"castPosNum",
"Nat.instOne",
"Nat.add_lt_add",
"instHAdd",
"HAdd.hAdd",
"Nat",
"instAddNat",
"Nat.le_succ_of_le",
"Nat... | [] | exact Nat.le_succ_of_le (Nat.add_lt_add this this) | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Data.Num.Lemmas | {
"line": 157,
"column": 6
} | {
"line": 157,
"column": 56
} | {
"line": 158,
"column": 2
} | [
{
"pp": "case gt\na b : PosNum\nthis : ↑b < ↑a\n⊢ ↑b + ↑b < ↑a + ↑a + 1",
"ppTerm": "?gt",
"assigned": true,
"usedConstants": [
"castPosNum",
"Nat.instOne",
"Nat.add_lt_add",
"instHAdd",
"HAdd.hAdd",
"Nat",
"instAddNat",
"Nat.le_succ_of_le",
"Nat... | [] | exact Nat.le_succ_of_le (Nat.add_lt_add this this) | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Computability.AkraBazzi.GrowsPolynomially | {
"line": 661,
"column": 24
} | {
"line": 661,
"column": 58
} | {
"line": 662,
"column": 6
} | [
{
"pp": "f g : ℝ → ℝ\nhg✝ : GrowsPolynomially g\nhf : f =Θ[atTop] g\nhf' : ∀ᶠ (x : ℝ) in atTop, 0 ≤ f x\nb : ℝ\nhb : b ∈ Set.Ioo 0 1\nhb_pos : 0 < b\nc₁ : ℝ\nhc₁_pos : 0 < c₁\nhf_lb : ∀ᶠ (x : ℝ) in atTop, c₁ * ‖g x‖ ≤ ‖f x‖\nc₂ : ℝ\nhc₂_pos : 0 < c₂\nhf_ub : ∀ᶠ (x : ℝ) in atTop, ‖f x‖ ≤ c₂ * ‖g x‖\nc₃ : ℝ\nhc₃_... | [] | by gcongr; exact (hg_bound u hu).1 | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Computability.EpsilonNFA | {
"line": 255,
"column": 4
} | {
"line": 255,
"column": 26
} | {
"line": 256,
"column": 4
} | [
{
"pp": "α : Type u\nσ : Type v\nM : εNFA α σ\nx : List α\ns₂ : σ\nleft✝ : s₂ ∈ M.accept\nh : ∃ t ∈ M.start, s₂ ∈ M.evalFrom {t} x\n⊢ ∃ s₁ s₂ x', s₁ ∈ M.start ∧ s₂ ∈ M.accept ∧ x'.reduceOption = x ∧ M.IsPath s₁ s₂ x'",
"ppTerm": "?m.80",
"assigned": true,
"usedConstants": [
"Membership.mem",
... | [
"α : Type u\nσ : Type v\nM : εNFA α σ\nx : List α\ns₂ : σ\nleft✝¹ : s₂ ∈ M.accept\ns₁ : σ\nleft✝ : s₁ ∈ M.start\nh : s₂ ∈ M.evalFrom {s₁} x\n⊢ ∃ s₁ s₂ x', s₁ ∈ M.start ∧ s₂ ∈ M.accept ∧ x'.reduceOption = x ∧ M.IsPath s₁ s₂ x'"
] | obtain ⟨s₁, _, h⟩ := h | _private.Lean.Elab.Tactic.RCases.0.Lean.Elab.Tactic.RCases.evalObtain | Lean.Parser.Tactic.obtain |
Mathlib.Computability.EpsilonNFA | {
"line": 311,
"column": 2
} | {
"line": 311,
"column": 9
} | {
"line": 312,
"column": 2
} | [
{
"pp": "α : Type u\nσ : Type v\nM : NFA α σ\nstart : Set σ\n⊢ M.toεNFA.stepSet = M.stepSet",
"ppTerm": "?m.31",
"assigned": true,
"usedConstants": [
"Set.ext",
"εNFA.stepSet",
"funext",
"NFA.stepSet",
"NFA.toεNFA",
"Set"
],
"usedFVars": [
"σ",
... | [
"α : Type u\nσ : Type v\nM : NFA α σ\nstart S : Set σ\ns : α\nx✝ : σ\n⊢ x✝ ∈ M.toεNFA.stepSet S s ↔ x✝ ∈ M.stepSet S s"
] | ext S s | _private.Lean.Elab.Tactic.Ext.0.Lean.Elab.Tactic.Ext.evalExt | Lean.Elab.Tactic.Ext.ext |
Mathlib.Computability.Halting | {
"line": 57,
"column": 36
} | {
"line": 57,
"column": 89
} | {
"line": 58,
"column": 12
} | [
{
"pp": "case inl\nH : ∀ (cf cg : Code), cf.eval = cg.eval → (cf ∈ ∅ ↔ cg ∈ ∅)\nhC : ∀ (f : Code), f ∈ ∅ ↔ f.eval ∈ eval '' ∅\n⊢ ComputablePred fun c ↦ c ∈ ∅",
"ppTerm": "?inl",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"False",
"Set.mem_empty_iff_false._simp_1",
"congrA... | [
"case inl\nH : ∀ (cf cg : Code), cf.eval = cg.eval → (cf ∈ ∅ ↔ cg ∈ ∅)\nhC : ∀ (f : Code), f ∈ ∅ ↔ f.eval ∈ eval '' ∅\n⊢ Computable fun a ↦ false"
] | simpa using | Lean.Elab.Tactic.Simpa.evalSimpa | null |
Mathlib.Computability.Halting | {
"line": 57,
"column": 36
} | {
"line": 57,
"column": 89
} | {
"line": 58,
"column": 12
} | [
{
"pp": "case inr\nH : ∀ (cf cg : Code), cf.eval = cg.eval → (cf ∈ Set.univ ↔ cg ∈ Set.univ)\nhC : ∀ (f : Code), f ∈ Set.univ ↔ f.eval ∈ eval '' Set.univ\n⊢ ComputablePred fun c ↦ c ∈ Set.univ",
"ppTerm": "?inr",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"instDecidableTrue",
"... | [
"case inr\nH : ∀ (cf cg : Code), cf.eval = cg.eval → (cf ∈ Set.univ ↔ cg ∈ Set.univ)\nhC : ∀ (f : Code), f ∈ Set.univ ↔ f.eval ∈ eval '' Set.univ\n⊢ Computable fun a ↦ true"
] | simpa using | Lean.Elab.Tactic.Simpa.evalSimpa | null |
Mathlib.Computability.RE | {
"line": 39,
"column": 2
} | {
"line": 44,
"column": 56
} | {
"line": 45,
"column": 2
} | [
{
"pp": "cf : Code\nhf : Nat.Partrec cf.eval\ncg : Code\nhg : Nat.Partrec cg.eval\nthis : Nat.Partrec fun n ↦ rfindOpt fun k ↦ Code.evaln k cf n <|> Code.evaln k cg n\nn : ℕ\n⊢ (∀ x ∈ rfindOpt fun k ↦ Code.evaln k cf n <|> Code.evaln k cg n, x ∈ cf.eval n ∨ x ∈ cg.eval n) ∧\n ((rfindOpt fun k ↦ Code.evaln k ... | [
"cf : Code\nhf : Nat.Partrec cf.eval\ncg : Code\nhg : Nat.Partrec cg.eval\nthis✝ : Nat.Partrec fun n ↦ rfindOpt fun k ↦ Code.evaln k cf n <|> Code.evaln k cg n\nn : ℕ\nthis : ∀ x ∈ rfindOpt fun k ↦ Code.evaln k cf n <|> Code.evaln k cg n, x ∈ cf.eval n ∨ x ∈ cg.eval n\n⊢ (∀ x ∈ rfindOpt fun k ↦ Code.evaln k cf n <|... | have : ∀ x ∈ rfindOpt fun k ↦ Code.evaln k cf n <|> Code.evaln k cg n,
x ∈ Code.eval cf n ∨ x ∈ Code.eval cg n := by
intro x h
obtain ⟨k, e⟩ := Nat.rfindOpt_spec h
rw [Option.mem_def, Option.orElse_eq_some, ← Option.mem_def, ← Option.mem_def] at e
obtain e | ⟨-, e⟩ := e <;> simp [Code.evaln_sound ... | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_tacticHave___1 | Lean.Parser.Tactic.tacticHave__ |
Mathlib.Data.Num.Lemmas | {
"line": 538,
"column": 21
} | {
"line": 538,
"column": 45
} | {
"line": 539,
"column": 2
} | [
{
"pp": "α : Type u_1\n⊢ ∀ (a b c : PosNum), a * (b + c) = a * b + a * c",
"ppTerm": "?m.4",
"assigned": true,
"usedConstants": [
"Distrib.leftDistribClass",
"Eq.mpr",
"castPosNum",
"HMul.hMul",
"Nat.instOne",
"congrArg",
"PosNum.instAdd",
"id",
... | [] | transfer; simp [mul_add] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Data.Num.Lemmas | {
"line": 538,
"column": 21
} | {
"line": 538,
"column": 45
} | {
"line": 539,
"column": 2
} | [
{
"pp": "α : Type u_1\n⊢ ∀ (a b c : PosNum), a * (b + c) = a * b + a * c",
"ppTerm": "?m.4",
"assigned": true,
"usedConstants": [
"Distrib.leftDistribClass",
"Eq.mpr",
"castPosNum",
"HMul.hMul",
"Nat.instOne",
"congrArg",
"PosNum.instAdd",
"id",
... | [] | transfer; simp [mul_add] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Data.Num.Lemmas | {
"line": 608,
"column": 27
} | {
"line": 609,
"column": 40
} | {
"line": 611,
"column": 0
} | [
{
"pp": "α : Type u_1\ninst✝² : Semiring α\ninst✝¹ : LinearOrder α\ninst✝ : IsStrictOrderedRing α\nm n : PosNum\n⊢ ↑m ≤ ↑n ↔ m ≤ n",
"ppTerm": "?m.7",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"NonAssocSemiring.toAddCommMonoidWithOne",
"castPosNum",
"Preorder.toLT",
... | [] | by
rw [← not_lt]; exact not_congr cast_lt | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Computability.PartrecBasis | {
"line": 80,
"column": 2
} | {
"line": 80,
"column": 48
} | {
"line": 80,
"column": 49
} | [
{
"pp": "n : ℕ\nf : List.Vector ℕ n →. ℕ\ng : List.Vector ℕ (n + 1) → ℕ\nhf : Partrec' f\nhg : Partrec' ↑g\n⊢ Partrec' fun v ↦ Part.map (fun a ↦ g (a ::ᵥ v)) (f v)",
"ppTerm": "?m.21",
"assigned": true,
"usedConstants": [
"Part",
"Eq.mpr",
"congrArg",
"Part.bind",
"Part... | [
"n : ℕ\nf : List.Vector ℕ n →. ℕ\ng : List.Vector ℕ (n + 1) → ℕ\nhf : Partrec' f\nhg : Partrec' ↑g\n⊢ Partrec' fun v ↦ (f v).bind fun y ↦ Part.some (g (y ::ᵥ v))"
] | simpa using | Lean.Elab.Tactic.Simpa.evalSimpa | null |
Mathlib.Computability.PartrecBasis | {
"line": 103,
"column": 2
} | {
"line": 103,
"column": 13
} | {
"line": 103,
"column": 14
} | [
{
"pp": "n : ℕ\nf : ℕ →. ℕ\ng : List.Vector ℕ n → ℕ\nhf : Partrec' fun v ↦ f v.head\nhg : Partrec' ↑g\n⊢ Partrec' fun v ↦ f (g v)",
"ppTerm": "?m.8",
"assigned": false,
"usedConstants": [],
"usedFVars": [],
"usedGoals": []
}
] | [
"n : ℕ\nf : ℕ →. ℕ\ng : List.Vector ℕ n → ℕ\nhf : Partrec' fun v ↦ f v.head\nhg : Partrec' ↑g\n⊢ Partrec' fun v ↦ f (g v)"
] | simpa using | Lean.Elab.Tactic.Simpa.evalSimpa | null |
Mathlib.Data.Num.Lemmas | {
"line": 742,
"column": 27
} | {
"line": 743,
"column": 40
} | {
"line": 745,
"column": 0
} | [
{
"pp": "α : Type u_1\ninst✝² : Semiring α\ninst✝¹ : LinearOrder α\ninst✝ : IsStrictOrderedRing α\nm n : Num\n⊢ ↑m ≤ ↑n ↔ m ≤ n",
"ppTerm": "?m.7",
"assigned": true,
"usedConstants": [
"Num.cast_lt",
"Eq.mpr",
"NonAssocSemiring.toAddCommMonoidWithOne",
"Preorder.toLT",
... | [] | by
rw [← not_lt]; exact not_congr cast_lt | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Computability.PartrecBasis | {
"line": 138,
"column": 4
} | {
"line": 138,
"column": 34
} | {
"line": 139,
"column": 6
} | [
{
"pp": "c : Code\nhf : Nat.Partrec c.eval\n⊢ Partrec' fun v ↦ c.eval v.head",
"ppTerm": "?m.46",
"assigned": true,
"usedConstants": [
"Part",
"Eq.mpr",
"Nat.Partrec.Code.evaln",
"congrArg",
"List.Vector.head",
"List.Vector",
"id",
"instOfNatNat",
... | [
"c : Code\nhf : Nat.Partrec c.eval\n⊢ Partrec' fun v ↦ Nat.rfindOpt fun k ↦ evaln k c v.head"
] | simpa using | Lean.Elab.Tactic.Simpa.evalSimpa | null |
Mathlib.Computability.PartrecBasis | {
"line": 164,
"column": 15
} | {
"line": 164,
"column": 42
} | {
"line": 164,
"column": 43
} | [
{
"pp": "m n : ℕ\nf : List.Vector ℕ m → List.Vector ℕ n\nh : Vec f\n⊢ Computable f",
"ppTerm": "?m.11",
"assigned": false,
"usedConstants": [],
"usedFVars": [],
"usedGoals": []
}
] | [
"m n : ℕ\nf : List.Vector ℕ m → List.Vector ℕ n\nh : Vec f\n⊢ Computable f"
] | simpa using | Lean.Elab.Tactic.Simpa.evalSimpa | null |
Mathlib.Computability.RE | {
"line": 198,
"column": 53
} | {
"line": 198,
"column": 64
} | {
"line": 198,
"column": 65
} | [
{
"pp": "α : Type u_1\ninst✝ : Primcodable α\nf : α → Bool\nh : Computable f\n⊢ Computable fun a ↦ decide ((fun a ↦ f a = true) a)",
"ppTerm": "?m.69",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"congrArg",
"inferInstance",
"id",
"instDecidableEqBool",
"Bool.t... | [
"α : Type u_1\ninst✝ : Primcodable α\nf : α → Bool\nh : Computable f\n⊢ Computable fun a ↦ f a"
] | simpa using | Lean.Elab.Tactic.Simpa.evalSimpa | null |
Mathlib.Computability.RE | {
"line": 209,
"column": 2
} | {
"line": 209,
"column": 32
} | {
"line": 209,
"column": 33
} | [
{
"pp": "f₁ f₂ : ℕ → ℕ\nhf₁ : Computable f₁\nhf₂ : Computable f₂\nc : ℕ → Prop\ninst✝ : DecidablePred c\nhc : ComputablePred c\n⊢ Computable fun k ↦ if c k then f₁ k else f₂ k",
"ppTerm": "?m.21",
"assigned": false,
"usedConstants": [],
"usedFVars": [],
"usedGoals": []
}
] | [
"f₁ f₂ : ℕ → ℕ\nhf₁ : Computable f₁\nhf₂ : Computable f₂\nc : ℕ → Prop\ninst✝ : DecidablePred c\nhc : ComputablePred c\n⊢ Computable fun k ↦ if c k then f₁ k else f₂ k"
] | simpa using | Lean.Elab.Tactic.Simpa.evalSimpa | null |
Mathlib.Computability.TuringMachine.Tape | {
"line": 267,
"column": 4
} | {
"line": 268,
"column": 70
} | {
"line": 269,
"column": 2
} | [
{
"pp": "case zero\nΓ : Type u_1\ninst✝ : Inhabited Γ\nf : Γ → Γ\ni : ℕ\nL : ListBlank Γ\n⊢ (modifyNth f 0 L).nth i = if i = 0 then f (L.nth i) else L.nth i",
"ppTerm": "?zero",
"assigned": true,
"usedConstants": [
"Turing.ListBlank.modifyNth",
"Turing.ListBlank.nth_zero",
"False",... | [] | cases i <;> simp only [ListBlank.nth_zero, if_true, ListBlank.head_cons, ListBlank.modifyNth,
ListBlank.nth_succ, if_false, ListBlank.tail_cons, reduceCtorEq] | Lean.Parser.Tactic.«_aux_Init_Tactics___macroRules_Lean_Parser_Tactic_tactic_<;>__1» | Lean.Parser.Tactic.«tactic_<;>_» |
Mathlib.Computability.TuringMachine.Tape | {
"line": 267,
"column": 4
} | {
"line": 268,
"column": 70
} | {
"line": 269,
"column": 2
} | [
{
"pp": "case zero\nΓ : Type u_1\ninst✝ : Inhabited Γ\nf : Γ → Γ\ni : ℕ\nL : ListBlank Γ\n⊢ (modifyNth f 0 L).nth i = if i = 0 then f (L.nth i) else L.nth i",
"ppTerm": "?zero",
"assigned": true,
"usedConstants": [
"Turing.ListBlank.modifyNth",
"Turing.ListBlank.nth_zero",
"False",... | [] | cases i <;> simp only [ListBlank.nth_zero, if_true, ListBlank.head_cons, ListBlank.modifyNth,
ListBlank.nth_succ, if_false, ListBlank.tail_cons, reduceCtorEq] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Computability.TuringMachine.Tape | {
"line": 267,
"column": 4
} | {
"line": 268,
"column": 70
} | {
"line": 269,
"column": 2
} | [
{
"pp": "case zero\nΓ : Type u_1\ninst✝ : Inhabited Γ\nf : Γ → Γ\ni : ℕ\nL : ListBlank Γ\n⊢ (modifyNth f 0 L).nth i = if i = 0 then f (L.nth i) else L.nth i",
"ppTerm": "?zero",
"assigned": true,
"usedConstants": [
"Turing.ListBlank.modifyNth",
"Turing.ListBlank.nth_zero",
"False",... | [] | cases i <;> simp only [ListBlank.nth_zero, if_true, ListBlank.head_cons, ListBlank.modifyNth,
ListBlank.nth_succ, if_false, ListBlank.tail_cons, reduceCtorEq] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Data.Num.Lemmas | {
"line": 779,
"column": 4
} | {
"line": 779,
"column": 35
} | {
"line": 779,
"column": 36
} | [
{
"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 (... | [
"case pos.pos.one\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 (pos m) (... | induction m generalizing n with | _private.Lean.Elab.Tactic.Induction.0.Lean.Elab.Tactic.evalInduction | null |
Mathlib.Computability.TuringMachine.Tape | {
"line": 509,
"column": 2
} | {
"line": 510,
"column": 65
} | {
"line": 512,
"column": 0
} | [
{
"pp": "Γ : Type u_1\ninst✝ : Inhabited Γ\nT : Tape Γ\nn : ℕ\n⊢ T.right₀.nth n = T.nth ↑n",
"ppTerm": "?m.10",
"assigned": true,
"usedConstants": [
"Turing.ListBlank.nth_zero",
"congrArg",
"Turing.Tape.nth",
"Turing.ListBlank.nth_succ",
"instOfNatNat",
"Int",
... | [] | cases n <;> simp only [Tape.nth, Tape.right₀, ListBlank.nth_zero,
ListBlank.nth_succ, ListBlank.head_cons, ListBlank.tail_cons] | Lean.Parser.Tactic.«_aux_Init_Tactics___macroRules_Lean_Parser_Tactic_tactic_<;>__1» | Lean.Parser.Tactic.«tactic_<;>_» |
Mathlib.Computability.TuringMachine.Tape | {
"line": 509,
"column": 2
} | {
"line": 510,
"column": 65
} | {
"line": 512,
"column": 0
} | [
{
"pp": "Γ : Type u_1\ninst✝ : Inhabited Γ\nT : Tape Γ\nn : ℕ\n⊢ T.right₀.nth n = T.nth ↑n",
"ppTerm": "?m.10",
"assigned": true,
"usedConstants": [
"Turing.ListBlank.nth_zero",
"congrArg",
"Turing.Tape.nth",
"Turing.ListBlank.nth_succ",
"instOfNatNat",
"Int",
... | [] | cases n <;> simp only [Tape.nth, Tape.right₀, ListBlank.nth_zero,
ListBlank.nth_succ, ListBlank.head_cons, ListBlank.tail_cons] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Computability.TuringMachine.Tape | {
"line": 509,
"column": 2
} | {
"line": 510,
"column": 65
} | {
"line": 512,
"column": 0
} | [
{
"pp": "Γ : Type u_1\ninst✝ : Inhabited Γ\nT : Tape Γ\nn : ℕ\n⊢ T.right₀.nth n = T.nth ↑n",
"ppTerm": "?m.10",
"assigned": true,
"usedConstants": [
"Turing.ListBlank.nth_zero",
"congrArg",
"Turing.Tape.nth",
"Turing.ListBlank.nth_succ",
"instOfNatNat",
"Int",
... | [] | cases n <;> simp only [Tape.nth, Tape.right₀, ListBlank.nth_zero,
ListBlank.nth_succ, ListBlank.head_cons, ListBlank.tail_cons] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Computability.RecursiveIn | {
"line": 88,
"column": 86
} | {
"line": 89,
"column": 34
} | {
"line": 91,
"column": 0
} | [
{
"pp": "f : ℕ →. ℕ\nO : Set (ℕ →. ℕ)\n⊢ RecursiveIn O f ↔ Nat.RecursiveIn O f",
"ppTerm": "?m.6",
"assigned": true,
"usedConstants": [
"Part",
"congrArg",
"Part.bind",
"Primcodable.ofDenumerable",
"Part.some",
"Part.bind_some",
"RecursiveIn",
"iff_sel... | [] | by
simp [RecursiveIn, Part.map_id'] | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Computability.RecursiveIn | {
"line": 208,
"column": 31
} | {
"line": 208,
"column": 69
} | {
"line": 208,
"column": 70
} | [
{
"pp": "α : Type u_1\nσ : Type u_4\ninst✝¹ : Primcodable α\ninst✝ : Primcodable σ\nO O' : Set (ℕ →. ℕ)\nf : α →. σ\nhf : RecursiveIn O f\nhO : ∀ g ∈ O, RecursiveIn O' g\n⊢ ∀ g ∈ O, Nat.RecursiveIn O' g",
"ppTerm": "?m.22",
"assigned": false,
"usedConstants": [],
"usedFVars": [],
"usedGoals"... | [
"α : Type u_1\nσ : Type u_4\ninst✝¹ : Primcodable α\ninst✝ : Primcodable σ\nO O' : Set (ℕ →. ℕ)\nf : α →. σ\nhf : RecursiveIn O f\nhO : ∀ g ∈ O, RecursiveIn O' g\n⊢ ∀ g ∈ O, Nat.RecursiveIn O' g"
] | simpa using | Lean.Elab.Tactic.Simpa.evalSimpa | null |
Mathlib.Computability.Reduce | {
"line": 130,
"column": 31
} | {
"line": 130,
"column": 42
} | {
"line": 130,
"column": 43
} | [
{
"pp": "α : Type u_1\nβ : Type u_2\ninst✝¹ : Primcodable α\ninst✝ : Primcodable β\np : α → Prop\nf : α → β\nc : Computable f\ng : β → Bool\nhg : Computable g\nh₂ : ComputablePred fun a ↦ g a = true\nhf : ∀ (a : α), p a ↔ (fun a ↦ g a = true) (f a)\n⊢ Computable fun a ↦ decide ((fun a ↦ (fun a ↦ g a = true) (f ... | [
"α : Type u_1\nβ : Type u_2\ninst✝¹ : Primcodable α\ninst✝ : Primcodable β\np : α → Prop\nf : α → β\nc : Computable f\ng : β → Bool\nhg : Computable g\nh₂ : ComputablePred fun a ↦ g a = true\nhf : ∀ (a : α), p a ↔ (fun a ↦ g a = true) (f a)\n⊢ Computable fun a ↦ g (f a)"
] | simpa using | Lean.Elab.Tactic.Simpa.evalSimpa | null |
Mathlib.Computability.RecursiveIn | {
"line": 219,
"column": 40
} | {
"line": 219,
"column": 74
} | {
"line": 219,
"column": 75
} | [
{
"pp": "α : Type u_1\nσ : Type u_4\ninst✝¹ : Primcodable α\ninst✝ : Primcodable σ\nf : α →. σ\nO : Set (ℕ →. ℕ)\nhO : ∀ g ∈ O, Partrec g\nhf : RecursiveIn O f\n⊢ ∀ g ∈ O, Nat.Partrec g",
"ppTerm": "?m.19",
"assigned": false,
"usedConstants": [],
"usedFVars": [],
"usedGoals": []
}
] | [
"α : Type u_1\nσ : Type u_4\ninst✝¹ : Primcodable α\ninst✝ : Primcodable σ\nf : α →. σ\nO : Set (ℕ →. ℕ)\nhO : ∀ g ∈ O, Partrec g\nhf : RecursiveIn O f\n⊢ ∀ g ∈ O, Nat.Partrec g"
] | simpa using | Lean.Elab.Tactic.Simpa.evalSimpa | null |
Mathlib.Computability.Reduce | {
"line": 380,
"column": 2
} | {
"line": 380,
"column": 13
} | {
"line": 381,
"column": 2
} | [
{
"pp": "case h.h\np✝¹ p✝ : Set ℕ\n⊢ of p✝¹ ≤ of p✝ → of p✝ ≤ of p✝¹ → of p✝¹ = of p✝",
"ppTerm": "?h.h",
"assigned": true,
"usedConstants": [
"ManyOneDegree.instLE",
"Primcodable.ofDenumerable",
"instInhabitedNat",
"LE.le",
"Nat",
"ManyOneDegree",
"Denumera... | [
"case h.h\np✝¹ p✝ : Set ℕ\nhp : of p✝¹ ≤ of p✝\nhq : of p✝ ≤ of p✝¹\n⊢ of p✝¹ = of p✝"
] | intro hp hq | Lean.Elab.Tactic.evalIntro | Lean.Parser.Tactic.intro |
Mathlib.Computability.Reduce | {
"line": 425,
"column": 2
} | {
"line": 425,
"column": 39
} | {
"line": 425,
"column": 40
} | [
{
"pp": "case h.h.h\np✝² p✝¹ p✝ : Set ℕ\n⊢ of p✝² + of p✝¹ ≤ of p✝ ↔ of p✝² ≤ of p✝ ∧ of p✝¹ ≤ of p✝",
"ppTerm": "?h.h.h",
"assigned": true,
"usedConstants": [
"ManyOneDegree.instLE",
"Eq.mpr",
"instInhabitedOfMonad",
"congrArg",
"Primcodable.ofDenumerable",
"_pri... | [
"case h.h.h\np✝² p✝¹ p✝ : Set ℕ\n⊢ p✝² ⊕' p✝¹ ≤₀ p✝ ↔ p✝² ≤₀ p✝ ∧ p✝¹ ≤₀ p✝"
] | simpa using | Lean.Elab.Tactic.Simpa.evalSimpa | null |
Mathlib.Computability.TuringMachine.PostTuringMachine | {
"line": 579,
"column": 16
} | {
"line": 579,
"column": 44
} | {
"line": 580,
"column": 6
} | [
{
"pp": "case right.some.some.move.refl\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 : Γ\nv' : σ\nval✝ : TM1.Stmt Γ Λ σ\nd : Dir\nh₂ : some (TM1.Stmt.move d val✝) ∈ TM1.stmts M S\nhs : TM1... | [
"case right.some.some.move.refl\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 : Γ\nv' : σ\nval✝ : TM1.Stmt Γ Λ σ\nd : Dir\nh₂ : some (TM1.Stmt.move d val✝) ∈ TM1.stmts M S\nhs : TM1.SupportsStm... | refine TM1.stmts_trans ?_ h₂ | Lean.Elab.Tactic.evalRefine | Lean.Parser.Tactic.refine |
Mathlib.Computability.TuringMachine.PostTuringMachine | {
"line": 583,
"column": 16
} | {
"line": 583,
"column": 44
} | {
"line": 584,
"column": 6
} | [
{
"pp": "case right.some.some.write.refl\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 : Γ\nv' : σ\nval✝ : TM1.Stmt Γ Λ σ\nb : Γ → σ → Γ\nh₂ : some (TM1.Stmt.write b val✝) ∈ TM1.stmts M S\n... | [
"case right.some.some.write.refl\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 : Γ\nv' : σ\nval✝ : TM1.Stmt Γ Λ σ\nb : Γ → σ → Γ\nh₂ : some (TM1.Stmt.write b val✝) ∈ TM1.stmts M S\nhs : TM1.Sup... | refine TM1.stmts_trans ?_ h₂ | Lean.Elab.Tactic.evalRefine | Lean.Parser.Tactic.refine |
Mathlib.Computability.RegularExpressions | {
"line": 262,
"column": 8
} | {
"line": 263,
"column": 28
} | {
"line": 264,
"column": 6
} | [
{
"pp": "case mp.nil\nα : Type u_1\ninst✝ : DecidableEq α\nP : RegularExpression α\nIH :\n ∀ (t : List α),\n t.length < [].length → (P.star.rmatch t = true ↔ ∃ S, t = S.flatten ∧ ∀ t ∈ S, t ≠ [] ∧ P.rmatch t = true)\n⊢ P.star.rmatch [] = true → ∃ S, [] = S.flatten ∧ ∀ t ∈ S, t ≠ [] ∧ P.rmatch t = true",
... | [] | intro _h
use []; dsimp; tauto | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Computability.RegularExpressions | {
"line": 262,
"column": 8
} | {
"line": 263,
"column": 28
} | {
"line": 264,
"column": 6
} | [
{
"pp": "case mp.nil\nα : Type u_1\ninst✝ : DecidableEq α\nP : RegularExpression α\nIH :\n ∀ (t : List α),\n t.length < [].length → (P.star.rmatch t = true ↔ ∃ S, t = S.flatten ∧ ∀ t ∈ S, t ≠ [] ∧ P.rmatch t = true)\n⊢ P.star.rmatch [] = true → ∃ S, [] = S.flatten ∧ ∀ t ∈ S, t ≠ [] ∧ P.rmatch t = true",
... | [] | intro _h
use []; dsimp; tauto | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Computability.RegularExpressions | {
"line": 291,
"column": 12
} | {
"line": 291,
"column": 47
} | {
"line": 292,
"column": 12
} | [
{
"pp": "case mpr.cons.cons.cons.refine_1\nα : Type u_1\ninst✝ : DecidableEq α\nP : RegularExpression α\na : α\nx : List α\nIH :\n ∀ (t : List α),\n t.length < (a :: x).length → (P.star.rmatch t = true ↔ ∃ S, t = S.flatten ∧ ∀ t ∈ S, t ≠ [] ∧ P.rmatch t = true)\nU : List (List α)\nb : α\nt : List α\nhelem :... | [
"case mpr.cons.cons.cons.refine_1\nα : Type u_1\ninst✝ : DecidableEq α\nP : RegularExpression α\na : α\nx : List α\nIH :\n ∀ (t : List α),\n t.length < (a :: x).length → (P.star.rmatch t = true ↔ ∃ S, t = S.flatten ∧ ∀ t ∈ S, t ≠ [] ∧ P.rmatch t = true)\nU : List (List α)\nb : α\nt : List α\nhelem : b :: t ≠ []... | specialize helem (b :: t) (by simp) | Lean.Elab.Tactic.evalSpecialize | Lean.Parser.Tactic.specialize |
Mathlib.Computability.TuringMachine.StackTuringMachine | {
"line": 378,
"column": 4
} | {
"line": 378,
"column": 88
} | {
"line": 379,
"column": 2
} | [
{
"pp": "case zero\nK : Type u_1\nΓ : K → Type u_2\nf : ((k : K) → Option (Γ k)) → (k : K) → Option (Γ k)\nL : ListBlank ((k : K) → Option (Γ k))\n⊢ ListBlank.modifyNth (fun a ↦ (a.1, f a.2)) 0 (addBottom L) = addBottom (ListBlank.modifyNth f 0 L)",
"ppTerm": "?zero",
"assigned": true,
"usedConstant... | [] | simp only [addBottom, ListBlank.head_cons, ListBlank.modifyNth, ListBlank.tail_cons] | Lean.Elab.Tactic.evalSimp | Lean.Parser.Tactic.simp |
Mathlib.Computability.TuringMachine.StackTuringMachine | {
"line": 378,
"column": 4
} | {
"line": 378,
"column": 88
} | {
"line": 379,
"column": 2
} | [
{
"pp": "case succ\nK : Type u_1\nΓ : K → Type u_2\nf : ((k : K) → Option (Γ k)) → (k : K) → Option (Γ k)\nL : ListBlank ((k : K) → Option (Γ k))\nn✝ : ℕ\n⊢ ListBlank.modifyNth (fun a ↦ (a.1, f a.2)) (n✝ + 1) (addBottom L) = addBottom (ListBlank.modifyNth f (n✝ + 1) L)",
"ppTerm": "?succ",
"assigned": t... | [
"case succ\nK : Type u_1\nΓ : K → Type u_2\nf : ((k : K) → Option (Γ k)) → (k : K) → Option (Γ k)\nL : ListBlank ((k : K) → Option (Γ k))\nn✝ : ℕ\n⊢ ListBlank.cons (true, L.head)\n (ListBlank.modifyNth (fun a ↦ (a.1, f a.2)) n✝ (ListBlank.map { f := Prod.mk false, map_pt' := ⋯ } L.tail)) =\n ListBlank.cons ... | simp only [addBottom, ListBlank.head_cons, ListBlank.modifyNth, ListBlank.tail_cons] | Lean.Elab.Tactic.evalSimp | Lean.Parser.Tactic.simp |
Mathlib.Computability.TuringMachine.Config | {
"line": 278,
"column": 40
} | {
"line": 278,
"column": 82
} | {
"line": 278,
"column": 83
} | [
{
"pp": "n✝² : ℕ\nf : List.Vector ℕ n✝² →. ℕ\nn✝¹ : ℕ\nf✝ : List.Vector ℕ n✝¹ → ℕ\nn✝ : ℕ\ni✝ : Fin n✝\nn : ℕ\ni : Fin n\nc : Code\nh : ∀ (v : List.Vector ℕ n), c.eval ↑v = pure <$> (↑fun v ↦ v.get i) v\nv : List.Vector ℕ n.succ\n⊢ (c.comp tail).eval ↑v = pure <$> (↑fun v ↦ v.get i.succ) v",
"ppTerm": "?m.2... | [
"n✝² : ℕ\nf : List.Vector ℕ n✝² →. ℕ\nn✝¹ : ℕ\nf✝ : List.Vector ℕ n✝¹ → ℕ\nn✝ : ℕ\ni✝ : Fin n✝\nn : ℕ\ni : Fin n\nc : Code\nh : ∀ (v : List.Vector ℕ n), c.eval ↑v = pure <$> (↑fun v ↦ v.get i) v\nv : List.Vector ℕ n.succ\n⊢ c.eval (↑v).tail = pure <$> Part.some (v.get i.succ)"
] | simpa using | Lean.Elab.Tactic.Simpa.evalSimpa | null |
Mathlib.Computability.TuringMachine.StackTuringMachine | {
"line": 529,
"column": 14
} | {
"line": 529,
"column": 41
} | {
"line": 531,
"column": 0
} | [
{
"pp": "case push\nK : Type u_1\nΓ : K → Type u_2\nΛ : Type u_3\nσ : Type u_4\nk : K\nq : TM2.Stmt Γ Λ σ\na✝ : σ → Γ k\n⊢ trStmts₁ (stRun (StAct.push a✝) q) = {go k (StAct.push a✝) q, ret q} ∪ trStmts₁ q",
"ppTerm": "?push",
"assigned": true,
"usedConstants": [
"Finset.instUnion",
"cong... | [] | simp only [trStmts₁, stRun] | Lean.Elab.Tactic.evalSimp | Lean.Parser.Tactic.simp |
Mathlib.Computability.TuringMachine.StackTuringMachine | {
"line": 529,
"column": 14
} | {
"line": 529,
"column": 41
} | {
"line": 531,
"column": 0
} | [
{
"pp": "case peek\nK : Type u_1\nΓ : K → Type u_2\nΛ : Type u_3\nσ : Type u_4\nk : K\nq : TM2.Stmt Γ Λ σ\na✝ : σ → Option (Γ k) → σ\n⊢ trStmts₁ (stRun (StAct.peek a✝) q) = {go k (StAct.peek a✝) q, ret q} ∪ trStmts₁ q",
"ppTerm": "?peek",
"assigned": true,
"usedConstants": [
"Finset.instUnion"... | [] | simp only [trStmts₁, stRun] | Lean.Elab.Tactic.evalSimp | Lean.Parser.Tactic.simp |
Mathlib.Computability.TuringMachine.StackTuringMachine | {
"line": 529,
"column": 14
} | {
"line": 529,
"column": 41
} | {
"line": 531,
"column": 0
} | [
{
"pp": "case pop\nK : Type u_1\nΓ : K → Type u_2\nΛ : Type u_3\nσ : Type u_4\nk : K\nq : TM2.Stmt Γ Λ σ\na✝ : σ → Option (Γ k) → σ\n⊢ trStmts₁ (stRun (StAct.pop a✝) q) = {go k (StAct.pop a✝) q, ret q} ∪ trStmts₁ q",
"ppTerm": "?pop",
"assigned": true,
"usedConstants": [
"Finset.instUnion",
... | [] | simp only [trStmts₁, stRun] | Lean.Elab.Tactic.evalSimp | Lean.Parser.Tactic.simp |
Mathlib.Computability.TuringMachine.Config | {
"line": 280,
"column": 6
} | {
"line": 280,
"column": 37
} | {
"line": 280,
"column": 38
} | [
{
"pp": "case prim.comp\nn : ℕ\nf : List.Vector ℕ n →. ℕ\nn✝¹ : ℕ\nf✝¹ : List.Vector ℕ n✝¹ → ℕ\nm✝ n✝ : ℕ\nf✝ : List.Vector ℕ n✝ → ℕ\ng : Fin n✝ → List.Vector ℕ m✝ → ℕ\nhf : Nat.Primrec' f✝\nhg : ∀ (i : Fin n✝), Nat.Primrec' (g i)\nIHf : ∃ c, ∀ (v : List.Vector ℕ n✝), c.eval ↑v = pure <$> ↑f✝ v\nIHg : ∀ (i : Fi... | [
"case prim.comp\nn : ℕ\nf : List.Vector ℕ n →. ℕ\nn✝¹ : ℕ\nf✝¹ : List.Vector ℕ n✝¹ → ℕ\nm✝ n✝ : ℕ\nf✝ : List.Vector ℕ n✝ → ℕ\ng : Fin n✝ → List.Vector ℕ m✝ → ℕ\nhf : Nat.Primrec' f✝\nhg : ∀ (i : Fin n✝), Nat.Primrec' (g i)\nIHf : ∃ c, ∀ (v : List.Vector ℕ n✝), c.eval ↑v = pure <$> ↑f✝ v\nIHg : ∀ (i : Fin n✝), ∃ c, ... | simpa using | Lean.Elab.Tactic.Simpa.evalSimpa | null |
Mathlib.Computability.TuringMachine.StackTuringMachine | {
"line": 566,
"column": 8
} | {
"line": 566,
"column": 63
} | {
"line": 566,
"column": 64
} | [
{
"pp": "case neg.inl.h\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\... | [
"case neg.inl.h\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 : σ → Γ k... | simpa using | Lean.Elab.Tactic.Simpa.evalSimpa | null |
Mathlib.Data.Num.Lemmas | {
"line": 801,
"column": 2
} | {
"line": 801,
"column": 84
} | {
"line": 803,
"column": 0
} | [
{
"pp": "⊢ ∀ (m n : Num), ↑(m &&& n) = ↑m &&& ↑n",
"ppTerm": "?m.16",
"assigned": true,
"usedConstants": [
"cond",
"Num.bit",
"Num.castNum_eq_bitwise",
"Num.instAndOp",
"PosNum.bit",
"Bool.and",
"instOnePosNum",
"Bool.true",
"Num",
"Bool.ca... | [] | apply castNum_eq_bitwise PosNum.land <;> intros <;> (try cases_type* Bool) <;> rfl | Lean.Parser.Tactic.«_aux_Init_Tactics___macroRules_Lean_Parser_Tactic_tactic_<;>__1» | Lean.Parser.Tactic.«tactic_<;>_» |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.