module stringlengths 16 90 | startPos dict | endPos dict | goals listlengths 0 96 | ppTac stringlengths 1 14.5k | elaborator stringclasses 366
values | kind stringclasses 370
values |
|---|---|---|---|---|---|---|
Mathlib.Computability.RE | {
"line": 39,
"column": 2
} | {
"line": 44,
"column": 56
} | [
{
"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 ... | 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.Computability.RE | {
"line": 90,
"column": 18
} | {
"line": 90,
"column": 66
} | [
{
"pp": "α : Type u_1\nσ : Type u_4\ninst✝¹ : Primcodable α\ninst✝ : Primcodable σ\nf g : α →. σ\nhf : Partrec f\nhg : Partrec g\nk : ℕ →. ℕ\nhk : Nat.Partrec k\nH :\n ∀ (a : ℕ),\n (∀ x ∈ k a,\n (x ∈ (↑(decode₂ α a)).bind fun a ↦ Part.map encode (f a)) ∨\n x ∈ (↑(decode₂ α a)).bind fun a ↦ P... | simpa using | Lean.Elab.Tactic.Simpa.evalSimpa | null |
Mathlib.Computability.EpsilonNFA | {
"line": 255,
"column": 4
} | {
"line": 255,
"column": 26
} | [
{
"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'",
"usedConstants": []
}
] | obtain ⟨s₁, _, h⟩ := h | _private.Lean.Elab.Tactic.RCases.0.Lean.Elab.Tactic.RCases.evalObtain | Lean.Parser.Tactic.obtain |
Mathlib.Data.Num.Lemmas | {
"line": 88,
"column": 12
} | {
"line": 88,
"column": 29
} | [
{
"pp": "b : PosNum\n⊢ 1 + b.succ = (1 + b).succ",
"usedConstants": [
"congrArg",
"PosNum.instAdd",
"instOnePosNum",
"PosNum.succ",
"instHAdd",
"HAdd.hAdd",
"congr",
"True",
"eq_self",
"of_eq_true",
"One.toOfNat1",
"PosNum",
"OfNa... | by simp [one_add] | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Computability.EpsilonNFA | {
"line": 311,
"column": 2
} | {
"line": 311,
"column": 9
} | [
{
"pp": "α : Type u\nσ : Type v\nM : NFA α σ\nstart : Set σ\n⊢ M.toεNFA.stepSet = M.stepSet",
"usedConstants": [
"εNFA.stepSet",
"funext",
"NFA.stepSet",
"NFA.toεNFA",
"Set"
]
}
] | ext S s | _private.Lean.Elab.Tactic.Ext.0.Lean.Elab.Tactic.Ext.evalExt | Lean.Elab.Tactic.Ext.ext |
Mathlib.Computability.PartrecBasis | {
"line": 75,
"column": 20
} | {
"line": 75,
"column": 31
} | [
{
"pp": "n : ℕ\nf : List.Vector ℕ n →. ℕ\ng : List.Vector ℕ (n + 1) →. ℕ\nhf : Partrec' f\nhg : Partrec' g\n⊢ Partrec' ((fun i ↦ Fin.cases f (fun i v ↦ ↑(some (v.get i))) i) 0)",
"usedConstants": [
"List.Vector.get",
"instNeZeroNatHAdd_1",
"PFun",
"List.Vector",
"Option.some",
... | simpa using | Lean.Elab.Tactic.Simpa.evalSimpa | null |
Mathlib.Data.Num.Lemmas | {
"line": 147,
"column": 6
} | {
"line": 147,
"column": 56
} | [
{
"pp": "case lt\na b : PosNum\nthis : ↑a < ↑b\n⊢ ↑a + ↑a < ↑b + ↑b + 1",
"usedConstants": [
"castPosNum",
"Nat.instOne",
"Nat.add_lt_add",
"instHAdd",
"HAdd.hAdd",
"Nat",
"instAddNat",
"Nat.le_succ_of_le",
"Nat.succ"
]
}
] | 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
} | [
{
"pp": "case lt\na b : PosNum\nthis : ↑a < ↑b\n⊢ ↑a + ↑a < ↑b + ↑b + 1",
"usedConstants": [
"castPosNum",
"Nat.instOne",
"Nat.add_lt_add",
"instHAdd",
"HAdd.hAdd",
"Nat",
"instAddNat",
"Nat.le_succ_of_le",
"Nat.succ"
]
}
] | 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
} | [
{
"pp": "case lt\na b : PosNum\nthis : ↑a < ↑b\n⊢ ↑a + ↑a < ↑b + ↑b + 1",
"usedConstants": [
"castPosNum",
"Nat.instOne",
"Nat.add_lt_add",
"instHAdd",
"HAdd.hAdd",
"Nat",
"instAddNat",
"Nat.le_succ_of_le",
"Nat.succ"
]
}
] | exact Nat.le_succ_of_le (Nat.add_lt_add this this) | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Computability.PartrecBasis | {
"line": 75,
"column": 49
} | {
"line": 75,
"column": 60
} | [
{
"pp": "n : ℕ\nf : List.Vector ℕ n →. ℕ\ng : List.Vector ℕ (n + 1) →. ℕ\nhf : Partrec' f\nhg : Partrec' g\ni : Fin n\n⊢ Partrec' ((fun i ↦ Fin.cases f (fun i v ↦ ↑(some (v.get i))) i) i.succ)",
"usedConstants": [
"List.Vector.get",
"PFun",
"Fin.succ",
"List.Vector",
"Option.so... | simpa using | Lean.Elab.Tactic.Simpa.evalSimpa | null |
Mathlib.Data.Num.Lemmas | {
"line": 157,
"column": 6
} | {
"line": 157,
"column": 56
} | [
{
"pp": "case gt\na b : PosNum\nthis : ↑b < ↑a\n⊢ ↑b + ↑b < ↑a + ↑a + 1",
"usedConstants": [
"castPosNum",
"Nat.instOne",
"Nat.add_lt_add",
"instHAdd",
"HAdd.hAdd",
"Nat",
"instAddNat",
"Nat.le_succ_of_le",
"Nat.succ"
]
}
] | 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
} | [
{
"pp": "case gt\na b : PosNum\nthis : ↑b < ↑a\n⊢ ↑b + ↑b < ↑a + ↑a + 1",
"usedConstants": [
"castPosNum",
"Nat.instOne",
"Nat.add_lt_add",
"instHAdd",
"HAdd.hAdd",
"Nat",
"instAddNat",
"Nat.le_succ_of_le",
"Nat.succ"
]
}
] | 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
} | [
{
"pp": "case gt\na b : PosNum\nthis : ↑b < ↑a\n⊢ ↑b + ↑b < ↑a + ↑a + 1",
"usedConstants": [
"castPosNum",
"Nat.instOne",
"Nat.add_lt_add",
"instHAdd",
"HAdd.hAdd",
"Nat",
"instAddNat",
"Nat.le_succ_of_le",
"Nat.succ"
]
}
] | exact Nat.le_succ_of_le (Nat.add_lt_add this this) | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Computability.PartrecBasis | {
"line": 80,
"column": 2
} | {
"line": 80,
"column": 48
} | [
{
"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)",
"usedConstants": [
"Part",
"Eq.mpr",
"congrArg",
"Part.bind",
"Part.some",
"List.Vector",
"id",
... | simpa using | Lean.Elab.Tactic.Simpa.evalSimpa | null |
Mathlib.Computability.PartrecBasis | {
"line": 93,
"column": 16
} | {
"line": 93,
"column": 27
} | [
{
"pp": "n m : ℕ\nf : List.Vector ℕ n → ℕ\ng : List.Vector ℕ n → List.Vector ℕ m\nhf : Partrec' ↑f\nhg : Vec g\ni : Fin m.succ\n⊢ Partrec' fun v ↦ ↑(some (((fun v ↦ f v ::ᵥ g v) v).get 0))",
"usedConstants": [
"List.Vector.get",
"Part",
"Eq.mpr",
"instNeZeroNatHAdd_1",
"congrAr... | simpa using | Lean.Elab.Tactic.Simpa.evalSimpa | null |
Mathlib.Computability.PartrecBasis | {
"line": 103,
"column": 2
} | {
"line": 103,
"column": 13
} | [
{
"pp": "n : ℕ\nf : ℕ →. ℕ\ng : List.Vector ℕ n → ℕ\nhf : Partrec' fun v ↦ f v.head\nhg : Partrec' ↑g\n⊢ Partrec' fun v ↦ f (g v)",
"usedConstants": []
}
] | simpa using | Lean.Elab.Tactic.Simpa.evalSimpa | null |
Mathlib.Data.Num.Lemmas | {
"line": 306,
"column": 6
} | {
"line": 306,
"column": 73
} | [
{
"pp": "p : PosNum\n⊢ Num.ofNat' ↑p.bit0 = Num.pos p.bit0",
"usedConstants": []
}
] | simpa using | Lean.Elab.Tactic.Simpa.evalSimpa | null |
Mathlib.Computability.RE | {
"line": 198,
"column": 53
} | {
"line": 198,
"column": 64
} | [
{
"pp": "α : Type u_1\ninst✝ : Primcodable α\nf : α → Bool\nh : Computable f\n⊢ Computable fun a ↦ decide ((fun a ↦ f a = true) a)",
"usedConstants": [
"Eq.mpr",
"congrArg",
"inferInstance",
"id",
"instDecidableEqBool",
"Bool.true",
"funext",
"Bool.decide_eq_t... | simpa using | Lean.Elab.Tactic.Simpa.evalSimpa | null |
Mathlib.Data.Num.Lemmas | {
"line": 308,
"column": 6
} | {
"line": 308,
"column": 71
} | [
{
"pp": "p : PosNum\n⊢ Num.ofNat' ↑p.bit1 = Num.pos p.bit1",
"usedConstants": []
}
] | simpa using | Lean.Elab.Tactic.Simpa.evalSimpa | null |
Mathlib.Computability.RE | {
"line": 209,
"column": 2
} | {
"line": 209,
"column": 32
} | [
{
"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",
"usedConstants": []
}
] | simpa using | Lean.Elab.Tactic.Simpa.evalSimpa | null |
Mathlib.Computability.PartrecBasis | {
"line": 138,
"column": 4
} | {
"line": 138,
"column": 34
} | [
{
"pp": "c : Code\nhf : Nat.Partrec c.eval\n⊢ Partrec' fun v ↦ c.eval v.head",
"usedConstants": [
"Part",
"Eq.mpr",
"Nat.Partrec.Code.evaln",
"congrArg",
"List.Vector.head",
"List.Vector",
"id",
"instOfNatNat",
"funext",
"Nat",
"Nat.rfindOpt"... | simpa using | Lean.Elab.Tactic.Simpa.evalSimpa | null |
Mathlib.Computability.PartrecBasis | {
"line": 164,
"column": 15
} | {
"line": 164,
"column": 42
} | [
{
"pp": "m n : ℕ\nf : List.Vector ℕ m → List.Vector ℕ n\nh : Vec f\n⊢ Computable f",
"usedConstants": []
}
] | simpa using | Lean.Elab.Tactic.Simpa.evalSimpa | null |
Mathlib.Data.Num.Lemmas | {
"line": 538,
"column": 21
} | {
"line": 538,
"column": 45
} | [
{
"pp": "α : Type u_1\n⊢ ∀ (a b c : PosNum), a * (b + c) = a * b + a * c",
"usedConstants": [
"Distrib.leftDistribClass",
"Eq.mpr",
"castPosNum",
"HMul.hMul",
"Nat.instOne",
"congrArg",
"PosNum.instAdd",
"id",
"PosNum.to_nat_inj",
"instMulNat",
... | transfer; simp [mul_add] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Data.Num.Lemmas | {
"line": 538,
"column": 21
} | {
"line": 538,
"column": 45
} | [
{
"pp": "α : Type u_1\n⊢ ∀ (a b c : PosNum), a * (b + c) = a * b + a * c",
"usedConstants": [
"Distrib.leftDistribClass",
"Eq.mpr",
"castPosNum",
"HMul.hMul",
"Nat.instOne",
"congrArg",
"PosNum.instAdd",
"id",
"PosNum.to_nat_inj",
"instMulNat",
... | transfer; simp [mul_add] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Data.Num.Lemmas | {
"line": 608,
"column": 27
} | {
"line": 609,
"column": 40
} | [
{
"pp": "α : Type u_1\ninst✝² : Semiring α\ninst✝¹ : LinearOrder α\ninst✝ : IsStrictOrderedRing α\nm n : PosNum\n⊢ ↑m ≤ ↑n ↔ m ≤ n",
"usedConstants": [
"Eq.mpr",
"NonAssocSemiring.toAddCommMonoidWithOne",
"castPosNum",
"Preorder.toLT",
"congrArg",
"PartialOrder.toPreorder... | by
rw [← not_lt]; exact not_congr cast_lt | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Data.Num.Lemmas | {
"line": 742,
"column": 27
} | {
"line": 743,
"column": 40
} | [
{
"pp": "α : Type u_1\ninst✝² : Semiring α\ninst✝¹ : LinearOrder α\ninst✝ : IsStrictOrderedRing α\nm n : Num\n⊢ ↑m ≤ ↑n ↔ m ≤ n",
"usedConstants": [
"Num.cast_lt",
"Eq.mpr",
"NonAssocSemiring.toAddCommMonoidWithOne",
"Preorder.toLT",
"congrArg",
"PartialOrder.toPreorder",... | by
rw [← not_lt]; exact not_congr cast_lt | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Computability.TuringMachine.Tape | {
"line": 267,
"column": 4
} | {
"line": 268,
"column": 70
} | [
{
"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",
"usedConstants": [
"Turing.ListBlank.modifyNth",
"Turing.ListBlank.nth_zero",
"False",
"instDecidableTrue",
"if_true",
... | 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
} | [
{
"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",
"usedConstants": [
"Turing.ListBlank.modifyNth",
"Turing.ListBlank.nth_zero",
"False",
"instDecidableTrue",
"if_true",
... | 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
} | [
{
"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",
"usedConstants": [
"Turing.ListBlank.modifyNth",
"Turing.ListBlank.nth_zero",
"False",
"instDecidableTrue",
"if_true",
... | 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
} | [
{
"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 (... | 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
} | [
{
"pp": "Γ : Type u_1\ninst✝ : Inhabited Γ\nT : Tape Γ\nn : ℕ\n⊢ T.right₀.nth n = T.nth ↑n",
"usedConstants": [
"Turing.ListBlank.nth_zero",
"congrArg",
"Turing.Tape.nth",
"Turing.ListBlank.nth_succ",
"instOfNatNat",
"Int",
"Turing.ListBlank.head_cons",
"Nat.c... | 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
} | [
{
"pp": "Γ : Type u_1\ninst✝ : Inhabited Γ\nT : Tape Γ\nn : ℕ\n⊢ T.right₀.nth n = T.nth ↑n",
"usedConstants": [
"Turing.ListBlank.nth_zero",
"congrArg",
"Turing.Tape.nth",
"Turing.ListBlank.nth_succ",
"instOfNatNat",
"Int",
"Turing.ListBlank.head_cons",
"Nat.c... | 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
} | [
{
"pp": "Γ : Type u_1\ninst✝ : Inhabited Γ\nT : Tape Γ\nn : ℕ\n⊢ T.right₀.nth n = T.nth ↑n",
"usedConstants": [
"Turing.ListBlank.nth_zero",
"congrArg",
"Turing.Tape.nth",
"Turing.ListBlank.nth_succ",
"instOfNatNat",
"Int",
"Turing.ListBlank.head_cons",
"Nat.c... | 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
} | [
{
"pp": "f : ℕ →. ℕ\nO : Set (ℕ →. ℕ)\n⊢ RecursiveIn O f ↔ Nat.RecursiveIn O f",
"usedConstants": [
"Part",
"congrArg",
"Part.bind",
"Primcodable.ofDenumerable",
"Part.some",
"Part.bind_some",
"RecursiveIn",
"iff_self",
"funext",
"Iff",
"Part... | by
simp [RecursiveIn, Part.map_id'] | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Computability.RecursiveIn | {
"line": 208,
"column": 31
} | {
"line": 208,
"column": 69
} | [
{
"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",
"usedConstants": []
}
] | simpa using | Lean.Elab.Tactic.Simpa.evalSimpa | null |
Mathlib.Computability.RecursiveIn | {
"line": 219,
"column": 40
} | {
"line": 219,
"column": 74
} | [
{
"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",
"usedConstants": []
}
] | simpa using | Lean.Elab.Tactic.Simpa.evalSimpa | null |
Mathlib.Computability.Reduce | {
"line": 130,
"column": 31
} | {
"line": 130,
"column": 42
} | [
{
"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 ... | simpa using | Lean.Elab.Tactic.Simpa.evalSimpa | null |
Mathlib.Computability.Reduce | {
"line": 380,
"column": 2
} | {
"line": 380,
"column": 13
} | [
{
"pp": "case h.h\np✝¹ p✝ : Set ℕ\n⊢ of p✝¹ ≤ of p✝ → of p✝ ≤ of p✝¹ → of p✝¹ = of p✝",
"usedConstants": [
"ManyOneDegree.instLE",
"Primcodable.ofDenumerable",
"instInhabitedNat",
"LE.le",
"Nat",
"ManyOneDegree",
"Denumerable.nat",
"ManyOneDegree.of"
]
}... | intro hp hq | Lean.Elab.Tactic.evalIntro | Lean.Parser.Tactic.intro |
Mathlib.Computability.Reduce | {
"line": 425,
"column": 2
} | {
"line": 425,
"column": 39
} | [
{
"pp": "case h.h.h\np✝² p✝¹ p✝ : Set ℕ\n⊢ of p✝² + of p✝¹ ≤ of p✝ ↔ of p✝² ≤ of p✝ ∧ of p✝¹ ≤ of p✝",
"usedConstants": [
"ManyOneDegree.instLE",
"Eq.mpr",
"instInhabitedOfMonad",
"congrArg",
"Primcodable.ofDenumerable",
"_private.Mathlib.Computability.Reduce.0.ManyOneDeg... | simpa using | Lean.Elab.Tactic.Simpa.evalSimpa | null |
Mathlib.Computability.TuringMachine.PostTuringMachine | {
"line": 579,
"column": 16
} | {
"line": 579,
"column": 44
} | [
{
"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... | 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
} | [
{
"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... | refine TM1.stmts_trans ?_ h₂ | Lean.Elab.Tactic.evalRefine | Lean.Parser.Tactic.refine |
Mathlib.Computability.TuringMachine.PostTuringMachine | {
"line": 771,
"column": 4
} | {
"line": 771,
"column": 64
} | [
{
"pp": "Γ : Type u_1\nn : ℕ\nenc : Γ → List.Vector Bool n\ninst✝ : Inhabited Γ\nenc0 : enc default = List.Vector.replicate n false\nR : ListBlank Γ\na : Γ\nL : ListBlank Γ\nthis :\n ∀ {L' R' : ListBlank Bool} {l₁ l₂ : List Bool},\n (enc a).toList = l₁.reverseAux l₂ →\n (Tape.move Dir.left)^[l₁.length]... | simpa using | Lean.Elab.Tactic.Simpa.evalSimpa | null |
Mathlib.Computability.RegularExpressions | {
"line": 262,
"column": 8
} | {
"line": 263,
"column": 28
} | [
{
"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
} | [
{
"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.TuringMachine.PostTuringMachine | {
"line": 866,
"column": 6
} | {
"line": 866,
"column": 17
} | [
{
"pp": "case some.write\nΓ : Type u_1\nΛ : Type u_2\nσ : Type u_3\nn : ℕ\nenc : Γ → List.Vector Bool n\ndec : List.Vector Bool n → Γ\nM : Λ → Stmt Γ Λ σ\ninst✝ : Inhabited Γ\nenc0 : enc default = List.Vector.replicate n false\nencdec : ∀ (a : Γ), dec (enc a) = a\nx✝ : Cfg Γ Λ σ\nf : Γ → σ → Γ\nq : Stmt Γ Λ σ\n... | simpa using | Lean.Elab.Tactic.Simpa.evalSimpa | null |
Mathlib.Computability.RegularExpressions | {
"line": 291,
"column": 12
} | {
"line": 291,
"column": 47
} | [
{
"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 :... | specialize helem (b :: t) (by simp) | Lean.Elab.Tactic.evalSpecialize | Lean.Parser.Tactic.specialize |
Mathlib.Data.Num.Lemmas | {
"line": 801,
"column": 2
} | {
"line": 801,
"column": 84
} | [
{
"pp": "⊢ ∀ (m n : Num), ↑(m &&& n) = ↑m &&& ↑n",
"usedConstants": [
"cond",
"Num.bit",
"Num.castNum_eq_bitwise",
"Num.instAndOp",
"PosNum.bit",
"Bool.and",
"instOnePosNum",
"Bool.true",
"Num",
"Bool.casesOn",
"instZeroNum",
"PosNum.la... | 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_<;>_» |
Mathlib.Data.Num.Lemmas | {
"line": 801,
"column": 2
} | {
"line": 801,
"column": 84
} | [
{
"pp": "⊢ ∀ (m n : Num), ↑(m &&& n) = ↑m &&& ↑n",
"usedConstants": [
"cond",
"Num.bit",
"Num.castNum_eq_bitwise",
"Num.instAndOp",
"PosNum.bit",
"Bool.and",
"instOnePosNum",
"Bool.true",
"Num",
"Bool.casesOn",
"instZeroNum",
"PosNum.la... | apply castNum_eq_bitwise PosNum.land <;> intros <;> (try cases_type* Bool) <;> rfl | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Data.Num.Lemmas | {
"line": 801,
"column": 2
} | {
"line": 801,
"column": 84
} | [
{
"pp": "⊢ ∀ (m n : Num), ↑(m &&& n) = ↑m &&& ↑n",
"usedConstants": [
"cond",
"Num.bit",
"Num.castNum_eq_bitwise",
"Num.instAndOp",
"PosNum.bit",
"Bool.and",
"instOnePosNum",
"Bool.true",
"Num",
"Bool.casesOn",
"instZeroNum",
"PosNum.la... | apply castNum_eq_bitwise PosNum.land <;> intros <;> (try cases_type* Bool) <;> rfl | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Computability.TuringMachine.Config | {
"line": 278,
"column": 40
} | {
"line": 278,
"column": 82
} | [
{
"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",
"usedConstants"... | simpa using | Lean.Elab.Tactic.Simpa.evalSimpa | null |
Mathlib.Computability.TuringMachine.Config | {
"line": 280,
"column": 6
} | {
"line": 280,
"column": 37
} | [
{
"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... | simpa using | Lean.Elab.Tactic.Simpa.evalSimpa | null |
Mathlib.Computability.TuringMachine.StackTuringMachine | {
"line": 378,
"column": 4
} | {
"line": 378,
"column": 88
} | [
{
"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)",
"usedConstants": [
"Turing.TM2to1.addBottom",
... | 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
} | [
{
"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)",
"usedConstants": [
"Turing.TM2... | simp only [addBottom, ListBlank.head_cons, ListBlank.modifyNth, ListBlank.tail_cons] | Lean.Elab.Tactic.evalSimp | Lean.Parser.Tactic.simp |
Mathlib.Computability.TuringMachine.StackTuringMachine | {
"line": 529,
"column": 14
} | {
"line": 529,
"column": 41
} | [
{
"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",
"usedConstants": [
"Finset.instUnion",
"Finset",
"Classical.propDecidable",
"... | simp only [trStmts₁, stRun] | Lean.Elab.Tactic.evalSimp | Lean.Parser.Tactic.simp |
Mathlib.Computability.TuringMachine.StackTuringMachine | {
"line": 529,
"column": 14
} | {
"line": 529,
"column": 41
} | [
{
"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",
"usedConstants": [
"Finset.instUnion",
"Finset",
"Classical.propDecida... | simp only [trStmts₁, stRun] | Lean.Elab.Tactic.evalSimp | Lean.Parser.Tactic.simp |
Mathlib.Computability.TuringMachine.StackTuringMachine | {
"line": 529,
"column": 14
} | {
"line": 529,
"column": 41
} | [
{
"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",
"usedConstants": [
"Finset.instUnion",
"Finset",
"Turing.TM2to1.StAct.pop... | simp only [trStmts₁, stRun] | Lean.Elab.Tactic.evalSimp | Lean.Parser.Tactic.simp |
Mathlib.Computability.TuringMachine.StackTuringMachine | {
"line": 566,
"column": 8
} | {
"line": 566,
"column": 63
} | [
{
"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\... | simpa using | Lean.Elab.Tactic.Simpa.evalSimpa | null |
Mathlib.Computability.TuringDegree | {
"line": 80,
"column": 15
} | {
"line": 80,
"column": 26
} | [
{
"pp": "f g h : ℕ →. ℕ\nhg : f ≤ᵀ g\nhh : g ≤ᵀ h\n⊢ ∀ g_1 ∈ {g}, RecursiveIn {h} g_1",
"usedConstants": [
"Eq.mpr",
"PFun",
"Primcodable.ofDenumerable",
"RecursiveIn",
"Membership.mem",
"Set.instSingletonSet",
"id",
"forall_eq._simp_1",
"implies_congr",... | simpa using | Lean.Elab.Tactic.Simpa.evalSimpa | null |
Mathlib.Computability.TuringMachine.StackTuringMachine | {
"line": 607,
"column": 10
} | {
"line": 607,
"column": 65
} | [
{
"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\... | simpa using | Lean.Elab.Tactic.Simpa.evalSimpa | null |
Mathlib.Topology.Category.CompHaus.EffectiveEpi | {
"line": 79,
"column": 4
} | {
"line": 79,
"column": 15
} | [
{
"pp": "α : Type\ninst✝ : Finite α\nB : CompHaus\nX : α → CompHaus\nπ : (a : α) → X a ⟶ B\ntfae_2_to_1 : Epi (Sigma.desc π) → EffectiveEpiFamily X π\ntfae_1_to_2 : EffectiveEpiFamily X π → Epi (Sigma.desc π)\nx✝ : ∀ (b : ↑B.toTop), ∃ a x, (ConcreteCategory.hom (π a)) x = b\ne : ∀ (b : ↑B.toTop), ∃ a x, (Concre... | simpa using | Lean.Elab.Tactic.Simpa.evalSimpa | null |
Mathlib.Computability.TuringMachine.StackTuringMachine | {
"line": 692,
"column": 2
} | {
"line": 692,
"column": 20
} | [
{
"pp": "K : Type u_1\nΓ : K → Type u_2\nΛ : Type u_3\nσ : Type u_4\ninst✝ : DecidableEq K\nM : Λ → TM2.Stmt Γ Λ σ\nv : σ\nS : (k : K) → List (Γ k)\nL : ListBlank ((k : K) → Option (Γ k))\nhT : ∀ (k : K), ListBlank.map (proj k) L = ListBlank.mk (List.map some (S k)).reverse\nl : Λ\n⊢ ∃ b,\n TrCfg (TM2.stepAu... | generalize M l = N | Lean.Elab.Tactic.evalGeneralize | Lean.Parser.Tactic.generalize |
Mathlib.Topology.Separation.Profinite | {
"line": 109,
"column": 4
} | {
"line": 109,
"column": 69
} | [
{
"pp": "H : Type u_3\ninst✝³ : TopologicalSpace H\ninst✝² : LocallyCompactSpace H\ninst✝¹ : T2Space H\ninst✝ : TotallyDisconnectedSpace H\nU : Set H\nhU : IsOpen[inst✝³] U\ns : Set H\ncomp : IsCompact s\nsU : s ⊆ U\nu : Set ↑s := Subtype.val ⁻¹' interior s\nu_open_in_s : IsOpen[instTopologicalSpaceSubtype] u\n... | have f2 : IsOpen v := VisClopen.2.preimage continuous_subtype_val | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_tacticHave___1 | Lean.Parser.Tactic.tacticHave__ |
Mathlib.Topology.Separation.Profinite | {
"line": 159,
"column": 58
} | {
"line": 159,
"column": 69
} | [
{
"pp": "X : Type u_4\nI : Type u_5\ninst✝⁴ : TopologicalSpace X\ninst✝³ : CompactSpace X\ninst✝² : T2Space X\ninst✝¹ : TotallyDisconnectedSpace X\ninst✝ : Finite I\nα✝ β✝ : Type u_5\ne : α✝ ≃ β✝\nIH :\n ∀ {Z D : α✝ → Set X},\n (∀ (i : α✝), IsClosed[inst✝⁴] (Z i)) →\n (∀ (i : α✝), IsClopen (D i)) →\n ... | simpa using | Lean.Elab.Tactic.Simpa.evalSimpa | null |
Mathlib.Topology.Separation.Profinite | {
"line": 160,
"column": 17
} | {
"line": 160,
"column": 28
} | [
{
"pp": "X : Type u_4\nI : Type u_5\ninst✝⁴ : TopologicalSpace X\ninst✝³ : CompactSpace X\ninst✝² : T2Space X\ninst✝¹ : TotallyDisconnectedSpace X\ninst✝ : Finite I\nα✝ β✝ : Type u_5\ne : α✝ ≃ β✝\nIH :\n ∀ {Z D : α✝ → Set X},\n (∀ (i : α✝), IsClosed[inst✝⁴] (Z i)) →\n (∀ (i : α✝), IsClopen (D i)) →\n ... | simpa using | Lean.Elab.Tactic.Simpa.evalSimpa | null |
Mathlib.Topology.Separation.Profinite | {
"line": 163,
"column": 4
} | {
"line": 163,
"column": 49
} | [
{
"pp": "case of_equiv\nX : Type u_4\nI : Type u_5\ninst✝⁴ : TopologicalSpace X\ninst✝³ : CompactSpace X\ninst✝² : T2Space X\ninst✝¹ : TotallyDisconnectedSpace X\ninst✝ : Finite I\nα✝ β✝ : Type u_5\ne : α✝ ≃ β✝\nIH :\n ∀ {Z D : α✝ → Set X},\n (∀ (i : α✝), IsClosed[inst✝⁴] (Z i)) →\n (∀ (i : α✝), IsClop... | simpa using | Lean.Elab.Tactic.Simpa.evalSimpa | null |
Mathlib.Topology.Separation.Profinite | {
"line": 178,
"column": 6
} | {
"line": 178,
"column": 17
} | [
{
"pp": "X : Type u_4\nI✝ : Type u_5\ninst✝⁵ : TopologicalSpace X\ninst✝⁴ : CompactSpace X\ninst✝³ : T2Space X\ninst✝² : TotallyDisconnectedSpace X\ninst✝¹ : Finite I✝\nI : Type u_5\ninst✝ : Fintype I\nIH :\n ∀ {Z D : I → Set X},\n (∀ (i : I), IsClosed[inst✝⁵] (Z i)) →\n (∀ (i : I), IsClopen (D i)) →\n... | simpa using | Lean.Elab.Tactic.Simpa.evalSimpa | null |
Mathlib.Topology.ExtremallyDisconnected | {
"line": 186,
"column": 4
} | {
"line": 186,
"column": 43
} | [
{
"pp": "case pos\nA E : Type u\ninst✝¹ : TopologicalSpace A\ninst✝ : TopologicalSpace E\nρ : E → A\nρ_cont : Continuous ρ\nρ_surj : Surjective ρ\nzorn_subset : ∀ (E₀ : Set E), E₀ ≠ univ → IsClosed E₀ → ρ '' E₀ ≠ univ\nG : Set E\nhG : IsOpen G\nG_empty : G = ∅\n⊢ ρ '' G ⊆ closure (ρ '' Gᶜ)ᶜ",
"usedConstants... | simpa using | Lean.Elab.Tactic.Simpa.evalSimpa | null |
Mathlib.Topology.ExtremallyDisconnected | {
"line": 202,
"column": 36
} | {
"line": 202,
"column": 47
} | [
{
"pp": "A E : Type u\ninst✝¹ : TopologicalSpace A\ninst✝ : TopologicalSpace E\nρ : E → A\nρ_cont : Continuous ρ\nρ_surj : Surjective ρ\nzorn_subset : ∀ (E₀ : Set E), E₀ ≠ univ → IsClosed E₀ → ρ '' E₀ ≠ univ\nG : Set E\nhG : IsOpen G\nG_empty : ¬G = ∅\nN : Set A\nN_open : IsOpen N\ne : E\nhe : e ∈ G\nha : ρ e ∈... | simpa using | Lean.Elab.Tactic.Simpa.evalSimpa | null |
Mathlib.Topology.Category.Stonean.Basic | {
"line": 146,
"column": 4
} | {
"line": 147,
"column": 11
} | [
{
"pp": "case h.h.h.hnc\nX Y : Stonean\nf : X ⟶ Y\nh✝ : Epi f\ny : ↑Y.toTop\nhy : ∀ (a : ↑X.toTop), (ConcreteCategory.hom f) a ≠ y\nC : Set ((fun X ↦ ↑X.toTop) Y) := Set.range ⇑(ConcreteCategory.hom f)\nhC : IsClosed C\nU : Set ((fun X ↦ ↑X.toTop) Y) := Cᶜ\nhUy : U ∈ 𝓝 y\nV : Set ↑Y.toTop\nhV : V ∈ {s | IsClop... | simpa using | Lean.Elab.Tactic.Simpa.evalSimpa | null |
Mathlib.Topology.Separation.Profinite | {
"line": 216,
"column": 8
} | {
"line": 216,
"column": 93
} | [
{
"pp": "case h_option.refine_5.none.some\nX : Type u_4\nI✝ : Type u_5\ninst✝⁵ : TopologicalSpace X\ninst✝⁴ : CompactSpace X\ninst✝³ : T2Space X\ninst✝² : TotallyDisconnectedSpace X\ninst✝¹ : Finite I✝\nI : Type u_5\ninst✝ : Fintype I\nIH :\n ∀ {Z D : I → Set X},\n (∀ (i : I), IsClosed[inst✝⁵] (Z i)) →\n ... | simpa using | Lean.Elab.Tactic.Simpa.evalSimpa | null |
Mathlib.Topology.Separation.Profinite | {
"line": 218,
"column": 8
} | {
"line": 218,
"column": 93
} | [
{
"pp": "case h_option.refine_5.some.none\nX : Type u_4\nI✝ : Type u_5\ninst✝⁵ : TopologicalSpace X\ninst✝⁴ : CompactSpace X\ninst✝³ : T2Space X\ninst✝² : TotallyDisconnectedSpace X\ninst✝¹ : Finite I✝\nI : Type u_5\ninst✝ : Fintype I\nIH :\n ∀ {Z D : I → Set X},\n (∀ (i : I), IsClosed[inst✝⁵] (Z i)) →\n ... | simpa using | Lean.Elab.Tactic.Simpa.evalSimpa | null |
Mathlib.Topology.Separation.Profinite | {
"line": 220,
"column": 8
} | {
"line": 220,
"column": 19
} | [
{
"pp": "case h_option.refine_5.some.some\nX : Type u_4\nI✝ : Type u_5\ninst✝⁵ : TopologicalSpace X\ninst✝⁴ : CompactSpace X\ninst✝³ : T2Space X\ninst✝² : TotallyDisconnectedSpace X\ninst✝¹ : Finite I✝\nI : Type u_5\ninst✝ : Fintype I\nIH :\n ∀ {Z D : I → Set X},\n (∀ (i : I), IsClosed[inst✝⁵] (Z i)) →\n ... | simpa using | Lean.Elab.Tactic.Simpa.evalSimpa | null |
Mathlib.Computability.TuringMachine.ToPartrec | {
"line": 1144,
"column": 2
} | {
"line": 1144,
"column": 24
} | [
{
"pp": "K : Option Γ' → Finset Λ'\nS : Finset Λ'\n⊢ Supports (Finset.univ.biUnion K) S ↔ ∀ (a : Option Γ'), Supports (K a) S",
"usedConstants": [
"Eq.mpr",
"Turing.TM2.SupportsStmt",
"Turing.PartrecToTM2.tr",
"Finset.univ",
"Turing.PartrecToTM2.Γ'",
"congrArg",
"Tu... | simpa using | Lean.Elab.Tactic.Simpa.evalSimpa | null |
Mathlib.Topology.DiscreteQuotient | {
"line": 234,
"column": 8
} | {
"line": 234,
"column": 84
} | [
{
"pp": "case h.e'_3.h\nα : Type u_1\nX : Type u_2\nY : Type u_3\nZ : Type u_4\ninst✝³ : TopologicalSpace X\ninst✝² : TopologicalSpace Y\ninst✝¹ : TopologicalSpace Z\nS : DiscreteQuotient X\ninst✝ : LocallyConnectedSpace X\nx y : X\n⊢ y ∈ setOf ((connectedComponentSetoid X) x) ↔ y ∈ connectedComponent x",
"... | simpa using | Lean.Elab.Tactic.Simpa.evalSimpa | null |
Mathlib.Topology.DiscreteQuotient | {
"line": 376,
"column": 4
} | {
"line": 376,
"column": 21
} | [
{
"pp": "case h.h.mp.h\nX : Type u_2\ninst✝¹ : TopologicalSpace X\ninst✝ : CompactSpace X\nd : DiscreteQuotient X\nx✝² : Set X\nx✝¹ : ∃ a, d.proj ⁻¹' {a} = x✝²\ny : Quotient d.toSetoid\nh : d.proj ⁻¹' {y} = x✝²\nx✝ : X\n⊢ x✝ ∈ x✝² ↔ x✝ ∈ {x | d.toSetoid x y.out}",
"usedConstants": [
"Eq.mpr",
"D... | simpa using | Lean.Elab.Tactic.Simpa.evalSimpa | null |
Mathlib.Topology.DiscreteQuotient | {
"line": 384,
"column": 2
} | {
"line": 384,
"column": 14
} | [
{
"pp": "X : Type u_2\ninst✝¹ : TopologicalSpace X\ninst✝ : CompactSpace X\n⊢ Injective fun x ↦\n match x with\n | { toSetoid := f, isOpen_setOf_rel := isOpen_setOf_rel } => f.classes",
"usedConstants": [
"DiscreteQuotient"
]
}
] | intro ⟨_, _⟩ | Lean.Elab.Tactic.evalIntro | null |
Mathlib.Topology.Category.Profinite.CofilteredLimit | {
"line": 87,
"column": 4
} | {
"line": 92,
"column": 55
} | [
{
"pp": "case refine_3.refine_1\nJ : Type v\ninst✝¹ : SmallCategory J\ninst✝ : IsCofiltered J\nF : J ⥤ Profinite\nC : Cone F\nU : Set ↑C.pt.toTop\nhC : IsLimit C\nhU : IsClopen U\nS : Set (Set ↑(toTopCat.mapCone C).pt)\nhS : S ⊆ {U | ∃ j, ∃ V ∈ (fun j ↦ {W | IsClopen W}) j, U = ⇑(ConcreteCategory.hom ((toTopCat... | apply isClopen_biUnion_finset
intro s hs
dsimp [W]
rw [dif_pos hs]
exact ⟨(hV s).1.1.preimage (F.map _).hom.hom.continuous,
(hV s).1.2.preimage (F.map _).hom.hom.continuous⟩ | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Topology.Category.Profinite.CofilteredLimit | {
"line": 87,
"column": 4
} | {
"line": 92,
"column": 55
} | [
{
"pp": "case refine_3.refine_1\nJ : Type v\ninst✝¹ : SmallCategory J\ninst✝ : IsCofiltered J\nF : J ⥤ Profinite\nC : Cone F\nU : Set ↑C.pt.toTop\nhC : IsLimit C\nhU : IsClopen U\nS : Set (Set ↑(toTopCat.mapCone C).pt)\nhS : S ⊆ {U | ∃ j, ∃ V ∈ (fun j ↦ {W | IsClopen W}) j, U = ⇑(ConcreteCategory.hom ((toTopCat... | apply isClopen_biUnion_finset
intro s hs
dsimp [W]
rw [dif_pos hs]
exact ⟨(hV s).1.1.preimage (F.map _).hom.hom.continuous,
(hV s).1.2.preimage (F.map _).hom.hom.continuous⟩ | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Topology.Category.Profinite.CofilteredLimit | {
"line": 131,
"column": 2
} | {
"line": 131,
"column": 41
} | [
{
"pp": "case intro\nJ : Type v\ninst✝² : SmallCategory J\ninst✝¹ : IsCofiltered J\nF : J ⥤ Profinite\nC : Cone F\nα : Type u_1\ninst✝ : Finite α\nhC : IsLimit C\nf : LocallyConstant (↑C.pt.toTop) α\nval✝ : Fintype α\nι : α → α → Fin 2 := fun x y ↦ if x = y then 0 else 1\nff : α → LocallyConstant (↑C.pt.toTop) ... | let G : Finset J := Finset.univ.image j | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_tacticLet___1 | Lean.Parser.Tactic.tacticLet__ |
Mathlib.Topology.Category.LightProfinite.Basic | {
"line": 338,
"column": 31
} | {
"line": 338,
"column": 42
} | [
{
"pp": "x✝ : LightProfinite\n⊢ lightProfiniteToLightDiagram.map ((Iso.refl (𝟭 LightProfinite)).hom.app x✝) ≫\n (NatIso.ofComponents\n (fun x ↦\n lightDiagramToProfinite.preimageIso\n (Iso.refl\n (lightDiagramToProfinite.obj\n ... | simpa using | Lean.Elab.Tactic.Simpa.evalSimpa | null |
Mathlib.Condensed.TopComparison | {
"line": 57,
"column": 2
} | {
"line": 57,
"column": 13
} | [
{
"pp": "C : Type u\ninst✝³ : Category.{v, u} C\nG : C ⥤ TopCat\nX : Type w'\ninst✝² : TopologicalSpace X\nZ B : C\nπ : Z ⟶ B\ninst✝¹ : HasPullback π π\ninst✝ : PreservesLimit (cospan π π) G\na : C(↑(G.obj Z), X)\nha : ⇑a ∘ ⇑(ConcreteCategory.hom (G.map (pullback.fst π π))) = ⇑a ∘ ⇑(ConcreteCategory.hom (G.map ... | simpa using | Lean.Elab.Tactic.Simpa.evalSimpa | null |
Mathlib.Topology.Category.LightProfinite.AsLimit | {
"line": 125,
"column": 2
} | {
"line": 125,
"column": 45
} | [
{
"pp": "S : LightProfinite\nn : ℕ\n⊢ Function.Surjective (⇑(ConcreteCategory.hom (S.transitionMap n)) ∘ ⇑(ConcreteCategory.hom (S.proj (n + 1))))",
"usedConstants": [
"Eq.mpr",
"Opposite",
"congrArg",
"CategoryTheory.ConcreteCategory.hom",
"SecondCountableTopology",
"Con... | simpa using | Lean.Elab.Tactic.Simpa.evalSimpa | null |
Mathlib.Topology.Category.LightProfinite.AsLimit | {
"line": 130,
"column": 2
} | {
"line": 130,
"column": 47
} | [
{
"pp": "S : LightProfinite\nn m : ℕ\nh : n ≤ m\n⊢ Function.Surjective (⇑(ConcreteCategory.hom (S.transitionMapLE h)) ∘ ⇑(ConcreteCategory.hom (S.proj m)))",
"usedConstants": [
"Eq.mpr",
"Opposite",
"LightProfinite.proj_comp_transitionMapLE'",
"congrArg",
"CategoryTheory.Concre... | simpa using | Lean.Elab.Tactic.Simpa.evalSimpa | null |
Mathlib.Condensed.Discrete.LocallyConstant | {
"line": 356,
"column": 9
} | {
"line": 356,
"column": 93
} | [
{
"pp": "case h.toFun.h.h\nP : TopCat → Prop\ninst✝⁴ : ∀ (S : CompHausLike P) (p : ↑S.toTop → Prop), HasProp P (Subtype p)\nS : CompHausLike P\nY : (CompHausLike P)ᵒᵖ ⥤ Type (max u w)\ninst✝³ : HasProp P PUnit.{u + 1}\nf : LocallyConstant (↑S.toTop) (Y.obj (op (of P PUnit.{u + 1})))\nT : CompHausLike P\ng : T ⟶... | ← map_eq_image _ a ⟨PUnit.unit, by simp [mem_iff_eq_image, ← map_preimage_eq_image]⟩ | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Condensed.Light.InternallyProjective | {
"line": 80,
"column": 2
} | {
"line": 80,
"column": 53
} | [
{
"pp": "case a.e_a.h.e_6.h.a\nR : Type u\ninst✝ : CommRing R\nA B P : LightCondMod R\nS : LightProfinite\ne : A ⟶ B\nx : ↑((P ⟹ A).obj.obj (Opposite.op S))\n⊢ (coherentTopology LightProfinite).yonedaEquiv\n ((coherentTopology LightProfinite).yonedaEquiv.symm\n ((ConcreteCategory.hom (((ihom P).map ... | simp [dsimp% GrothendieckTopology.yonedaEquiv_comp] | Lean.Elab.Tactic.evalSimp | Lean.Parser.Tactic.simp |
Mathlib.Condensed.Light.InternallyProjective | {
"line": 87,
"column": 2
} | {
"line": 87,
"column": 99
} | [
{
"pp": "R : Type u\ninst✝ : CommRing R\nB P : LightCondMod R\nS S' : LightProfinite\nπ : S ⟶ S'\nf : P ⊗ (free R).obj S'.toCondensed ⟶ B\n⊢ (ihomPoints R P B S).symm (P ◁ (free R).map (lightProfiniteToLightCondSet.map π) ≫ f) =\n (ConcreteCategory.hom ((P ⟹ B).obj.map π.op)) ((ihomPoints R P B S').symm f)",... | simpa using | Lean.Elab.Tactic.Simpa.evalSimpa | null |
Mathlib.Condensed.Light.InternallyProjective | {
"line": 86,
"column": 79
} | {
"line": 88,
"column": 60
} | [
{
"pp": "R : Type u\ninst✝ : CommRing R\nB P : LightCondMod R\nS S' : LightProfinite\nπ : S ⟶ S'\nf : P ⊗ (free R).obj S'.toCondensed ⟶ B\n⊢ (ihomPoints R P B S).symm (P ◁ (free R).map (lightProfiniteToLightCondSet.map π) ≫ f) =\n (ConcreteCategory.hom ((P ⟹ B).obj.map π.op)) ((ihomPoints R P B S').symm f)",... | by
simpa [ihomPoints_symm_apply, MonoidalClosed.curry_natural_left, Adjunction.homEquiv_apply] using
(GrothendieckTopology.yonedaEquiv_naturality _ _ _).symm | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Condensed.Discrete.Colimit | {
"line": 152,
"column": 16
} | {
"line": 152,
"column": 27
} | [
{
"pp": "S : Profinite\nF : Profiniteᵒᵖ ⥤ Type (u + 1)\nhF : (S : Profinite) → IsColimit (F.mapCocone S.asLimitCone.op)\nX✝ Y✝ : Profiniteᵒᵖ\nx✝ : X✝ ⟶ Y✝\n⊢ (lanPresheaf F).map x✝ ≫\n ((fun x ↦\n match x with\n | Opposite.op S => lanPresheafIso (hF S))\n Y✝).hom =\n ((fun... | simpa using | Lean.Elab.Tactic.Simpa.evalSimpa | null |
Mathlib.Condensed.Discrete.Colimit | {
"line": 308,
"column": 2
} | {
"line": 309,
"column": 74
} | [
{
"pp": "case w.h.w.e_a.h.toFun.h.h.a.h\nX : Profiniteᵒᵖ ⥤ Type (u + 1)\ninst✝ : PreservesFiniteProducts X\nhX : (S : Profinite) → IsColimit (X.mapCocone S.asLimitCone.op)\nS : Profiniteᵒᵖ\nY : FintypeCatᵒᵖ\nright✝ : Discrete PUnit.{1}\ng : toProfinite.op.obj Y ⟶ (fromPUnit S).obj right✝\nf :\n LocallyConstant... | simpa using | Lean.Elab.Tactic.Simpa.evalSimpa | null |
Mathlib.Topology.Category.LightProfinite.Injective | {
"line": 114,
"column": 4
} | {
"line": 114,
"column": 37
} | [
{
"pp": "case refine_2.h\nX : Type u_1\nY : Type u_2\nS : Type u_3\nT : Type u_4\ninst✝¹⁰ : TopologicalSpace X\ninst✝⁹ : CompactSpace X\ninst✝⁸ : TopologicalSpace Y\ninst✝⁷ : CompactSpace Y\ninst✝⁶ : T2Space Y\ninst✝⁵ : TotallyDisconnectedSpace Y\ninst✝⁴ : TopologicalSpace S\ninst✝³ : T2Space S\ninst✝² : Finite... | simpa using | Lean.Elab.Tactic.Simpa.evalSimpa | null |
Mathlib.Topology.Category.LightProfinite.Injective | {
"line": 116,
"column": 51
} | {
"line": 116,
"column": 74
} | [
{
"pp": "X : Type u_1\nY : Type u_2\nS : Type u_3\nT : Type u_4\ninst✝¹⁰ : TopologicalSpace X\ninst✝⁹ : CompactSpace X\ninst✝⁸ : TopologicalSpace Y\ninst✝⁷ : CompactSpace Y\ninst✝⁶ : T2Space Y\ninst✝⁵ : TotallyDisconnectedSpace Y\ninst✝⁴ : TopologicalSpace S\ninst✝³ : T2Space S\ninst✝² : Finite S\ninst✝¹ : Topo... | simpa using | Lean.Elab.Tactic.Simpa.evalSimpa | null |
Mathlib.Condensed.Discrete.Colimit | {
"line": 593,
"column": 2
} | {
"line": 594,
"column": 74
} | [
{
"pp": "case w.h.w.e_a.h.toFun.h.h.a.h\nX : LightProfiniteᵒᵖ ⥤ Type u\ninst✝ : PreservesFiniteProducts X\nhX : (S : LightProfinite) → IsColimit (X.mapCocone (coconeRightOpOfCone S.asLimitCone))\nS : LightProfiniteᵒᵖ\nY : FintypeCatᵒᵖ\nright✝ : Discrete PUnit.{1}\ng : toLightProfinite.op.obj Y ⟶ (fromPUnit S).o... | simpa using | Lean.Elab.Tactic.Simpa.evalSimpa | null |
Mathlib.Condensed.TopCatAdjunction | {
"line": 125,
"column": 6
} | {
"line": 129,
"column": 9
} | [
{
"pp": "X✝ X : CondensedSet\nx✝² x✝¹ : CompHausᵒᵖ\nx✝ : x✝² ⟶ x✝¹\n⊢ (X.obj.map x✝ ≫\n ↾fun x ↦\n { toFun := fun s ↦ (ConcreteCategory.hom (X.obj.map (CompHausLike.const (of PUnit.{u + 1}) s).op)) x,\n continuous_toFun := ⋯ }) =\n (↾fun x ↦\n { toFun := fun s ↦ (ConcreteCategory.... | ext
simp only [TopCat.toSheafCompHausLike_obj_obj, TypeCat.Fun.toFun_apply,
comp_apply, TopCat.toSheafCompHausLike_obj_map, ConcreteCategory.hom_ofHom,
TypeCat.Fun.coe_mk, ← Functor.map_comp_apply]
rfl | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Condensed.TopCatAdjunction | {
"line": 125,
"column": 6
} | {
"line": 129,
"column": 9
} | [
{
"pp": "X✝ X : CondensedSet\nx✝² x✝¹ : CompHausᵒᵖ\nx✝ : x✝² ⟶ x✝¹\n⊢ (X.obj.map x✝ ≫\n ↾fun x ↦\n { toFun := fun s ↦ (ConcreteCategory.hom (X.obj.map (CompHausLike.const (of PUnit.{u + 1}) s).op)) x,\n continuous_toFun := ⋯ }) =\n (↾fun x ↦\n { toFun := fun s ↦ (ConcreteCategory.... | ext
simp only [TopCat.toSheafCompHausLike_obj_obj, TypeCat.Fun.toFun_apply,
comp_apply, TopCat.toSheafCompHausLike_obj_map, ConcreteCategory.hom_ofHom,
TypeCat.Fun.coe_mk, ← Functor.map_comp_apply]
rfl | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Control.Functor.Multivariate | {
"line": 174,
"column": 4
} | {
"line": 174,
"column": 91
} | [
{
"pp": "case h₁\nn : ℕ\nF : TypeVec.{u} (n + 1) → Type u_1\ninst✝¹ : MvFunctor F\ninst✝ : LawfulMvFunctor F\nα : TypeVec.{u} n\nβ : Type u\nP : β → Prop\nx : F (α ::: β)\nu✝ : F fun i ↦ { p_1 // ofRepeat (α.PredLast' P i p_1) }\n⊢ (fun i ↦ Subtype.val) <$$> u✝ = x ↔ (fun i x ↦ ↑(f P n α i x)) <$$> u✝ = x",
... | suffices (fun i => Subtype.val) = (fun i x => (MvFunctor.f P n α i x).val) by rw [this] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_tacticSuffices__1 | Lean.Parser.Tactic.tacticSuffices_ |
Mathlib.Condensed.Light.Sequence | {
"line": 68,
"column": 15
} | {
"line": 68,
"column": 32
} | [
{
"pp": "S : Type u_1\nT : Type u_2\nX : Type u_3\nπ : T → S × Option X\nσ : Option X → S → T\nhσ' : ∀ (x : Option X) (s : S), (π (σ x s)).2 = x\nx : T\nx✝ : ∃ i, (∀ (x_1 : S), ¬σ (Option.some i) x_1 = x) ∧ (π x).2 = ↑i\nn : X\nhn : ∀ (x_1 : S), ¬σ (Option.some n) x_1 = x\nhn' : (π x).2 = ↑n\n⊢ ¬(π x).2 = none"... | simpa using | Lean.Elab.Tactic.Simpa.evalSimpa | null |
Mathlib.Condensed.Light.Sequence | {
"line": 81,
"column": 4
} | {
"line": 81,
"column": 15
} | [
{
"pp": "case refine_1\nS : Type u_1\nT : Type u_2\nX : Type u_3\ninst✝⁵ : TopologicalSpace S\ninst✝⁴ : TopologicalSpace T\ninst✝³ : TopologicalSpace X\ninst✝² : DiscreteTopology X\ninst✝¹ : T2Space T\ninst✝ : CompactSpace S\nπ : T → S × OnePoint X\nhπ : Continuous π\nσ : Option X → S → T\nhσ : ∀ (x : Option X)... | simpa using | Lean.Elab.Tactic.Simpa.evalSimpa | null |
Mathlib.Control.LawfulFix | {
"line": 132,
"column": 4
} | {
"line": 135,
"column": 25
} | [
{
"pp": "case a\nα : Type u_1\nβ : α → Type u_2\nf : ((a : α) → Part (β a)) →o (a : α) → Part (β a)\n⊢ ωSup (approxChain f) ≤ Part.fix ⇑f",
"usedConstants": [
"Part",
"Pi.preorder",
"instOmegaCompletePartialOrderForall",
"Part.Fix.approx_le_fix",
"PartialOrder.toPreorder",
... | apply ωSup_le _ _ _
simp only [Fix.approxChain]
intro y x
apply approx_le_fix f | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Control.LawfulFix | {
"line": 132,
"column": 4
} | {
"line": 135,
"column": 25
} | [
{
"pp": "case a\nα : Type u_1\nβ : α → Type u_2\nf : ((a : α) → Part (β a)) →o (a : α) → Part (β a)\n⊢ ωSup (approxChain f) ≤ Part.fix ⇑f",
"usedConstants": [
"Part",
"Pi.preorder",
"instOmegaCompletePartialOrderForall",
"Part.Fix.approx_le_fix",
"PartialOrder.toPreorder",
... | apply ωSup_le _ _ _
simp only [Fix.approxChain]
intro y x
apply approx_le_fix f | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Control.LawfulFix | {
"line": 188,
"column": 4
} | {
"line": 188,
"column": 80
} | [
{
"pp": "α : Type u_1\nβ : α → Type u_2\nf : Part α → Part α\nhc : ωScottContinuous f\n⊢ Part.fix ⇑(toUnitMono { toFun := f, monotone' := ⋯ }) () = f (Fix.fix f)",
"usedConstants": [
"Part",
"Eq.mpr",
"Unit.unit",
"Pi.preorder",
"congrArg",
"Fix.fix",
"PartialOrder.... | rw [Part.fix_eq_of_ωScottContinuous (ωScottContinuous_toUnitMono f hc)]; rfl | 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.