module string | startPos dict | endPos dict | nextStartPos dict | goals list | goalsAfter list | ppTac string | elaborator string | kind string |
|---|---|---|---|---|---|---|---|---|
Mathlib.Computability.Primrec.Basic | {
"line": 204,
"column": 4
} | {
"line": 204,
"column": 32
} | {
"line": 206,
"column": 0
} | [
{
"pp": "α : Type u_1\ninst✝ : Primcodable α\nn : ℕ\n⊢ (Nat.casesOn (encode (decode n)) 0 fun n ↦ n.succ.succ) = encode (Option.map some (decode n))",
"ppTerm": "?m.16",
"assigned": true,
"usedConstants": [
"Option.casesOn",
"Option.some",
"Option.encodable",
"instOfNatNat",
... | [] | cases @decode α _ n <;> simp | Lean.Parser.Tactic.«_aux_Init_Tactics___macroRules_Lean_Parser_Tactic_tactic_<;>__1» | Lean.Parser.Tactic.«tactic_<;>_» |
Mathlib.Computability.Primrec.Basic | {
"line": 204,
"column": 4
} | {
"line": 204,
"column": 32
} | {
"line": 206,
"column": 0
} | [
{
"pp": "α : Type u_1\ninst✝ : Primcodable α\nn : ℕ\n⊢ (Nat.casesOn (encode (decode n)) 0 fun n ↦ n.succ.succ) = encode (Option.map some (decode n))",
"ppTerm": "?m.16",
"assigned": true,
"usedConstants": [
"Option.casesOn",
"Option.some",
"Option.encodable",
"instOfNatNat",
... | [] | cases @decode α _ n <;> simp | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Computability.Primrec.Basic | {
"line": 204,
"column": 4
} | {
"line": 204,
"column": 32
} | {
"line": 206,
"column": 0
} | [
{
"pp": "α : Type u_1\ninst✝ : Primcodable α\nn : ℕ\n⊢ (Nat.casesOn (encode (decode n)) 0 fun n ↦ n.succ.succ) = encode (Option.map some (decode n))",
"ppTerm": "?m.16",
"assigned": true,
"usedConstants": [
"Option.casesOn",
"Option.some",
"Option.encodable",
"instOfNatNat",
... | [] | cases @decode α _ n <;> simp | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Computability.Primrec.Basic | {
"line": 517,
"column": 31
} | {
"line": 517,
"column": 48
} | {
"line": 519,
"column": 0
} | [
{
"pp": "case some.zero\nα : Type u_1\nβ : Type u_2\ninst✝¹ : Primcodable α\ninst✝ : Primcodable β\nf : α → β\ng : α → ℕ × β → β\nhf : Primrec f\nhg : Primrec₂ g\nn : ℕ\na : α\n⊢ Nat.rec (encode (f a) + 1)\n (fun y IH ↦ encode (Option.map ((fun p ↦ g p.1 p.2) ∘ Prod.mk a ∘ Prod.mk y) (decode (IH - 1)))) 0 ... | [] | simp [*, encodek] | Lean.Elab.Tactic.evalSimp | Lean.Parser.Tactic.simp |
Mathlib.Computability.Primrec.Basic | {
"line": 517,
"column": 31
} | {
"line": 517,
"column": 48
} | {
"line": 519,
"column": 0
} | [
{
"pp": "case some.succ\nα : Type u_1\nβ : Type u_2\ninst✝¹ : Primcodable α\ninst✝ : Primcodable β\nf : α → β\ng : α → ℕ × β → β\nhf : Primrec f\nhg : Primrec₂ g\nn : ℕ\na : α\nn✝ : ℕ\na✝ :\n Nat.rec (encode (f a) + 1)\n (fun y IH ↦ encode (Option.map ((fun p ↦ g p.1 p.2) ∘ Prod.mk a ∘ Prod.mk y) (decode ... | [] | simp [*, encodek] | Lean.Elab.Tactic.evalSimp | Lean.Parser.Tactic.simp |
Mathlib.Computability.Primrec.List | {
"line": 202,
"column": 11
} | {
"line": 202,
"column": 15
} | {
"line": 203,
"column": 4
} | [
{
"pp": "α : Type u_1\ninst✝ : Primcodable α\nF : List α → ℕ → ℕ ⊕ α :=\n fun l n ↦ List.foldl (fun s a ↦ Sum.casesOn s (fun x ↦ Nat.casesOn x (Sum.inr a) Sum.inl) Sum.inr) (Sum.inl n) l\nhF : Primrec₂ F\nthis : Primrec fun p ↦ Sum.casesOn (F p.1 p.2) (fun x ↦ none) some\nl : List α\nn : ℕ\n⊢ Sum.rec (fun val ... | [
"α : Type u_1\ninst✝ : Primcodable α\nF : List α → ℕ → ℕ ⊕ α := ⋯\nhF : Primrec₂ F\nthis : Primrec fun p ↦ Sum.casesOn (F p.1 p.2) (fun x ↦ none) some\nl : List α\nn : ℕ\n⊢ l[n]? = Sum.rec (fun val ↦ none) (fun val ↦ some val) (F l n)"
] | symm | Lean.Elab.Tactic.evalSymm | Lean.Parser.Tactic.symm |
Mathlib.Computability.Primrec.Basic | {
"line": 862,
"column": 2
} | {
"line": 862,
"column": 58
} | {
"line": 864,
"column": 0
} | [
{
"pp": "α : Type u_1\ninst✝¹ : Primcodable α\np : α → Prop\ninst✝ : DecidablePred p\nhp : PrimrecPred p\nthis : Primcodable (Subtype p) := Primcodable.subtype hp\nn : ℕ\n⊢ encode (decode n) = encode (Option.map Subtype.val (decode n))",
"ppTerm": "?m.26",
"assigned": true,
"usedConstants": [
... | [] | rcases @decode (Subtype p) _ n with (_ | ⟨a, h⟩) <;> rfl | Lean.Parser.Tactic.«_aux_Init_Tactics___macroRules_Lean_Parser_Tactic_tactic_<;>__1» | Lean.Parser.Tactic.«tactic_<;>_» |
Mathlib.Computability.Primrec.List | {
"line": 346,
"column": 41
} | {
"line": 346,
"column": 56
} | {
"line": 347,
"column": 10
} | [
{
"pp": "β : Type u_2\nσ : Type u_4\ninst✝¹ : Primcodable β\ninst✝ : Primcodable σ\nf : β → σ\nm : β → ℕ\nl : β → List β\ng : β → List σ → Option σ\nhm : Primrec m\nhl : Primrec l\nhg : Primrec₂ g\nOrd : ∀ (b b' : β), b' ∈ l b → m b' < m b\nH : ∀ (b : β), g b (List.map f (l b)) = some (f b)\nthis✝ : DecidableEq... | [] | simpa using has | Lean.Elab.Tactic.Simpa.evalSimpa | Lean.Parser.Tactic.simpa |
Mathlib.Computability.Primrec.List | {
"line": 354,
"column": 16
} | {
"line": 354,
"column": 20
} | {
"line": 354,
"column": 20
} | [
{
"pp": "case zero\nβ : Type u_2\nσ : Type u_4\ninst✝¹ : Primcodable β\ninst✝ : Primcodable σ\nf : β → σ\nm : β → ℕ\nl : β → List β\ng : β → List σ → Option σ\nhm : Primrec m\nhl : Primrec l\nhg : Primrec₂ g\nOrd : ∀ (b b' : β), b' ∈ l b → m b' < m b\nH : ∀ (b : β), g b (List.map f (l b)) = some (f b)\nthis✝ : ... | [
"case zero\nβ : Type u_2\nσ : Type u_4\ninst✝¹ : Primcodable β\ninst✝ : Primcodable σ\nf : β → σ\nm : β → ℕ\nl : β → List β\ng : β → List σ → Option σ\nhm : Primrec m\nhl : Primrec l\nhg : Primrec₂ g\nOrd : ∀ (b b' : β), b' ∈ l b → m b' < m b\nH : ∀ (b : β), g b (List.map f (l b)) = some (f b)\nthis✝ : DecidableEq ... | symm | Lean.Elab.Tactic.evalSymm | Lean.Parser.Tactic.symm |
Mathlib.Computability.Primrec.List | {
"line": 618,
"column": 24
} | {
"line": 618,
"column": 66
} | {
"line": 619,
"column": 2
} | [
{
"pp": "case comp\nn : ℕ\nf : List.Vector ℕ n → ℕ\nm✝ n✝ : ℕ\nf✝ : List.Vector ℕ n✝ → ℕ\ng✝ : Fin n✝ → List.Vector ℕ m✝ → ℕ\na✝¹ : Primrec' f✝\na✝ : ∀ (i : Fin n✝), Primrec' (g✝ i)\nhf : Primrec f✝\nhg : ∀ (i : Fin n✝), Primrec (g✝ i)\n⊢ Primrec fun a ↦ f✝ (ofFn fun i ↦ g✝ i a)",
"ppTerm": "?comp",
"as... | [] | exact hf.comp (.vector_ofFn fun i => hg i) | Lean.Elab.Tactic.evalExact | Lean.Parser.Tactic.exact |
Mathlib.Computability.Primrec.List | {
"line": 618,
"column": 24
} | {
"line": 618,
"column": 66
} | {
"line": 619,
"column": 2
} | [
{
"pp": "case comp\nn : ℕ\nf : List.Vector ℕ n → ℕ\nm✝ n✝ : ℕ\nf✝ : List.Vector ℕ n✝ → ℕ\ng✝ : Fin n✝ → List.Vector ℕ m✝ → ℕ\na✝¹ : Primrec' f✝\na✝ : ∀ (i : Fin n✝), Primrec' (g✝ i)\nhf : Primrec f✝\nhg : ∀ (i : Fin n✝), Primrec (g✝ i)\n⊢ Primrec fun a ↦ f✝ (ofFn fun i ↦ g✝ i a)",
"ppTerm": "?comp",
"as... | [] | exact hf.comp (.vector_ofFn fun i => hg i) | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Computability.Primrec.List | {
"line": 618,
"column": 24
} | {
"line": 618,
"column": 66
} | {
"line": 619,
"column": 2
} | [
{
"pp": "case comp\nn : ℕ\nf : List.Vector ℕ n → ℕ\nm✝ n✝ : ℕ\nf✝ : List.Vector ℕ n✝ → ℕ\ng✝ : Fin n✝ → List.Vector ℕ m✝ → ℕ\na✝¹ : Primrec' f✝\na✝ : ∀ (i : Fin n✝), Primrec' (g✝ i)\nhf : Primrec f✝\nhg : ∀ (i : Fin n✝), Primrec (g✝ i)\n⊢ Primrec fun a ↦ f✝ (ofFn fun i ↦ g✝ i a)",
"ppTerm": "?comp",
"as... | [] | exact hf.comp (.vector_ofFn fun i => hg i) | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Computability.PartrecCode | {
"line": 191,
"column": 74
} | {
"line": 191,
"column": 80
} | {
"line": 191,
"column": 81
} | [
{
"pp": "cf cg : Code\n⊢ 1 ≤ 2 * 2",
"ppTerm": "?m.35",
"assigned": true,
"usedConstants": [
"HMul.hMul",
"of_decide_eq_true",
"id",
"instMulNat",
"instOfNatNat",
"LE.le",
"instLENat",
"Bool.true",
"Nat",
"Bool",
"Eq.refl",
"OfN... | [] | decide | Lean.Elab.Tactic.evalDecide | Lean.Parser.Tactic.decide |
Mathlib.Computability.PartrecCode | {
"line": 191,
"column": 74
} | {
"line": 191,
"column": 80
} | {
"line": 191,
"column": 81
} | [
{
"pp": "cf cg : Code\n⊢ 1 ≤ 2 * 2",
"ppTerm": "?m.35",
"assigned": true,
"usedConstants": [
"HMul.hMul",
"of_decide_eq_true",
"id",
"instMulNat",
"instOfNatNat",
"LE.le",
"instLENat",
"Bool.true",
"Nat",
"Bool",
"Eq.refl",
"OfN... | [] | decide | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Computability.PartrecCode | {
"line": 191,
"column": 74
} | {
"line": 191,
"column": 80
} | {
"line": 191,
"column": 81
} | [
{
"pp": "cf cg : Code\n⊢ 1 ≤ 2 * 2",
"ppTerm": "?m.35",
"assigned": true,
"usedConstants": [
"HMul.hMul",
"of_decide_eq_true",
"id",
"instMulNat",
"instOfNatNat",
"LE.le",
"instLENat",
"Bool.true",
"Nat",
"Bool",
"Eq.refl",
"OfN... | [] | decide | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Computability.PartrecCode | {
"line": 193,
"column": 57
} | {
"line": 193,
"column": 63
} | {
"line": 193,
"column": 64
} | [
{
"pp": "cf cg : Code\nthis : Nat.pair cf.encodeCode cg.encodeCode ≤ 2 * (2 * Nat.pair cf.encodeCode cg.encodeCode)\n⊢ 0 < 4",
"ppTerm": "?m.73",
"assigned": true,
"usedConstants": [
"of_decide_eq_true",
"id",
"instOfNatNat",
"Bool.true",
"Nat",
"LT.lt",
"Bo... | [] | decide | Lean.Elab.Tactic.evalDecide | Lean.Parser.Tactic.decide |
Mathlib.Computability.PartrecCode | {
"line": 193,
"column": 57
} | {
"line": 193,
"column": 63
} | {
"line": 193,
"column": 64
} | [
{
"pp": "cf cg : Code\nthis : Nat.pair cf.encodeCode cg.encodeCode ≤ 2 * (2 * Nat.pair cf.encodeCode cg.encodeCode)\n⊢ 0 < 4",
"ppTerm": "?m.73",
"assigned": true,
"usedConstants": [
"of_decide_eq_true",
"id",
"instOfNatNat",
"Bool.true",
"Nat",
"LT.lt",
"Bo... | [] | decide | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Computability.PartrecCode | {
"line": 193,
"column": 57
} | {
"line": 193,
"column": 63
} | {
"line": 193,
"column": 64
} | [
{
"pp": "cf cg : Code\nthis : Nat.pair cf.encodeCode cg.encodeCode ≤ 2 * (2 * Nat.pair cf.encodeCode cg.encodeCode)\n⊢ 0 < 4",
"ppTerm": "?m.73",
"assigned": true,
"usedConstants": [
"of_decide_eq_true",
"id",
"instOfNatNat",
"Bool.true",
"Nat",
"LT.lt",
"Bo... | [] | decide | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Computability.Primrec.List | {
"line": 718,
"column": 10
} | {
"line": 718,
"column": 14
} | {
"line": 719,
"column": 2
} | [
{
"pp": "n : ℕ\n⊢ n.sqrt = Nat.rec 0 (fun x y ↦ if x.succ < y.succ * y.succ then y else y.succ) n",
"ppTerm": "?m.104",
"assigned": true,
"usedConstants": [
"HMul.hMul",
"Nat.rec",
"instMulNat",
"Nat.sqrt",
"instOfNatNat",
"Nat",
"LT.lt",
"Nat.decLt",
... | [
"n : ℕ\n⊢ Nat.rec 0 (fun x y ↦ if x.succ < y.succ * y.succ then y else y.succ) n = n.sqrt"
] | symm | Lean.Elab.Tactic.evalSymm | Lean.Parser.Tactic.symm |
Mathlib.Computability.AkraBazzi.AkraBazzi | {
"line": 201,
"column": 6
} | {
"line": 201,
"column": 99
} | {
"line": 202,
"column": 6
} | [
{
"pp": "p : ℝ\nhp : p = 0\n⊢ (fun x ↦ ‖deriv (fun z ↦ z ^ p * (1 + ε z)) x‖) =ᶠ[atTop] fun z ↦ z⁻¹ / log z ^ 2",
"ppTerm": "?m.117",
"assigned": true,
"usedConstants": [
"Real.instIsOrderedRing",
"Norm.norm",
"Real.instPow",
"Real.partialOrder",
"Real",
"Preorder... | [
"p : ℝ\nhp : p = 0\nx : ℝ\nhx : deriv (fun x ↦ 1 + ε x) x = -x⁻¹ / log x ^ 2\nhx_pos : 1 < x\n⊢ ‖deriv (fun z ↦ z ^ p * (1 + ε z)) x‖ = x⁻¹ / log x ^ 2"
] | filter_upwards [eventually_deriv_one_add_smoothingFn, eventually_gt_atTop 1] with x hx hx_pos | Mathlib.Tactic._aux_Mathlib_Order_Filter_Defs___elabRules_Mathlib_Tactic_filterUpwards_1 | Mathlib.Tactic.filterUpwards |
Mathlib.Computability.AkraBazzi.GrowsPolynomially | {
"line": 214,
"column": 6
} | {
"line": 214,
"column": 31
} | {
"line": 215,
"column": 6
} | [
{
"pp": "case neg.inl\nf : ℝ → ℝ\nhf : GrowsPolynomially f\nh : ∀ᶠ (x : ℝ) in atTop, f x ≠ 0\nh' : ∀ᶠ (x : ℝ) in atTop, 0 ≤ f x\n⊢ (∀ᶠ (x : ℝ) in atTop, f x = 0) ∨ (∀ᶠ (x : ℝ) in atTop, 0 < f x) ∨ ∀ᶠ (x : ℝ) in atTop, f x < 0",
"ppTerm": "?neg.inl✝",
"assigned": true,
"usedConstants": [
"Real"... | [
"case neg.inl\nf : ℝ → ℝ\nhf : GrowsPolynomially f\nh : ∀ᶠ (x : ℝ) in atTop, f x ≠ 0\nh' : ∀ᶠ (x : ℝ) in atTop, 0 ≤ f x\n⊢ ∀ᶠ (x : ℝ) in atTop, 0 < f x"
] | refine Or.inr (Or.inl ?_) | Lean.Elab.Tactic.evalRefine | Lean.Parser.Tactic.refine |
Mathlib.Computability.AkraBazzi.GrowsPolynomially | {
"line": 261,
"column": 2
} | {
"line": 261,
"column": 26
} | {
"line": 262,
"column": 2
} | [
{
"pp": "c x✝¹ : ℝ\nx✝ : x✝¹ ∈ Set.Ioo 0 1\n⊢ ∀ᶠ (x : ℝ) in atTop, ∀ u ∈ Set.Icc (x✝¹ * x) x, (fun x ↦ c) u ∈ Set.Icc (1 * (fun x ↦ c) x) (1 * (fun x ↦ c) x)",
"ppTerm": "?m.19",
"assigned": true,
"usedConstants": [
"Real",
"HMul.hMul",
"setOf",
"Membership.mem",
"id",
... | [
"c x✝¹ : ℝ\nx✝ : x✝¹ ∈ Set.Ioo 0 1\nx : ℝ\n⊢ ∀ u ∈ Set.Icc (x✝¹ * x) x, c ∈ Set.Icc (1 * c) (1 * c)"
] | filter_upwards [] with x | Mathlib.Tactic._aux_Mathlib_Order_Filter_Defs___elabRules_Mathlib_Tactic_filterUpwards_1 | Mathlib.Tactic.filterUpwards |
Mathlib.Computability.AkraBazzi.GrowsPolynomially | {
"line": 387,
"column": 6
} | {
"line": 388,
"column": 72
} | {
"line": 389,
"column": 4
} | [
{
"pp": "f g : ℝ → ℝ\nhf✝ : GrowsPolynomially f\nhfg : ∀ᶠ (x : ℝ) in atTop, ‖g x‖ ≤ 1 / 2 * ‖f x‖\nb : ℝ\nhb : b ∈ Set.Ioo 0 1\nhb_ub : b < 1\nhf' : ∀ᶠ (x : ℝ) in atTop, 0 ≤ f x\nc₁ : ℝ\nhc₁_mem : 0 < c₁\nc₂ : ℝ\nhc₂_mem : 0 < c₂\nhf : ∀ᶠ (x : ℝ) in atTop, ∀ u ∈ Set.Icc (b * x) x, f u ∈ Set.Icc (c₁ * f x) (c₂ *... | [] | calc ‖g x‖ ≤ 1 / 2 * ‖f x‖ := hfg' x hbx
_ = 1 / 2 * f x := by congr; exact norm_of_nonneg (hf₂ _ hbx) | Lean.Elab.Tactic._aux_Mathlib_Tactic_Widget_Calc___elabRules_Lean_calcTactic_1 | Lean.calcTactic |
Mathlib.Computability.PartrecCode | {
"line": 714,
"column": 4
} | {
"line": 714,
"column": 30
} | {
"line": 714,
"column": 30
} | [
{
"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⊢ x ∈\n Nat.rec (cf.eval (unpair n).1) (fun y IH ↦ IH.bind fun i ↦ cg.eval (Nat.pair (unpair n).1 (Nat.pair y i)))\n (unpair n).2 →... | [
"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⊢ x ∈ Nat.rec (cf.eval n₁) (fun y IH ↦ IH.bind fun i ↦ cg.eval (Nat.pair n₁ (Nat.pair y i))) (unpair n).2 →\n ∃ k,\n n ≤ k ∧\n Nat.rec (e... | generalize n.unpair.1 = n₁ | Lean.Elab.Tactic.evalGeneralize | Lean.Parser.Tactic.generalize |
Mathlib.Computability.ContextFreeGrammar | {
"line": 253,
"column": 79
} | {
"line": 253,
"column": 92
} | {
"line": 255,
"column": 0
} | [
{
"pp": "T : Type u_1\nN : Type u_2\n⊢ reverse ∘ reverse = id",
"ppTerm": "?m.10",
"assigned": true,
"usedConstants": [
"congrArg",
"Function.comp",
"ContextFreeRule.reverse_reverse",
"id",
"ContextFreeRule.reverse",
"funext",
"True",
"eq_self",
... | [] | ext : 1; simp | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Computability.ContextFreeGrammar | {
"line": 253,
"column": 79
} | {
"line": 253,
"column": 92
} | {
"line": 255,
"column": 0
} | [
{
"pp": "T : Type u_1\nN : Type u_2\n⊢ reverse ∘ reverse = id",
"ppTerm": "?m.10",
"assigned": true,
"usedConstants": [
"congrArg",
"Function.comp",
"ContextFreeRule.reverse_reverse",
"id",
"ContextFreeRule.reverse",
"funext",
"True",
"eq_self",
... | [] | ext : 1; simp | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Computability.DFA | {
"line": 145,
"column": 4
} | {
"line": 148,
"column": 9
} | {
"line": 149,
"column": 2
} | [
{
"pp": "case refine_3\nα : Type u\nσ : Type v\nM : DFA α σ\ninst✝ : Fintype σ\nx : List α\ns t : σ\nhlen : Fintype.card σ ≤ x.length\nhx : M.evalFrom s x = t\nn m : Fin (Fintype.card σ + 1)\nhneq : n ≠ m\nheq : M.evalFrom s (List.take (↑n) x) = M.evalFrom s (List.take (↑m) x)\nhle : ↑n ≤ ↑m\n⊢ List.drop (↑n) (... | [] | intro h
have hlen' := congr_arg List.length h
simp only [List.length_drop, List.length, List.length_take] at hlen'
omega | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Computability.DFA | {
"line": 145,
"column": 4
} | {
"line": 148,
"column": 9
} | {
"line": 149,
"column": 2
} | [
{
"pp": "case refine_3\nα : Type u\nσ : Type v\nM : DFA α σ\ninst✝ : Fintype σ\nx : List α\ns t : σ\nhlen : Fintype.card σ ≤ x.length\nhx : M.evalFrom s x = t\nn m : Fin (Fintype.card σ + 1)\nhneq : n ≠ m\nheq : M.evalFrom s (List.take (↑n) x) = M.evalFrom s (List.take (↑m) x)\nhle : ↑n ≤ ↑m\n⊢ List.drop (↑n) (... | [] | intro h
have hlen' := congr_arg List.length h
simp only [List.length_drop, List.length, List.length_take] at hlen'
omega | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Computability.AkraBazzi.GrowsPolynomially | {
"line": 477,
"column": 42
} | {
"line": 523,
"column": 23
} | {
"line": 525,
"column": 0
} | [
{
"pp": "f : ℝ → ℝ\nhf : GrowsPolynomially f\n⊢ GrowsPolynomially fun x ↦ (f x)⁻¹",
"ppTerm": "?m.4",
"assigned": true,
"usedConstants": [
"Iff.mpr",
"AddGroup.toSubtractionMonoid",
"Real.instIsOrderedRing",
"Eq.mpr",
"GroupWithZero.toMonoidWithZero",
"NegZeroClas... | [] | by
cases hf.eventually_atTop_zero_or_pos_or_neg with
| inl hf' =>
refine fun b hb => ⟨1, by simp, 1, by simp, ?_⟩
have hb_pos := hb.1
filter_upwards [hf', (tendsto_id.const_mul_atTop hb_pos).eventually_forall_ge_atTop hf']
with x hx hx'
intro u hu
simp only [hx, inv_zero, mul_zero, Set.Icc... | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Computability.AkraBazzi.GrowsPolynomially | {
"line": 527,
"column": 66
} | {
"line": 527,
"column": 85
} | {
"line": 528,
"column": 2
} | [
{
"pp": "f g : ℝ → ℝ\nhf : GrowsPolynomially f\nhg : GrowsPolynomially g\nx✝ : ℝ\n⊢ f x✝ / g x✝ = f x✝ * (g x✝)⁻¹",
"ppTerm": "?m.28",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"Real",
"DivInvMonoid.toInv",
"instHDiv",
"HMul.hMul",
"Monoid.toMulOneClass",
... | [] | rw [div_eq_mul_inv] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.Data.Nat.Size | {
"line": 24,
"column": 73
} | {
"line": 24,
"column": 85
} | {
"line": 24,
"column": 85
} | [
{
"pp": "m k : ℕ\n⊢ (m + 1) * (2 ^ k * 2) = (m + 1) * 2 ^ (k + 1)",
"ppTerm": "?m.73",
"assigned": true,
"usedConstants": [
"instPowNat",
"Eq.mpr",
"HMul.hMul",
"congrArg",
"Nat.pow_succ",
"id",
"instMulNat",
"instOfNatNat",
"instNatPowNat",
... | [
"m k : ℕ\n⊢ (m + 1) * (2 ^ k * 2) = (m + 1) * (2 ^ k * 2)"
] | Nat.pow_succ | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Data.Nat.Size | {
"line": 23,
"column": 4
} | {
"line": 24,
"column": 86
} | {
"line": 26,
"column": 0
} | [
{
"pp": "m k : ℕ\n⊢ shiftLeft' true m (k + 1) + 1 = (m + 1) * 2 ^ (k + 1)",
"ppTerm": "?m.37",
"assigned": true,
"usedConstants": [
"Nat.bit",
"instPowNat",
"Eq.mpr",
"HMul.hMul",
"congrArg",
"Nat.mul_left_comm",
"Bool.toNat",
"Nat.pow_succ",
"id... | [] | rw [shiftLeft', bit_val, Bool.toNat_true, Nat.add_assoc, ← Nat.mul_add_one,
shiftLeft'_true_eq_mul_pow m k, Nat.mul_left_comm, Nat.mul_comm 2, Nat.pow_succ] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.Data.Nat.Size | {
"line": 23,
"column": 4
} | {
"line": 24,
"column": 86
} | {
"line": 26,
"column": 0
} | [
{
"pp": "m k : ℕ\n⊢ shiftLeft' true m (k + 1) + 1 = (m + 1) * 2 ^ (k + 1)",
"ppTerm": "?m.37",
"assigned": true,
"usedConstants": [
"Nat.bit",
"instPowNat",
"Eq.mpr",
"HMul.hMul",
"congrArg",
"Nat.mul_left_comm",
"Bool.toNat",
"Nat.pow_succ",
"id... | [] | rw [shiftLeft', bit_val, Bool.toNat_true, Nat.add_assoc, ← Nat.mul_add_one,
shiftLeft'_true_eq_mul_pow m k, Nat.mul_left_comm, Nat.mul_comm 2, Nat.pow_succ] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Data.Nat.Size | {
"line": 23,
"column": 4
} | {
"line": 24,
"column": 86
} | {
"line": 26,
"column": 0
} | [
{
"pp": "m k : ℕ\n⊢ shiftLeft' true m (k + 1) + 1 = (m + 1) * 2 ^ (k + 1)",
"ppTerm": "?m.37",
"assigned": true,
"usedConstants": [
"Nat.bit",
"instPowNat",
"Eq.mpr",
"HMul.hMul",
"congrArg",
"Nat.mul_left_comm",
"Bool.toNat",
"Nat.pow_succ",
"id... | [] | rw [shiftLeft', bit_val, Bool.toNat_true, Nat.add_assoc, ← Nat.mul_add_one,
shiftLeft'_true_eq_mul_pow m k, Nat.mul_left_comm, Nat.mul_comm 2, Nat.pow_succ] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Data.Nat.Size | {
"line": 58,
"column": 4
} | {
"line": 58,
"column": 38
} | {
"line": 59,
"column": 4
} | [
{
"pp": "case succ\nb : Bool\nm n : ℕ\nIH : shiftLeft' b m n ≠ 0 → (shiftLeft' b m n).size = m.size + n\nh : ¬bit b (shiftLeft' b m n) = 0\n⊢ (shiftLeft' b m n).size.succ = (m.size + n).succ",
"ppTerm": "?succ",
"assigned": true,
"usedConstants": [
"instOfNatNat",
"dite",
"instHAdd... | [
"case pos\nb : Bool\nm n : ℕ\nIH : shiftLeft' b m n ≠ 0 → (shiftLeft' b m n).size = m.size + n\nh : ¬bit b (shiftLeft' b m n) = 0\ns0 : shiftLeft' b m n = 0\n⊢ (shiftLeft' b m n).size.succ = (m.size + n).succ",
"case neg\nb : Bool\nm n : ℕ\nIH : shiftLeft' b m n ≠ 0 → (shiftLeft' b m n).size = m.size + n\nh : ¬bi... | by_cases s0 : shiftLeft' b m n = 0 | «_aux_Init_ByCases___macroRules_tacticBy_cases_:__2» | «tacticBy_cases_:_» |
Mathlib.Data.Nat.Size | {
"line": 80,
"column": 74
} | {
"line": 80,
"column": 80
} | {
"line": 80,
"column": 80
} | [
{
"pp": "m n : ℕ\nh : m.size ≤ n\n⊢ 2 > 0",
"ppTerm": "?m.19",
"assigned": true,
"usedConstants": [
"of_decide_eq_true",
"id",
"instOfNatNat",
"Bool.true",
"GT.gt",
"Nat",
"Bool",
"Nat.decLt",
"Eq.refl",
"instLTNat",
"OfNat.ofNat",
... | [] | decide | Lean.Elab.Tactic.evalDecide | Lean.Parser.Tactic.decide |
Mathlib.Data.Nat.Size | {
"line": 80,
"column": 74
} | {
"line": 80,
"column": 80
} | {
"line": 80,
"column": 80
} | [
{
"pp": "m n : ℕ\nh : m.size ≤ n\n⊢ 2 > 0",
"ppTerm": "?m.19",
"assigned": true,
"usedConstants": [
"of_decide_eq_true",
"id",
"instOfNatNat",
"Bool.true",
"GT.gt",
"Nat",
"Bool",
"Nat.decLt",
"Eq.refl",
"instLTNat",
"OfNat.ofNat",
... | [] | decide | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Data.Nat.Size | {
"line": 80,
"column": 74
} | {
"line": 80,
"column": 80
} | {
"line": 80,
"column": 80
} | [
{
"pp": "m n : ℕ\nh : m.size ≤ n\n⊢ 2 > 0",
"ppTerm": "?m.19",
"assigned": true,
"usedConstants": [
"of_decide_eq_true",
"id",
"instOfNatNat",
"Bool.true",
"GT.gt",
"Nat",
"Bool",
"Nat.decLt",
"Eq.refl",
"instLTNat",
"OfNat.ofNat",
... | [] | decide | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Data.Nat.Size | {
"line": 99,
"column": 71
} | {
"line": 99,
"column": 77
} | {
"line": 99,
"column": 77
} | [
{
"pp": "n : ℕ\n⊢ 1 ≠ 0",
"ppTerm": "?m.17",
"assigned": true,
"usedConstants": [
"instDecidableNot",
"of_decide_eq_true",
"id",
"Ne",
"instOfNatNat",
"Bool.true",
"Nat",
"Bool",
"Eq.refl",
"instDecidableEqNat",
"OfNat.ofNat",
"... | [] | decide | Lean.Elab.Tactic.evalDecide | Lean.Parser.Tactic.decide |
Mathlib.Data.Nat.Size | {
"line": 99,
"column": 71
} | {
"line": 99,
"column": 77
} | {
"line": 99,
"column": 77
} | [
{
"pp": "n : ℕ\n⊢ 1 ≠ 0",
"ppTerm": "?m.17",
"assigned": true,
"usedConstants": [
"instDecidableNot",
"of_decide_eq_true",
"id",
"Ne",
"instOfNatNat",
"Bool.true",
"Nat",
"Bool",
"Eq.refl",
"instDecidableEqNat",
"OfNat.ofNat",
"... | [] | decide | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Data.Nat.Size | {
"line": 99,
"column": 71
} | {
"line": 99,
"column": 77
} | {
"line": 99,
"column": 77
} | [
{
"pp": "n : ℕ\n⊢ 1 ≠ 0",
"ppTerm": "?m.17",
"assigned": true,
"usedConstants": [
"instDecidableNot",
"of_decide_eq_true",
"id",
"Ne",
"instOfNatNat",
"Bool.true",
"Nat",
"Bool",
"Eq.refl",
"instDecidableEqNat",
"OfNat.ofNat",
"... | [] | decide | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Computability.PartrecCode | {
"line": 963,
"column": 12
} | {
"line": 963,
"column": 44
} | {
"line": 963,
"column": 44
} | [
{
"pp": "case succ.prec\nx✝ : Unit\np n : ℕ\nthis : List.range p = List.range (Nat.pair (unpair p).1 (encode (ofNat Code (unpair p).2)))\nk' : ℕ\nk : ℕ := k' + 1\nnk : n ≤ k'\ncf cg : Code\nhg :\n ∀ {k' : ℕ} {c' : Code} {n : ℕ},\n Nat.pair k' (encode c') < Nat.pair k (encode (cf.prec cg)) →\n lup\n ... | [
"case succ.prec\nx✝ : Unit\np n : ℕ\nthis : List.range p = List.range (Nat.pair (unpair p).1 (encode (ofNat Code (unpair p).2)))\nk' : ℕ\nk : ℕ := k' + 1\nnk : n ≤ k'\ncf cg : Code\nhg :\n ∀ {k' : ℕ} {c' : Code} {n : ℕ},\n Nat.pair k' (encode c') < Nat.pair k (encode (cf.prec cg)) →\n lup\n (List.... | hg (Nat.pair_lt_pair_right _ lf) | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Data.Nat.Bitwise | {
"line": 226,
"column": 81
} | {
"line": 226,
"column": 84
} | {
"line": 226,
"column": 84
} | [
{
"pp": "case bit.bit\nf : Bool → Bool → Bool\nbm : Bool\nm : ℕ\nhm : m = 0 → bm = true\nihm : ∀ (n : ℕ), bitwise (swap f) m n = bitwise f n m\nbn : Bool\nn : ℕ\nhn : n = 0 → bn = true\na✝ : bitwise (swap f) (bit bm m) n = bitwise f n (bit bm m)\n⊢ bit (swap f bm bn) (bitwise (swap f) m n) = bit (f bn bm) (bitw... | [
"case bit.bit\nf : Bool → Bool → Bool\nbm : Bool\nm : ℕ\nhm : m = 0 → bm = true\nihm : ∀ (n : ℕ), bitwise (swap f) m n = bitwise f n m\nbn : Bool\nn : ℕ\nhn : n = 0 → bn = true\na✝ : bitwise (swap f) (bit bm m) n = bitwise f n (bit bm m)\n⊢ bit (swap f bm bn) (bitwise f n m) = bit (f bn bm) (bitwise f n m)"
] | ihm | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Data.Nat.Bitwise | {
"line": 281,
"column": 13
} | {
"line": 281,
"column": 41
} | {
"line": 281,
"column": 41
} | [
{
"pp": "a b c : ℕ\nv : ℕ := a ^^^ b ^^^ c\nh : v ≠ 0\nhv : v = a ^^^ b ^^^ c\nhab : a ^^^ b = c ^^^ v\nhbc : b ^^^ c = a ^^^ v\nhca : c ^^^ a = b ^^^ v\ni : ℕ\nhi' : ∀ (j : ℕ), i < j → v.testBit j = false\nhi : a.testBit i ≠ true ∧ b.testBit i ≠ true ∧ c.testBit i ≠ true\n⊢ v.testBit i ≠ true",
"ppTerm": "... | [
"a b c : ℕ\nv : ℕ := a ^^^ b ^^^ c\nh : v ≠ 0\nhv : v = a ^^^ b ^^^ c\nhab : a ^^^ b = c ^^^ v\nhbc : b ^^^ c = a ^^^ v\nhca : c ^^^ a = b ^^^ v\ni : ℕ\nhi' : ∀ (j : ℕ), i < j → v.testBit j = false\nhi : a.testBit i = false ∧ b.testBit i = false ∧ c.testBit i = false\n⊢ v.testBit i = false"
] | Bool.eq_false_eq_not_eq_true | Mathlib.Tactic._aux_Mathlib_Tactic_SimpRw___elabRules_Mathlib_Tactic_tacticSimp_rw____1 | null |
Mathlib.Computability.PartrecCode | {
"line": 972,
"column": 12
} | {
"line": 972,
"column": 44
} | {
"line": 972,
"column": 44
} | [
{
"pp": "case succ.rfind'\nx✝ : Unit\np n : ℕ\nthis : List.range p = List.range (Nat.pair (unpair p).1 (encode (ofNat Code (unpair p).2)))\nk' : ℕ\nk : ℕ := k' + 1\nnk : n ≤ k'\ncf : Code\nhg :\n ∀ {k' : ℕ} {c' : Code} {n : ℕ},\n Nat.pair k' (encode c') < Nat.pair k (encode cf.rfind') →\n lup\n ... | [
"case succ.rfind'\nx✝ : Unit\np n : ℕ\nthis : List.range p = List.range (Nat.pair (unpair p).1 (encode (ofNat Code (unpair p).2)))\nk' : ℕ\nk : ℕ := k' + 1\nnk : n ≤ k'\ncf : Code\nhg :\n ∀ {k' : ℕ} {c' : Code} {n : ℕ},\n Nat.pair k' (encode c') < Nat.pair k (encode cf.rfind') →\n lup\n (List.map ... | hg (Nat.pair_lt_pair_right _ lf) | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Computability.AkraBazzi.GrowsPolynomially | {
"line": 649,
"column": 23
} | {
"line": 649,
"column": 27
} | {
"line": 649,
"column": 28
} | [
{
"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₃_... | [
"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₃_pos : 0 < c₃... | h_ub | Lean.Elab.Tactic.evalIntro | ident |
Mathlib.Computability.EpsilonNFA | {
"line": 202,
"column": 10
} | {
"line": 202,
"column": 29
} | {
"line": 202,
"column": 30
} | [
{
"pp": "case h\nα : Type u\nσ : Type v\nM : εNFA α σ\ns₁ s₂ s✝ t✝ : σ\na✝¹ : t✝ ∈ M.step s✝ none\na✝ : M.εClosure {s₁} s✝\nn : ℕ\nh✝ : M.IsPath s₁ s✝ (List.replicate n none)\n⊢ M.IsPath s₁ t✝ (List.replicate (n + 1) none)",
"ppTerm": "?h",
"assigned": true,
"usedConstants": [
"Eq.mpr",
... | [
"case h\nα : Type u\nσ : Type v\nM : εNFA α σ\ns₁ s₂ s✝ t✝ : σ\na✝¹ : t✝ ∈ M.step s✝ none\na✝ : M.εClosure {s₁} s✝\nn : ℕ\nh✝ : M.IsPath s₁ s✝ (List.replicate n none)\n⊢ M.IsPath s₁ t✝ (List.replicate n none ++ List.replicate 1 none)"
] | List.replicate_add, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Computability.EpsilonNFA | {
"line": 210,
"column": 15
} | {
"line": 210,
"column": 34
} | {
"line": 210,
"column": 35
} | [
{
"pp": "case succ\nα : Type u\nσ : Type v\nM : εNFA α σ\ns₁ : σ\nn✝ : ℕ\na✝ : ∀ {s₂ : σ}, M.IsPath s₁ s₂ (List.replicate n✝ none) → s₂ ∈ M.εClosure {s₁}\ns₂ : σ\nh : M.IsPath s₁ s₂ (List.replicate (n✝ + 1) none)\n⊢ s₂ ∈ M.εClosure {s₁}",
"ppTerm": "?succ",
"assigned": true,
"usedConstants": [
... | [
"case succ\nα : Type u\nσ : Type v\nM : εNFA α σ\ns₁ : σ\nn✝ : ℕ\na✝ : ∀ {s₂ : σ}, M.IsPath s₁ s₂ (List.replicate n✝ none) → s₂ ∈ M.εClosure {s₁}\ns₂ : σ\nh : M.IsPath s₁ s₂ (List.replicate n✝ none ++ List.replicate 1 none)\n⊢ s₂ ∈ M.εClosure {s₁}"
] | List.replicate_add, | Mathlib.Tactic._aux_Mathlib_Tactic_SimpRw___elabRules_Mathlib_Tactic_tacticSimp_rw____1 | null |
Mathlib.Data.Num.Lemmas | {
"line": 366,
"column": 18
} | {
"line": 366,
"column": 65
} | {
"line": 367,
"column": 2
} | [
{
"pp": "x✝¹ x✝ : Num\n⊢ x✝¹ + x✝ = x✝ + x✝¹",
"ppTerm": "?m.71",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"Nat.instMulZeroClass",
"Nat.instOne",
"AddMonoid.toAddSemigroup",
"congrArg",
"_private.Mathlib.Data.Num.Lemmas.0.Num.commSemiring._simp_1",
"id... | [] | by simp_rw [← to_nat_inj, add_to_nat, add_comm] | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Data.Num.Lemmas | {
"line": 365,
"column": 18
} | {
"line": 365,
"column": 66
} | {
"line": 366,
"column": 2
} | [
{
"pp": "x✝ : Num\n⊢ 1 * x✝ = x✝",
"ppTerm": "?m.77",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"MulOne.toOne",
"Nat.instMulZeroClass",
"HMul.hMul",
"Nat.instOne",
"congrArg",
"Nat.instMulOneClass",
"id",
"MulOne.toMul",
"instMulNat",
... | [] | rw [← to_nat_inj, mul_to_nat, cast_one, one_mul] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.Data.Num.Lemmas | {
"line": 365,
"column": 18
} | {
"line": 365,
"column": 66
} | {
"line": 366,
"column": 2
} | [
{
"pp": "x✝ : Num\n⊢ 1 * x✝ = x✝",
"ppTerm": "?m.77",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"MulOne.toOne",
"Nat.instMulZeroClass",
"HMul.hMul",
"Nat.instOne",
"congrArg",
"Nat.instMulOneClass",
"id",
"MulOne.toMul",
"instMulNat",
... | [] | rw [← to_nat_inj, mul_to_nat, cast_one, one_mul] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Data.Num.Lemmas | {
"line": 365,
"column": 18
} | {
"line": 365,
"column": 66
} | {
"line": 366,
"column": 2
} | [
{
"pp": "x✝ : Num\n⊢ 1 * x✝ = x✝",
"ppTerm": "?m.77",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"MulOne.toOne",
"Nat.instMulZeroClass",
"HMul.hMul",
"Nat.instOne",
"congrArg",
"Nat.instMulOneClass",
"id",
"MulOne.toMul",
"instMulNat",
... | [] | rw [← to_nat_inj, mul_to_nat, cast_one, one_mul] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Data.Num.Lemmas | {
"line": 395,
"column": 20
} | {
"line": 395,
"column": 26
} | {
"line": 396,
"column": 2
} | [
{
"pp": "⊢ 0 ≤ 1",
"ppTerm": "?m.6",
"assigned": true,
"usedConstants": [
"NonAssocSemiring.toAddCommMonoidWithOne",
"Num.decidableLE",
"of_decide_eq_true",
"CommSemiring.toSemiring",
"PartialOrder.toPreorder",
"Preorder.toLE",
"id",
"AddCommMonoidWith... | [] | decide | Lean.Elab.Tactic.evalDecide | Lean.Parser.Tactic.decide |
Mathlib.Data.Num.Lemmas | {
"line": 395,
"column": 20
} | {
"line": 395,
"column": 26
} | {
"line": 396,
"column": 2
} | [
{
"pp": "⊢ 0 ≤ 1",
"ppTerm": "?m.6",
"assigned": true,
"usedConstants": [
"NonAssocSemiring.toAddCommMonoidWithOne",
"Num.decidableLE",
"of_decide_eq_true",
"CommSemiring.toSemiring",
"PartialOrder.toPreorder",
"Preorder.toLE",
"id",
"AddCommMonoidWith... | [] | decide | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Data.Num.Lemmas | {
"line": 395,
"column": 20
} | {
"line": 395,
"column": 26
} | {
"line": 396,
"column": 2
} | [
{
"pp": "⊢ 0 ≤ 1",
"ppTerm": "?m.6",
"assigned": true,
"usedConstants": [
"NonAssocSemiring.toAddCommMonoidWithOne",
"Num.decidableLE",
"of_decide_eq_true",
"CommSemiring.toSemiring",
"PartialOrder.toPreorder",
"Preorder.toLE",
"id",
"AddCommMonoidWith... | [] | decide | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Data.Num.Lemmas | {
"line": 396,
"column": 30
} | {
"line": 396,
"column": 36
} | {
"line": 396,
"column": 36
} | [
{
"pp": "⊢ 0 ≠ 1",
"ppTerm": "?m.15",
"assigned": true,
"usedConstants": [
"instDecidableEqNum",
"instDecidableNot",
"of_decide_eq_true",
"id",
"Ne",
"instOneNum",
"Bool.true",
"Num",
"instZeroNum",
"Bool",
"One.toOfNat1",
"Zero... | [] | decide | Lean.Elab.Tactic.evalDecide | Lean.Parser.Tactic.decide |
Mathlib.Data.Num.Lemmas | {
"line": 396,
"column": 30
} | {
"line": 396,
"column": 36
} | {
"line": 396,
"column": 36
} | [
{
"pp": "⊢ 0 ≠ 1",
"ppTerm": "?m.15",
"assigned": true,
"usedConstants": [
"instDecidableEqNum",
"instDecidableNot",
"of_decide_eq_true",
"id",
"Ne",
"instOneNum",
"Bool.true",
"Num",
"instZeroNum",
"Bool",
"One.toOfNat1",
"Zero... | [] | decide | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Data.Num.Lemmas | {
"line": 396,
"column": 30
} | {
"line": 396,
"column": 36
} | {
"line": 396,
"column": 36
} | [
{
"pp": "⊢ 0 ≠ 1",
"ppTerm": "?m.15",
"assigned": true,
"usedConstants": [
"instDecidableEqNum",
"instDecidableNot",
"of_decide_eq_true",
"id",
"Ne",
"instOneNum",
"Bool.true",
"Num",
"instZeroNum",
"Bool",
"One.toOfNat1",
"Zero... | [] | decide | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Data.Num.Lemmas | {
"line": 460,
"column": 6
} | {
"line": 460,
"column": 65
} | {
"line": 461,
"column": 4
} | [
{
"pp": "n : PosNum\n⊢ (↑n.pred').succ = ↑n",
"ppTerm": "?m.12",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"castPosNum",
"Nat.instMulZeroClass",
"Nat.instOne",
"Nat.succ_pred_eq_of_pos",
"PosNum.pred'",
"congrArg",
"PosNum.to_nat_pos",
"id",... | [] | rw [pred'_to_nat n, Nat.succ_pred_eq_of_pos (to_nat_pos n)] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.Data.Num.Lemmas | {
"line": 460,
"column": 6
} | {
"line": 460,
"column": 65
} | {
"line": 461,
"column": 4
} | [
{
"pp": "n : PosNum\n⊢ (↑n.pred').succ = ↑n",
"ppTerm": "?m.12",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"castPosNum",
"Nat.instMulZeroClass",
"Nat.instOne",
"Nat.succ_pred_eq_of_pos",
"PosNum.pred'",
"congrArg",
"PosNum.to_nat_pos",
"id",... | [] | rw [pred'_to_nat n, Nat.succ_pred_eq_of_pos (to_nat_pos n)] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Data.Num.Lemmas | {
"line": 460,
"column": 6
} | {
"line": 460,
"column": 65
} | {
"line": 461,
"column": 4
} | [
{
"pp": "n : PosNum\n⊢ (↑n.pred').succ = ↑n",
"ppTerm": "?m.12",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"castPosNum",
"Nat.instMulZeroClass",
"Nat.instOne",
"Nat.succ_pred_eq_of_pos",
"PosNum.pred'",
"congrArg",
"PosNum.to_nat_pos",
"id",... | [] | rw [pred'_to_nat n, Nat.succ_pred_eq_of_pos (to_nat_pos n)] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Data.Num.Lemmas | {
"line": 498,
"column": 17
} | {
"line": 498,
"column": 67
} | {
"line": 499,
"column": 2
} | [
{
"pp": "n : PosNum\n⊢ ↑n.bit0.size = n.bit0.natSize",
"ppTerm": "?m.9",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"castPosNum",
"Nat.instOne",
"congrArg",
"PosNum.natSize",
"id",
"instOfNatNat",
"PosNum.succ",
"PosNum.size",
"PosNum.b... | [] | rw [size, succ_to_nat, natSize, size_eq_natSize n] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.Data.Num.Lemmas | {
"line": 498,
"column": 17
} | {
"line": 498,
"column": 67
} | {
"line": 499,
"column": 2
} | [
{
"pp": "n : PosNum\n⊢ ↑n.bit0.size = n.bit0.natSize",
"ppTerm": "?m.9",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"castPosNum",
"Nat.instOne",
"congrArg",
"PosNum.natSize",
"id",
"instOfNatNat",
"PosNum.succ",
"PosNum.size",
"PosNum.b... | [] | rw [size, succ_to_nat, natSize, size_eq_natSize n] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Data.Num.Lemmas | {
"line": 498,
"column": 17
} | {
"line": 498,
"column": 67
} | {
"line": 499,
"column": 2
} | [
{
"pp": "n : PosNum\n⊢ ↑n.bit0.size = n.bit0.natSize",
"ppTerm": "?m.9",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"castPosNum",
"Nat.instOne",
"congrArg",
"PosNum.natSize",
"id",
"instOfNatNat",
"PosNum.succ",
"PosNum.size",
"PosNum.b... | [] | rw [size, succ_to_nat, natSize, size_eq_natSize n] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Data.Num.Lemmas | {
"line": 499,
"column": 17
} | {
"line": 499,
"column": 67
} | {
"line": 501,
"column": 0
} | [
{
"pp": "n : PosNum\n⊢ ↑n.bit1.size = n.bit1.natSize",
"ppTerm": "?m.12",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"castPosNum",
"Nat.instOne",
"congrArg",
"PosNum.bit1",
"PosNum.size.eq_3",
"PosNum.natSize",
"id",
"instOfNatNat",
"Po... | [] | rw [size, succ_to_nat, natSize, size_eq_natSize n] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.Data.Num.Lemmas | {
"line": 499,
"column": 17
} | {
"line": 499,
"column": 67
} | {
"line": 501,
"column": 0
} | [
{
"pp": "n : PosNum\n⊢ ↑n.bit1.size = n.bit1.natSize",
"ppTerm": "?m.12",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"castPosNum",
"Nat.instOne",
"congrArg",
"PosNum.bit1",
"PosNum.size.eq_3",
"PosNum.natSize",
"id",
"instOfNatNat",
"Po... | [] | rw [size, succ_to_nat, natSize, size_eq_natSize n] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Data.Num.Lemmas | {
"line": 499,
"column": 17
} | {
"line": 499,
"column": 67
} | {
"line": 501,
"column": 0
} | [
{
"pp": "n : PosNum\n⊢ ↑n.bit1.size = n.bit1.natSize",
"ppTerm": "?m.12",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"castPosNum",
"Nat.instOne",
"congrArg",
"PosNum.bit1",
"PosNum.size.eq_3",
"PosNum.natSize",
"id",
"instOfNatNat",
"Po... | [] | rw [size, succ_to_nat, natSize, size_eq_natSize n] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Data.Num.Lemmas | {
"line": 693,
"column": 26
} | {
"line": 693,
"column": 32
} | {
"line": 693,
"column": 32
} | [
{
"pp": "n : PosNum\nh : 1 < n\ne : n.pred' = zero\nthis : 1 ≤ ↑zero\n⊢ ¬1 ≤ ↑zero",
"ppTerm": "?m.68",
"assigned": true,
"usedConstants": [
"instDecidableNot",
"Nat.instMulZeroClass",
"of_decide_eq_true",
"Nat.instOne",
"id",
"instOfNatNat",
"LE.le",
... | [] | decide | Lean.Elab.Tactic.evalDecide | Lean.Parser.Tactic.decide |
Mathlib.Data.Num.Lemmas | {
"line": 693,
"column": 26
} | {
"line": 693,
"column": 32
} | {
"line": 693,
"column": 32
} | [
{
"pp": "n : PosNum\nh : 1 < n\ne : n.pred' = zero\nthis : 1 ≤ ↑zero\n⊢ ¬1 ≤ ↑zero",
"ppTerm": "?m.68",
"assigned": true,
"usedConstants": [
"instDecidableNot",
"Nat.instMulZeroClass",
"of_decide_eq_true",
"Nat.instOne",
"id",
"instOfNatNat",
"LE.le",
... | [] | decide | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Data.Num.Lemmas | {
"line": 693,
"column": 26
} | {
"line": 693,
"column": 32
} | {
"line": 693,
"column": 32
} | [
{
"pp": "n : PosNum\nh : 1 < n\ne : n.pred' = zero\nthis : 1 ≤ ↑zero\n⊢ ¬1 ≤ ↑zero",
"ppTerm": "?m.68",
"assigned": true,
"usedConstants": [
"instDecidableNot",
"Nat.instMulZeroClass",
"of_decide_eq_true",
"Nat.instOne",
"id",
"instOfNatNat",
"LE.le",
... | [] | decide | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Computability.PartrecBasis | {
"line": 75,
"column": 47
} | {
"line": 75,
"column": 88
} | {
"line": 75,
"column": 88
} | [
{
"pp": "n : ℕ\nf : List.Vector ℕ n →. ℕ\ng : List.Vector ℕ (n + 1) →. ℕ\nhf : Partrec' f\nhg : Partrec' g\ni : Fin n\n⊢ Partrec' (Fin.cases f (fun i v ↦ ↑(some (v.get i))) i.succ)",
"ppTerm": "?m.44",
"assigned": true,
"usedConstants": [
"List.Vector.get",
"PFun",
"Fin.succ",
... | [] | by simpa using! prim (Nat.Primrec'.get i) | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Data.Num.Lemmas | {
"line": 705,
"column": 73
} | {
"line": 705,
"column": 79
} | {
"line": 707,
"column": 0
} | [
{
"pp": "case lt\nm n : PosNum\n⊢ Ordering.lt.swap = Ordering.lt ↔ Ordering.lt = Ordering.gt",
"ppTerm": "?lt",
"assigned": true,
"usedConstants": [
"Ordering.gt",
"instDecidableEqOrdering",
"of_decide_eq_true",
"Ordering",
"id",
"Ordering.swap",
"Bool.true"... | [] | decide | Lean.Elab.Tactic.evalDecide | Lean.Parser.Tactic.decide |
Mathlib.Data.Num.Lemmas | {
"line": 705,
"column": 73
} | {
"line": 705,
"column": 79
} | {
"line": 707,
"column": 0
} | [
{
"pp": "case eq\nm n : PosNum\n⊢ Ordering.eq.swap = Ordering.lt ↔ Ordering.eq = Ordering.gt",
"ppTerm": "?eq",
"assigned": true,
"usedConstants": [
"Ordering.gt",
"instDecidableEqOrdering",
"of_decide_eq_true",
"Ordering",
"Ordering.eq",
"id",
"Ordering.swa... | [] | decide | Lean.Elab.Tactic.evalDecide | Lean.Parser.Tactic.decide |
Mathlib.Data.Num.Lemmas | {
"line": 705,
"column": 73
} | {
"line": 705,
"column": 79
} | {
"line": 707,
"column": 0
} | [
{
"pp": "case gt\nm n : PosNum\n⊢ Ordering.gt.swap = Ordering.lt ↔ Ordering.gt = Ordering.gt",
"ppTerm": "?gt",
"assigned": true,
"usedConstants": [
"Ordering.gt",
"instDecidableEqOrdering",
"of_decide_eq_true",
"Ordering",
"id",
"Ordering.swap",
"Bool.true"... | [] | decide | Lean.Elab.Tactic.evalDecide | Lean.Parser.Tactic.decide |
Mathlib.Data.Num.Lemmas | {
"line": 754,
"column": 73
} | {
"line": 754,
"column": 79
} | {
"line": 756,
"column": 0
} | [
{
"pp": "case lt\nm n : Num\n⊢ Ordering.lt.swap = Ordering.lt ↔ Ordering.lt = Ordering.gt",
"ppTerm": "?lt",
"assigned": true,
"usedConstants": [
"Ordering.gt",
"instDecidableEqOrdering",
"of_decide_eq_true",
"Ordering",
"id",
"Ordering.swap",
"Bool.true",
... | [] | decide | Lean.Elab.Tactic.evalDecide | Lean.Parser.Tactic.decide |
Mathlib.Data.Num.Lemmas | {
"line": 754,
"column": 73
} | {
"line": 754,
"column": 79
} | {
"line": 756,
"column": 0
} | [
{
"pp": "case eq\nm n : Num\n⊢ Ordering.eq.swap = Ordering.lt ↔ Ordering.eq = Ordering.gt",
"ppTerm": "?eq",
"assigned": true,
"usedConstants": [
"Ordering.gt",
"instDecidableEqOrdering",
"of_decide_eq_true",
"Ordering",
"Ordering.eq",
"id",
"Ordering.swap",... | [] | decide | Lean.Elab.Tactic.evalDecide | Lean.Parser.Tactic.decide |
Mathlib.Data.Num.Lemmas | {
"line": 754,
"column": 73
} | {
"line": 754,
"column": 79
} | {
"line": 756,
"column": 0
} | [
{
"pp": "case gt\nm n : Num\n⊢ Ordering.gt.swap = Ordering.lt ↔ Ordering.gt = Ordering.gt",
"ppTerm": "?gt",
"assigned": true,
"usedConstants": [
"Ordering.gt",
"instDecidableEqOrdering",
"of_decide_eq_true",
"Ordering",
"id",
"Ordering.swap",
"Bool.true",
... | [] | decide | Lean.Elab.Tactic.evalDecide | Lean.Parser.Tactic.decide |
Mathlib.Computability.TuringMachine.Tape | {
"line": 103,
"column": 4
} | {
"line": 103,
"column": 64
} | {
"line": 105,
"column": 0
} | [
{
"pp": "case refine_2\nΓ : Type ?u.5\ninst✝ : Inhabited Γ\nl₁ l₂ : List Γ\nh : BlankRel l₁ l₂\nhl : ¬l₁.length ≤ l₂.length\nh' : BlankExtends l₁ l₂\n⊢ BlankExtends l₂ l₁",
"ppTerm": "?refine_2",
"assigned": true,
"usedConstants": [
"le_of_not_ge",
"Nat",
"Turing.BlankExtends.refl"... | [] | exact (BlankExtends.refl _).above_of_le h' (le_of_not_ge hl) | Lean.Elab.Tactic.evalExact | Lean.Parser.Tactic.exact |
Mathlib.Computability.TuringMachine.Tape | {
"line": 103,
"column": 4
} | {
"line": 103,
"column": 64
} | {
"line": 105,
"column": 0
} | [
{
"pp": "case refine_2\nΓ : Type ?u.5\ninst✝ : Inhabited Γ\nl₁ l₂ : List Γ\nh : BlankRel l₁ l₂\nhl : ¬l₁.length ≤ l₂.length\nh' : BlankExtends l₁ l₂\n⊢ BlankExtends l₂ l₁",
"ppTerm": "?refine_2",
"assigned": true,
"usedConstants": [
"le_of_not_ge",
"Nat",
"Turing.BlankExtends.refl"... | [] | exact (BlankExtends.refl _).above_of_le h' (le_of_not_ge hl) | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Computability.TuringMachine.Tape | {
"line": 103,
"column": 4
} | {
"line": 103,
"column": 64
} | {
"line": 105,
"column": 0
} | [
{
"pp": "case refine_2\nΓ : Type ?u.5\ninst✝ : Inhabited Γ\nl₁ l₂ : List Γ\nh : BlankRel l₁ l₂\nhl : ¬l₁.length ≤ l₂.length\nh' : BlankExtends l₁ l₂\n⊢ BlankExtends l₂ l₁",
"ppTerm": "?refine_2",
"assigned": true,
"usedConstants": [
"le_of_not_ge",
"Nat",
"Turing.BlankExtends.refl"... | [] | exact (BlankExtends.refl _).above_of_le h' (le_of_not_ge hl) | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Computability.TuringMachine.Tape | {
"line": 112,
"column": 4
} | {
"line": 112,
"column": 64
} | {
"line": 114,
"column": 0
} | [
{
"pp": "case refine_2\nΓ : Type ?u.5\ninst✝ : Inhabited Γ\nl₁ l₂ : List Γ\nh : BlankRel l₁ l₂\nhl : ¬l₁.length ≤ l₂.length\nh' : BlankExtends l₁ l₂\n⊢ BlankExtends l₂ l₁",
"ppTerm": "?refine_2",
"assigned": true,
"usedConstants": [
"le_of_not_ge",
"Nat",
"Turing.BlankExtends.refl"... | [] | exact (BlankExtends.refl _).above_of_le h' (le_of_not_ge hl) | Lean.Elab.Tactic.evalExact | Lean.Parser.Tactic.exact |
Mathlib.Computability.TuringMachine.Tape | {
"line": 112,
"column": 4
} | {
"line": 112,
"column": 64
} | {
"line": 114,
"column": 0
} | [
{
"pp": "case refine_2\nΓ : Type ?u.5\ninst✝ : Inhabited Γ\nl₁ l₂ : List Γ\nh : BlankRel l₁ l₂\nhl : ¬l₁.length ≤ l₂.length\nh' : BlankExtends l₁ l₂\n⊢ BlankExtends l₂ l₁",
"ppTerm": "?refine_2",
"assigned": true,
"usedConstants": [
"le_of_not_ge",
"Nat",
"Turing.BlankExtends.refl"... | [] | exact (BlankExtends.refl _).above_of_le h' (le_of_not_ge hl) | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Computability.TuringMachine.Tape | {
"line": 112,
"column": 4
} | {
"line": 112,
"column": 64
} | {
"line": 114,
"column": 0
} | [
{
"pp": "case refine_2\nΓ : Type ?u.5\ninst✝ : Inhabited Γ\nl₁ l₂ : List Γ\nh : BlankRel l₁ l₂\nhl : ¬l₁.length ≤ l₂.length\nh' : BlankExtends l₁ l₂\n⊢ BlankExtends l₂ l₁",
"ppTerm": "?refine_2",
"assigned": true,
"usedConstants": [
"le_of_not_ge",
"Nat",
"Turing.BlankExtends.refl"... | [] | exact (BlankExtends.refl _).above_of_le h' (le_of_not_ge hl) | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Computability.TuringMachine.Tape | {
"line": 199,
"column": 2
} | {
"line": 203,
"column": 7
} | {
"line": 205,
"column": 0
} | [
{
"pp": "Γ : Type u_1\ninst✝ : Inhabited Γ\n⊢ ∀ (l : ListBlank Γ), cons l.head l.tail = l",
"ppTerm": "?m.10",
"assigned": true,
"usedConstants": [
"Quotient.sound'",
"Inhabited.default",
"List.replicate",
"Quotient.mk''",
"instOfNatNat",
"List.tail",
"List.... | [] | apply Quotient.ind'
refine fun l ↦ Quotient.sound' (Or.inr ?_)
cases l
· exact ⟨1, rfl⟩
· rfl | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Computability.TuringMachine.Tape | {
"line": 199,
"column": 2
} | {
"line": 203,
"column": 7
} | {
"line": 205,
"column": 0
} | [
{
"pp": "Γ : Type u_1\ninst✝ : Inhabited Γ\n⊢ ∀ (l : ListBlank Γ), cons l.head l.tail = l",
"ppTerm": "?m.10",
"assigned": true,
"usedConstants": [
"Quotient.sound'",
"Inhabited.default",
"List.replicate",
"Quotient.mk''",
"instOfNatNat",
"List.tail",
"List.... | [] | apply Quotient.ind'
refine fun l ↦ Quotient.sound' (Or.inr ?_)
cases l
· exact ⟨1, rfl⟩
· rfl | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Computability.TuringMachine.Tape | {
"line": 245,
"column": 50
} | {
"line": 245,
"column": 54
} | {
"line": 245,
"column": 54
} | [
{
"pp": "case inr.inr\nΓ : Type u_1\ni : Inhabited Γ\nL₁ L₂ : ListBlank Γ\nl₁ l₂ : List Γ\nH : ∀ (i_1 : ℕ), (mk l₁).nth i_1 = (mk l₂).nth i_1\nthis :\n ∀ {Γ : Type u_1} [i : Inhabited Γ] {L₁ L₂ : ListBlank Γ} (l₁ l₂ : List Γ),\n (∀ (i_1 : ℕ), (mk l₁).nth i_1 = (mk l₂).nth i_1) → l₁.length ≤ l₂.length → mk l... | [
"case inr.inr\nΓ : Type u_1\ni : Inhabited Γ\nL₁ L₂ : ListBlank Γ\nl₁ l₂ : List Γ\nH : ∀ (i_1 : ℕ), (mk l₁).nth i_1 = (mk l₂).nth i_1\nthis :\n ∀ {Γ : Type u_1} [i : Inhabited Γ] {L₁ L₂ : ListBlank Γ} (l₁ l₂ : List Γ),\n (∀ (i_1 : ℕ), (mk l₁).nth i_1 = (mk l₂).nth i_1) → l₁.length ≤ l₂.length → mk l₁ = mk l₂\nh... | symm | Lean.Elab.Tactic.evalSymm | Lean.Parser.Tactic.symm |
Mathlib.Computability.StateTransition | {
"line": 188,
"column": 8
} | {
"line": 188,
"column": 16
} | {
"line": 188,
"column": 17
} | [
{
"pp": "case tail.inl.some\nσ₁ : Type u_1\nσ₂ : Type u_2\nf₁ : σ₁ → Option σ₁\nf₂ : σ₂ → Option σ₂\ntr : σ₁ → σ₂ → Prop\nH : Respects f₁ f₂ tr\na₁ : σ₁\na₂ : σ₂\naa : tr a₁ a₂\nb₂ b✝ c✝ : σ₂\na✝ : ReflTransGen (fun a b ↦ b ∈ f₂ a) a₂ b✝\ncd : c✝ ∈ f₂ b✝\ne₁ : σ₁\nae : Reaches f₁ a₁ e₁\nce : Reaches f₂ b✝ b✝\ne... | [
"case tail.inl.some\nσ₁ : Type u_1\nσ₂ : Type u_2\nf₁ : σ₁ → Option σ₁\nf₂ : σ₂ → Option σ₂\ntr : σ₁ → σ₂ → Prop\nH : Respects f₁ f₂ tr\na₁ : σ₁\na₂ : σ₂\naa : tr a₁ a₂\nb₂ b✝ c✝ : σ₂\na✝ : ReflTransGen (fun a b ↦ b ∈ f₂ a) a₂ b✝\ncd : c✝ ∈ f₂ b✝\ne₁ : σ₁\nae : Reaches f₁ a₁ e₁\nce : Reaches f₂ b✝ b✝\nee : tr e₁ b✝... | intro g₂ | Lean.Elab.Tactic.evalIntro | null |
Mathlib.Computability.TuringMachine.PostTuringMachine | {
"line": 699,
"column": 2
} | {
"line": 699,
"column": 33
} | {
"line": 700,
"column": 2
} | [
{
"pp": "Γ : Type u_1\nΛ : Type u_2\nσ : Type u_3\nn : ℕ\nd : Dir\nq : Stmt Bool (Λ' Γ Λ σ) σ\nv : σ\nT : Tape Bool\ni : ℕ\n⊢ stepAux ((Stmt.move d)^[i] q) v T = stepAux q v ((Tape.move d)^[i] T)",
"ppTerm": "?m.36",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"Nat.recAux",
"Fun... | [] | induction i generalizing T with | _private.Lean.Elab.Tactic.Induction.0.Lean.Elab.Tactic.evalInduction | null |
Mathlib.Computability.TuringMachine.StackTuringMachine | {
"line": 379,
"column": 9
} | {
"line": 379,
"column": 13
} | {
"line": 379,
"column": 13
} | [
{
"pp": "case e_l\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✝ (ListBlank.map { f := Prod.mk false, map_pt' := ⋯ } L.tail) =\n ListBlank.map { f := Prod.mk false, map_pt'... | [
"case e_l\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.map { f := Prod.mk false, map_pt' := ⋯ } (ListBlank.modifyNth f n✝ L.tail) =\n ListBlank.modifyNth (fun a ↦ (a.1, f a.2)) n✝ (ListBlank.map { f := Prod.mk ... | symm | Lean.Elab.Tactic.evalSymm | Lean.Parser.Tactic.symm |
Mathlib.Computability.TuringMachine.StackTuringMachine | {
"line": 446,
"column": 61
} | {
"line": 447,
"column": 17
} | {
"line": 449,
"column": 0
} | [
{
"pp": "K : Type u_1\nΓ : K → Type u_2\nΛ : Type u_3\nσ : Type u_4\nS : Finset Λ\nk : K\ns : StAct K Γ σ k\nq : TM2.Stmt Γ Λ σ\n⊢ TM2.SupportsStmt S (stRun s q) ↔ TM2.SupportsStmt S q",
"ppTerm": "?m.15",
"assigned": true,
"usedConstants": [
"Turing.TM2.SupportsStmt",
"Iff.rfl",
"... | [] | by
cases s <;> rfl | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Computability.TuringMachine.StackTuringMachine | {
"line": 511,
"column": 54
} | {
"line": 512,
"column": 17
} | {
"line": 514,
"column": 0
} | [
{
"pp": "K : Type u_1\nΓ : K → Type u_2\nΛ : Type u_3\nσ : Type u_4\nk : K\ns : StAct K Γ σ k\nq : TM2.Stmt Γ Λ σ\n⊢ trNormal (stRun s q) = goto fun x x_1 ↦ go k s q",
"ppTerm": "?m.25",
"assigned": true,
"usedConstants": [
"Turing.TM2to1.trNormal",
"Turing.TM2to1.StAct.pop",
"Turi... | [] | by
cases s <;> rfl | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Computability.TuringMachine.PostTuringMachine | {
"line": 1004,
"column": 4
} | {
"line": 1004,
"column": 83
} | {
"line": 1005,
"column": 4
} | [
{
"pp": "case some\nΓ : Type u_1\ninst✝¹ : Inhabited Γ\nΛ : Type u_2\ninst✝ : Inhabited Λ\nM : TM0.Machine Γ Λ\nx✝ : TM0.Cfg Γ Λ\nq : Λ\nT : Tape Γ\nq' : Λ\ns : TM0.Stmt Γ\ne : M q T.head = some (q', s)\n⊢ FRespects (TM1.step (tr M)) (trCfg M) (trCfg M { q := q, Tape := T }) (TM0.step M { q := q, Tape := T })",... | [
"case some\nΓ : Type u_1\ninst✝¹ : Inhabited Γ\nΛ : Type u_2\ninst✝ : Inhabited Λ\nM : TM0.Machine Γ Λ\nx✝ : TM0.Cfg Γ Λ\nq : Λ\nT : Tape Γ\nq' : Λ\ns : TM0.Stmt Γ\ne : M q T.head = some (q', s)\n⊢ Reaches₁ (TM1.step (tr M)) { l := some (Λ'.normal q), var := (), Tape := T }\n {\n l :=\n match\n ... | simp only [FRespects, TM0.step, trCfg, e, Option.isSome, cond, Option.map_some] | Lean.Elab.Tactic.evalSimp | Lean.Parser.Tactic.simp |
Mathlib.Data.Num.Lemmas | {
"line": 814,
"column": 4
} | {
"line": 814,
"column": 8
} | {
"line": 815,
"column": 4
} | [
{
"pp": "case zero\nn : ℕ\n⊢ ↑0 = ↑zero <<< n",
"ppTerm": "?zero",
"assigned": true,
"usedConstants": [
"Nat.instMulZeroClass",
"Nat.instOne",
"HShiftLeft.hShiftLeft",
"castNum",
"Num",
"instZeroNum",
"Nat",
"instAddNat",
"Zero.toOfNat0",
"... | [
"case zero\nn : ℕ\n⊢ ↑zero <<< n = ↑0"
] | symm | Lean.Elab.Tactic.evalSymm | Lean.Parser.Tactic.symm |
Mathlib.Data.Num.Lemmas | {
"line": 826,
"column": 4
} | {
"line": 826,
"column": 8
} | {
"line": 827,
"column": 4
} | [
{
"pp": "case zero\nn : ℕ\n⊢ ↑0 = ↑zero >>> n",
"ppTerm": "?zero",
"assigned": true,
"usedConstants": [
"Nat.instMulZeroClass",
"Nat.instOne",
"instHShiftRightOfShiftRight",
"castNum",
"Num",
"Nat.instShiftRight",
"instZeroNum",
"HShiftRight.hShiftRigh... | [
"case zero\nn : ℕ\n⊢ ↑zero >>> n = ↑0"
] | symm | Lean.Elab.Tactic.evalSymm | Lean.Parser.Tactic.symm |
Mathlib.Data.Num.Lemmas | {
"line": 834,
"column": 4
} | {
"line": 834,
"column": 8
} | {
"line": 835,
"column": 4
} | [
{
"pp": "case pos.succ.one\nn : ℕ\nIH : ∀ (m : PosNum), ↑(m >>> n) = ↑(pos m) >>> n\nhdiv2 : ∀ (m : ℕ), (m + m).div2 = m\n⊢ ↑0 = ↑(pos one) / 2 ^ (n + 1)",
"ppTerm": "?pos.succ.one",
"assigned": true,
"usedConstants": [
"instPowNat",
"Nat.instMulZeroClass",
"instHDiv",
"Nat.i... | [
"case pos.succ.one\nn : ℕ\nIH : ∀ (m : PosNum), ↑(m >>> n) = ↑(pos m) >>> n\nhdiv2 : ∀ (m : ℕ), (m + m).div2 = m\n⊢ ↑(pos one) / 2 ^ (n + 1) = ↑0"
] | symm | Lean.Elab.Tactic.evalSymm | Lean.Parser.Tactic.symm |
Mathlib.Computability.TuringMachine.ToPartrec | {
"line": 614,
"column": 14
} | {
"line": 614,
"column": 20
} | {
"line": 614,
"column": 20
} | [
{
"pp": "q : Λ'\ns : Option Γ'\nS : K' → List Γ'\n⊢ rev ≠ main",
"ppTerm": "?m.37",
"assigned": true,
"usedConstants": [
"instDecidableNot",
"Turing.PartrecToTM2.K'.rev",
"of_decide_eq_true",
"Turing.PartrecToTM2.instDecidableEqK'",
"id",
"Ne",
"Bool.true",
... | [] | decide | Lean.Elab.Tactic.evalDecide | Lean.Parser.Tactic.decide |
Mathlib.Computability.TuringMachine.ToPartrec | {
"line": 614,
"column": 14
} | {
"line": 614,
"column": 20
} | {
"line": 614,
"column": 20
} | [
{
"pp": "q : Λ'\ns : Option Γ'\nS : K' → List Γ'\n⊢ rev ≠ main",
"ppTerm": "?m.37",
"assigned": true,
"usedConstants": [
"instDecidableNot",
"Turing.PartrecToTM2.K'.rev",
"of_decide_eq_true",
"Turing.PartrecToTM2.instDecidableEqK'",
"id",
"Ne",
"Bool.true",
... | [] | decide | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Computability.TuringMachine.ToPartrec | {
"line": 614,
"column": 14
} | {
"line": 614,
"column": 20
} | {
"line": 614,
"column": 20
} | [
{
"pp": "q : Λ'\ns : Option Γ'\nS : K' → List Γ'\n⊢ rev ≠ main",
"ppTerm": "?m.37",
"assigned": true,
"usedConstants": [
"instDecidableNot",
"Turing.PartrecToTM2.K'.rev",
"of_decide_eq_true",
"Turing.PartrecToTM2.instDecidableEqK'",
"id",
"Ne",
"Bool.true",
... | [] | decide | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Computability.TuringMachine.ToPartrec | {
"line": 708,
"column": 17
} | {
"line": 708,
"column": 23
} | {
"line": 708,
"column": 23
} | [
{
"pp": "q : Λ'\ns : Option Γ'\nL : List ℕ\nc d : List Γ'\no : Option Γ' := List.casesOn L none fun x x_1 ↦ some Γ'.cons\n⊢ main ≠ rev",
"ppTerm": "?m.47",
"assigned": true,
"usedConstants": [
"instDecidableNot",
"Turing.PartrecToTM2.K'.rev",
"of_decide_eq_true",
"Turing.Part... | [] | decide | Lean.Elab.Tactic.evalDecide | Lean.Parser.Tactic.decide |
Mathlib.Computability.TuringMachine.ToPartrec | {
"line": 708,
"column": 17
} | {
"line": 708,
"column": 23
} | {
"line": 708,
"column": 23
} | [
{
"pp": "q : Λ'\ns : Option Γ'\nL : List ℕ\nc d : List Γ'\no : Option Γ' := List.casesOn L none fun x x_1 ↦ some Γ'.cons\n⊢ main ≠ rev",
"ppTerm": "?m.47",
"assigned": true,
"usedConstants": [
"instDecidableNot",
"Turing.PartrecToTM2.K'.rev",
"of_decide_eq_true",
"Turing.Part... | [] | decide | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.