fullname
stringlengths 16
82
| header
stringlengths 77
703
| imported_modules
stringlengths 74
502
| opened_namespaces
stringlengths 1
365
| formal_statement
stringlengths 49
704
| formal_statement_original
stringlengths 60
704
| formal_statement_references
stringlengths 0
729
| formal_proof
stringclasses 7
values | formal_proof_references
stringclasses 7
values | doc_string
stringclasses 3
values | problem_id
stringclasses 1
value | problem_kind
stringclasses 2
values | informal_statement
stringclasses 1
value | informal_proof
stringclasses 1
value | ref
stringclasses 7
values | inv_references
stringclasses 1
value | passed
bool 2
classes | module_name
stringlengths 29
81
| head
null | lean_toolchain
stringclasses 1
value | package_name
stringclasses 1
value | validation_detail
stringlengths 0
6.03k
|
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
CliffordAlgebraComplex.ofComplex_I_tac_5919 | import Init
import Mathlib.Algebra.DualNumber
import Mathlib.Algebra.QuaternionBasis
import Mathlib.Data.Complex.Module
import Mathlib.LinearAlgebra.CliffordAlgebra.Conjugation
import Mathlib.LinearAlgebra.CliffordAlgebra.Star
import Mathlib.LinearAlgebra.QuadraticForm.Prod
import Mathlib.LinearAlgebra.CliffordAlgebra.Equivs
open CliffordAlgebra
open scoped ComplexConjugate
open scoped ComplexConjugate
| import Init
import Mathlib.Algebra.DualNumber
import Mathlib.Algebra.QuaternionBasis
import Mathlib.Data.Complex.Module
import Mathlib.LinearAlgebra.CliffordAlgebra.Conjugation
import Mathlib.LinearAlgebra.CliffordAlgebra.Star
import Mathlib.LinearAlgebra.QuadraticForm.Prod
import Mathlib.LinearAlgebra.CliffordAlgebra.Equivs
| open CliffordAlgebra
open scoped ComplexConjugate
open scoped ComplexConjugate
| lemma ofComplex_I_tac_5919 : ↑⟨(ι Q) 1, ofComplex.proof_1⟩ * ↑⟨(ι Q) 1, ofComplex.proof_1⟩ = -1 := sorry | lemma ofComplex_I_tac_5919 : ↑⟨(ι Q) 1, ofComplex.proof_1⟩ * ↑⟨(ι Q) 1, ofComplex.proof_1⟩ = -1 := sorry | tactic | false | ['Mathlib', 'LinearAlgebra', 'CliffordAlgebra', 'Equivs'] | null | leanprover/lean4:v4.11.0
| Mathlib | {"sorries":
[{"proofState": 0,
"pos": {"line": 13, "column": 100},
"goal": "⊢ sorryAx ℤ true * sorryAx ℤ true = -1",
"endPos": {"line": 13, "column": 105}}],
"messages":
[{"severity": "error",
"pos": {"line": 13, "column": 31},
"endPos": {"line": 13, "column": 59},
"data":
"invalid constructor ⟨...⟩, expected type must be an inductive type with only one constructor \n ℤ"},
{"severity": "error",
"pos": {"line": 13, "column": 63},
"endPos": {"line": 13, "column": 91},
"data":
"invalid constructor ⟨...⟩, expected type must be an inductive type with only one constructor \n ℤ"}],
"env": 0}
|
|||||||||
MeasureTheory.addContent_union'_tac_3811 | import Init
import Mathlib.Data.ENNReal.Basic
import Mathlib.MeasureTheory.SetSemiring
import Mathlib.MeasureTheory.Measure.AddContent
open Set Finset
open scoped ENNReal
| import Init
import Mathlib.Data.ENNReal.Basic
import Mathlib.MeasureTheory.SetSemiring
import Mathlib.MeasureTheory.Measure.AddContent
| open Set Finset
open scoped ENNReal
| lemma addContent_union'_tac_3811 (C : Set (Set α)) (s : Set α) (t : Set α) (m : AddContent C) (hs : s ∈ C) (ht : t ∈ C) (hst : s ∪ t ∈ C) (h_dis : Disjoint s s) (hs_empty : ¬s = ∅) (h : m (⋃₀ ↑{s, t}) = ∑ u ∈ {s, t}, m u) (hs_eq_t : s = t) : s = ∅ := sorry | lemma addContent_union'_tac_3811 {α : Type*} (C : Set (Set α)) (s : Set α) (t : Set α) (m : AddContent C) (hs : s ∈ C) (ht : t ∈ C) (hst : s ∪ t ∈ C) (h_dis : Disjoint s s) (hs_empty : ¬s = ∅) (h : m (⋃₀ ↑{s, t}) = ∑ u ∈ {s, t}, m u) (hs_eq_t : s = t) : s = ∅ := sorry | tactic | null | ['Mathlib', 'MeasureTheory', 'Measure', 'AddContent'] | null | leanprover/lean4:v4.11.0
| Mathlib | ||||||||||
nhdsSet_empty_tac_4941 | import Init
import Mathlib.Topology.Basic
import Mathlib.Topology.NhdsSet
open Set Filter Topology
| import Init
import Mathlib.Topology.Basic
import Mathlib.Topology.NhdsSet
| open Set Filter Topology
| lemma nhdsSet_empty_tac_4941 [TopologicalSpace X] : ⊥ = ⊥ := sorry | lemma nhdsSet_empty_tac_4941 {X : Type*} [TopologicalSpace X] : ⊥ = ⊥ := sorry | tactic | false | ['Mathlib', 'Topology', 'NhdsSet'] | null | leanprover/lean4:v4.11.0
| Mathlib | {"messages":
[{"severity": "error",
"pos": {"line": 6, "column": 56},
"endPos": {"line": 6, "column": 57},
"data":
"typeclass instance problem is stuck, it is often due to metavariables\n Bot ?m.139"}],
"env": 0}
|
|||||||||
CategoryTheory.Subgroupoid.map_objs_eq_tac_19472 | import Init
import Mathlib.Algebra.Group.Subgroup.Basic
import Mathlib.CategoryTheory.Groupoid.VertexGroup
import Mathlib.CategoryTheory.Groupoid.Basic
import Mathlib.CategoryTheory.Groupoid
import Mathlib.Data.Set.Lattice
import Mathlib.Order.GaloisConnection
import Mathlib.CategoryTheory.Groupoid.Subgroupoid
open Set Groupoid
| import Init
import Mathlib.Algebra.Group.Subgroup.Basic
import Mathlib.CategoryTheory.Groupoid.VertexGroup
import Mathlib.CategoryTheory.Groupoid.Basic
import Mathlib.CategoryTheory.Groupoid
import Mathlib.Data.Set.Lattice
import Mathlib.Order.GaloisConnection
import Mathlib.CategoryTheory.Groupoid.Subgroupoid
| open Set Groupoid
| lemma map_objs_eq_tac_19472 [Groupoid C] (S : Subgroupoid C) [Groupoid D] (φ : C ⥤ D) (hφ : Function.Injective φ.obj) (x : D) : x ∈ (map φ hφ S).objs ↔ x ∈ φ.obj '' S.objs := sorry | lemma map_objs_eq_tac_19472 {C : Type*} [Groupoid C] (S : Subgroupoid C) {D : Type*} [Groupoid D] (φ : C ⥤ D) (hφ : Function.Injective φ.obj) (x : D) : x ∈ (map φ hφ S).objs ↔ x ∈ φ.obj '' S.objs := sorry | [['x'], ['mem_map_objs_iff'], ['φ'], ['hφ'], ['S']] | tactic | false | ['Mathlib', 'CategoryTheory', 'Groupoid', 'Subgroupoid'] | null | leanprover/lean4:v4.11.0
| Mathlib | {"messages":
[{"severity": "error",
"pos": {"line": 9, "column": 9},
"endPos": {"line": 9, "column": 17},
"data": "unknown namespace 'Groupoid'"},
{"severity": "error",
"pos": {"line": 11, "column": 81},
"endPos": null,
"data": "expected token"}],
"env": 0}
|
||||||||
Sym2.filter_image_mk_not_isDiag_tac_23472 | import Init
import Mathlib.Data.Finset.Prod
import Mathlib.Data.Sym.Basic
import Mathlib.Data.Sym.Sym2.Init
import Mathlib.Data.SetLike.Basic
import Mathlib.Data.Sym.Sym2
open Mathlib (Vector)
open Finset Function Sym
| import Init
import Mathlib.Data.Finset.Prod
import Mathlib.Data.Sym.Basic
import Mathlib.Data.Sym.Sym2.Init
import Mathlib.Data.SetLike.Basic
import Mathlib.Data.Sym.Sym2
| open Mathlib (Vector)
open Finset Function Sym
| lemma filter_image_mk_not_isDiag_tac_23472 [DecidableEq α] (s : Finset α) (a : α) (b : α) (hab : ¬a = b) (h : s(a, b) = s(x✝, y✝)) (ha : a ∈ s) (hb : b ∈ s) : ∃ a b, (a ∈ s ∧ b ∈ s ∧ a ≠ b) ∧ s(a, b) = s(x✝, y✝) := sorry | lemma filter_image_mk_not_isDiag_tac_23472 {α : Type*} [DecidableEq α] (s : Finset α) (x✝ : α) (y✝ : α) (a : α) (b : α) (hab : ¬a = b) (h : s(a, b) = s(x✝, y✝)) (ha : a ∈ s) (hb : b ∈ s) : ∃ a b, (a ∈ s ∧ b ∈ s ∧ a ≠ b) ∧ s(a, b) = s(x✝, y✝) := sorry | tactic | false | ['Mathlib', 'Data', 'Sym', 'Sym2'] | null | leanprover/lean4:v4.11.0
| Mathlib | {"messages":
[{"severity": "error",
"pos": {"line": 10, "column": 123},
"endPos": null,
"data": "expected token"}],
"env": 0}
|
|||||||||
_private.0.soln_unique_tac_19461 | import Init
import Mathlib.Algebra.Polynomial.Identities
import Mathlib.Analysis.SpecificLimits.Basic
import Mathlib.NumberTheory.Padics.PadicIntegers
import Mathlib.Topology.Algebra.Polynomial
import Mathlib.Topology.MetricSpace.CauSeqFilter
import Mathlib.NumberTheory.Padics.Hensel
open Topology
open Filter Metric
open Nat
| import Init
import Mathlib.Algebra.Polynomial.Identities
import Mathlib.Analysis.SpecificLimits.Basic
import Mathlib.NumberTheory.Padics.PadicIntegers
import Mathlib.Topology.Algebra.Polynomial
import Mathlib.Topology.MetricSpace.CauSeqFilter
import Mathlib.NumberTheory.Padics.Hensel
| open Topology
open Filter Metric
open Nat
| lemma soln_unique_tac_19461 (p : ℕ) [Fact (Nat.Prime p)] (F : Polynomial ℤ_[p]) (a : ℤ_[p]) (hnorm : ‖Polynomial.eval a F‖ < ‖Polynomial.eval a (Polynomial.derivative F)‖ ^ 2) (hnsol : Polynomial.eval a F ≠ 0) (z : ℤ_[p]) (hev : Polynomial.eval z F = 0) (hnlt : ‖z - a‖ < ‖Polynomial.eval a (Polynomial.derivative F)‖) (soln_dist : ‖z - soln‖ < ‖Polynomial.eval a (Polynomial.derivative F)‖) (h : ℤ_[p]) (q : ℤ_[p]) (hq : Polynomial.eval (soln + h) F = Polynomial.eval soln F + Polynomial.eval soln (Polynomial.derivative F) * h + q * h ^ 2) : Polynomial.eval (soln + h) F = Polynomial.eval soln (Polynomial.derivative F) * h + q * h ^ 2 := sorry | lemma soln_unique_tac_19461 (p : ℕ) [Fact (Nat.Prime p)] (F : Polynomial ℤ_[p]) (a : ℤ_[p]) (hnorm : ‖Polynomial.eval a F‖ < ‖Polynomial.eval a (Polynomial.derivative F)‖ ^ 2) (hnsol : Polynomial.eval a F ≠ 0) (z : ℤ_[p]) (hev : Polynomial.eval z F = 0) (hnlt : ‖z - a‖ < ‖Polynomial.eval a (Polynomial.derivative F)‖) (soln_dist : ‖z - soln‖ < ‖Polynomial.eval a (Polynomial.derivative F)‖) (h : ℤ_[p]) (q : ℤ_[p]) (hq : Polynomial.eval (soln + h) F = Polynomial.eval soln F + Polynomial.eval soln (Polynomial.derivative F) * h + q * h ^ 2) : Polynomial.eval (soln + h) F = Polynomial.eval soln (Polynomial.derivative F) * h + q * h ^ 2 := sorry | [['zero_add'], ['eval_soln'], ['hq']] | tactic | false | ['Mathlib', 'NumberTheory', 'Padics', 'Hensel'] | null | leanprover/lean4:v4.11.0
| Mathlib | {"messages":
[{"severity": "error",
"pos": {"line": 12, "column": 575},
"endPos": {"line": 12, "column": 621},
"data":
"type mismatch\n Polynomial.eval soln (Polynomial.derivative ?m.4450)\nhas type\n ?m.4434 : Type ?u.4141\nbut is expected to have type\n ℤ_[p] : Type"}],
"env": 0}
|
||||||||
IsCompact.uniform_oscillationWithin_tac_5084 | import Init
import Mathlib.Topology.EMetricSpace.Diam
import Mathlib.Order.WellFoundedSet
import Mathlib.Analysis.Oscillation
open Topology EMetric Set ENNReal
| import Init
import Mathlib.Topology.EMetricSpace.Diam
import Mathlib.Order.WellFoundedSet
import Mathlib.Analysis.Oscillation
| open Topology EMetric Set ENNReal
| lemma uniform_oscillationWithin_tac_5084 [PseudoEMetricSpace F] [PseudoEMetricSpace E] (K : Set E) (f : E → F) (D : Set E) (ε : ℝ≥0∞) (comp : IsCompact K) (hK : ∀ x ∈ K, oscillationWithin f D x < ε) (S : ℝ → Set E) (S_open : ∀ r > 0, IsOpen (S r)) (x : E) (hx : x ∈ K) : x ∈ ⋃ r, ⋃ (_ : r > 0), S r := sorry | lemma uniform_oscillationWithin_tac_5084 {E : Type*} {F : Type*} [PseudoEMetricSpace F] [PseudoEMetricSpace E] (K : Set E) (f : E → F) (D : Set E) (ε : ℝ≥0∞) (comp : IsCompact K) (hK : ∀ x ∈ K, oscillationWithin f D x < ε) (S : ℝ → Set E) (S_open : ∀ r > 0, IsOpen (S r)) (x : E) (hx : x ∈ K) : x ∈ ⋃ r, ⋃ (_ : r > 0), S r := sorry | [['ε'], ['x'], ['hx'], ['hK'], [], ['f'], ['D'], ['oscillationWithin']] | tactic | true | ['Mathlib', 'Analysis', 'Oscillation'] | null | leanprover/lean4:v4.11.0
| Mathlib | {"sorries":
[{"proofState": 0,
"pos": {"line": 7, "column": 302},
"goal":
"F : Type u_1\nE : Type u_2\ninst✝¹ : PseudoEMetricSpace F\ninst✝ : PseudoEMetricSpace E\nK : Set E\nf : E → F\nD : Set E\nε : ℝ≥0∞\ncomp : IsCompact K\nhK : ∀ x ∈ K, oscillationWithin f D x < ε\nS : ℝ → Set E\nS_open : ∀ r > 0, IsOpen (S r)\nx : E\nhx : x ∈ K\n⊢ x ∈ ⋃ r, ⋃ (_ : r > 0), S r",
"endPos": {"line": 7, "column": 307}}],
"messages":
[{"severity": "warning",
"pos": {"line": 7, "column": 6},
"endPos": {"line": 7, "column": 40},
"data": "declaration uses 'sorry'"}],
"env": 0}
|
||||||||
List.sum_map_count_dedup_filter_eq_countP_tac_23259 | import Init
import Mathlib.Algebra.Divisibility.Basic
import Mathlib.Algebra.Group.Int
import Mathlib.Algebra.Group.Nat
import Mathlib.Algebra.Group.Opposite
import Mathlib.Algebra.Group.Units
import Mathlib.Data.List.Perm
import Mathlib.Data.List.ProdSigma
import Mathlib.Data.List.Range
import Mathlib.Data.List.Rotate
import Mathlib.Algebra.BigOperators.Group.List
| import Init
import Mathlib.Algebra.Divisibility.Basic
import Mathlib.Algebra.Group.Int
import Mathlib.Algebra.Group.Nat
import Mathlib.Algebra.Group.Opposite
import Mathlib.Algebra.Group.Units
import Mathlib.Data.List.Perm
import Mathlib.Data.List.ProdSigma
import Mathlib.Data.List.Range
import Mathlib.Data.List.Rotate
import Mathlib.Algebra.BigOperators.Group.List
| lemma sum_map_count_dedup_filter_eq_countP_tac_23259 [DecidableEq α] (p : α → Bool) (a : α) (as : List α) (h : (map (fun x => count x as) (filter p as.dedup)).sum = countP p as) (ha : a ∉ as) : (map (fun i => count i as)
(match true with
| true => a :: filter p as.dedup
| false => filter p as.dedup)).sum =
(map (fun i => count i as) (filter p as.dedup)).sum := sorry | lemma sum_map_count_dedup_filter_eq_countP_tac_23259 {α : Type*} [DecidableEq α] (p : α → Bool) (a : α) (as : List α) (h : (map (fun x => count x as) (filter p as.dedup)).sum = countP p as) (ha : a ∉ as) : (map (fun i => count i as)
(match true with
| true => a :: filter p as.dedup
| false => filter p as.dedup)).sum =
(map (fun i => count i as) (filter p as.dedup)).sum := sorry | [['zero_add'], ['List', 'map_cons'], ['List', 'sum_cons'], ['rhs', '_@', '_hyg', 7756], ['ha'], ['List', 'count_eq_zero']] | tactic | false | ['Mathlib', 'Algebra', 'BigOperators', 'Group', 'List'] | null | leanprover/lean4:v4.11.0
| Mathlib | {"sorries":
[{"proofState": 0,
"pos": {"line": 18, "column": 57},
"goal":
"α : Type u_1\nx✝¹ : Sort u_2\nmap : x✝¹\nx✝ : Sort u_3\ncountP : x✝\ninst✝ : DecidableEq α\np : α → Bool\na : α\nas : List α\nh : sorryAx (?m.347 p a as) true = sorryAx (?m.347 p a as) true\nha : a ∉ as\n⊢ sorryAx (?m.348 p a as h ha) true = sorryAx (?m.348 p a as h ha) true",
"endPos": {"line": 18, "column": 62}}],
"messages":
[{"severity": "error",
"pos": {"line": 14, "column": 112},
"endPos": {"line": 14, "column": 157},
"data": "function expected at\n map\nterm has type\n ?m.27"},
{"severity": "error",
"pos": {"line": 14, "column": 165},
"endPos": {"line": 14, "column": 176},
"data": "function expected at\n countP\nterm has type\n ?m.59"},
{"severity": "error",
"pos": {"line": 14, "column": 195},
"endPos": {"line": 17, "column": 35},
"data": "function expected at\n map\nterm has type\n ?m.27"},
{"severity": "error",
"pos": {"line": 18, "column": 3},
"endPos": {"line": 18, "column": 48},
"data": "function expected at\n map\nterm has type\n ?m.27"}],
"env": 0}
|
|||||||||
CategoryTheory.ShortComplex.quasiIso_iff_of_zeros_tac_31368 | import Init
import Mathlib.Algebra.Homology.ShortComplex.PreservesHomology
import Mathlib.Algebra.Homology.ShortComplex.Abelian
import Mathlib.Algebra.Homology.ShortComplex.QuasiIso
import Mathlib.CategoryTheory.Abelian.Opposite
import Mathlib.CategoryTheory.Preadditive.AdditiveFunctor
import Mathlib.CategoryTheory.Preadditive.Injective
import Mathlib.Algebra.Homology.ShortComplex.Exact
open Category Limits ZeroObject Preadditive
| import Init
import Mathlib.Algebra.Homology.ShortComplex.PreservesHomology
import Mathlib.Algebra.Homology.ShortComplex.Abelian
import Mathlib.Algebra.Homology.ShortComplex.QuasiIso
import Mathlib.CategoryTheory.Abelian.Opposite
import Mathlib.CategoryTheory.Preadditive.AdditiveFunctor
import Mathlib.CategoryTheory.Preadditive.Injective
import Mathlib.Algebra.Homology.ShortComplex.Exact
| open Category Limits ZeroObject Preadditive
| lemma quasiIso_iff_of_zeros_tac_31368 [Category.{u_3, u_1} C] [Abelian C] (S₁ : ShortComplex C) (S₂ : ShortComplex C) (φ : S₁ ⟶ S₂) (hf₁ : S₁.f = 0) (hg₁ : S₁.g = 0) (hf₂ : S₂.f = 0) (w : φ.τ₂ ≫ S₂.g = 0) (h₁ : (mk φ.τ₂ S₂.g ⋯).Exact) (h₂ : Mono φ.τ₂) : S₂.iCycles = S₂.iCycles := sorry | lemma quasiIso_iff_of_zeros_tac_31368 {C : Type*} [Category.{u_3, u_1} C] [Abelian C] (S₁ : ShortComplex C) (S₂ : ShortComplex C) (φ : S₁ ⟶ S₂) (hf₁ : S₁.f = 0) (hg₁ : S₁.g = 0) (hf₂ : S₂.f = 0) (w : φ.τ₂ ≫ S₂.g = 0) (h₁ : (mk φ.τ₂ S₂.g ⋯).Exact) (h₂ : Mono φ.τ₂) : S₂.iCycles = S₂.iCycles := sorry | tactic | false | ['Mathlib', 'Algebra', 'Homology', 'ShortComplex', 'Exact'] | null | leanprover/lean4:v4.11.0
| Mathlib | {"messages":
[{"severity": "error",
"pos": {"line": 9, "column": 5},
"endPos": {"line": 9, "column": 13},
"data": "unknown namespace 'Category'"},
{"severity": "error",
"pos": {"line": 11, "column": 193},
"endPos": null,
"data": "expected token"}],
"env": 0}
|
|||||||||
Localization.mk_left_injective_tac_67784 | import Init
import Mathlib.Algebra.Group.Submonoid.Membership
import Mathlib.GroupTheory.Congruence.Basic
import Mathlib.RingTheory.OreLocalization.Basic
import Mathlib.GroupTheory.MonoidLocalization.Basic
open Function
| import Init
import Mathlib.Algebra.Group.Submonoid.Membership
import Mathlib.GroupTheory.Congruence.Basic
import Mathlib.RingTheory.OreLocalization.Basic
import Mathlib.GroupTheory.MonoidLocalization.Basic
| open Function
| lemma mk_left_injective_tac_67784 [CancelCommMonoid α] (s : Submonoid α) (b : ↥s) (c : α) (d : α) (h : (fun a => mk a b) c = (fun a => mk a b) d) : c = d := sorry | lemma mk_left_injective_tac_67784 {α : Type*} [CancelCommMonoid α] (s : Submonoid α) (b : ↥s) (c : α) (d : α) (h : (fun a => mk a b) c = (fun a => mk a b) d) : c = d := sorry | [['h'], ['mk_eq_mk_iff'], ["mk_eq_monoidOf_mk'"], ['r_iff_exists']] | tactic | false | ['Mathlib', 'GroupTheory', 'MonoidLocalization', 'Basic'] | null | leanprover/lean4:v4.11.0
| Mathlib | {"sorries":
[{"proofState": 0,
"pos": {"line": 8, "column": 157},
"goal":
"α : Type u_1\nx✝ : Sort u_2\nmk : x✝\ninst✝ : CancelCommMonoid α\ns : Submonoid α\nb : ↥s\nc d : α\nh : (fun a => ?m.600 s b c d a) c = (fun a => ?m.601 s b c d a) d\n⊢ c = d",
"endPos": {"line": 8, "column": 162}}],
"messages":
[{"severity": "error",
"pos": {"line": 8, "column": 113},
"endPos": {"line": 8, "column": 119},
"data": "function expected at\n mk\nterm has type\n ?m.233"},
{"severity": "error",
"pos": {"line": 8, "column": 135},
"endPos": {"line": 8, "column": 141},
"data": "function expected at\n mk\nterm has type\n ?m.233"}],
"env": 0}
|
||||||||
lp.norm_neg_tac_17360 | import Init
import Mathlib.Analysis.MeanInequalities
import Mathlib.Analysis.MeanInequalitiesPow
import Mathlib.Analysis.SpecialFunctions.Pow.Continuity
import Mathlib.Data.Set.Image
import Mathlib.Topology.Algebra.Order.LiminfLimsup
import Mathlib.Analysis.Normed.Lp.lpSpace
open scoped NNReal ENNReal Function
| import Init
import Mathlib.Analysis.MeanInequalities
import Mathlib.Analysis.MeanInequalitiesPow
import Mathlib.Analysis.SpecialFunctions.Pow.Continuity
import Mathlib.Data.Set.Image
import Mathlib.Topology.Algebra.Order.LiminfLimsup
import Mathlib.Analysis.Normed.Lp.lpSpace
| open scoped NNReal ENNReal Function
| lemma norm_neg_tac_17360 (p : ℝ≥0∞) [(i : α) → NormedAddCommGroup (E i)] (f : ↥(lp E p)) (hp : 0 < p.toReal) : ‖-f‖ = ‖f‖ := sorry | lemma norm_neg_tac_17360 {α : Type*} {E : Type*} (p : ℝ≥0∞) [(i : α) → NormedAddCommGroup (E i)] (f : ↥(lp E p)) (hp : 0 < p.toReal) : ‖-f‖ = ‖f‖ := sorry | [['Real', 'rpow_left_injOn'], ["norm_nonneg'"], ['hp', "ne'"], ['this'], ['p', 'toReal'], [], ['f']] | tactic | true | ['Mathlib', 'Analysis', 'Normed', 'Lp', 'lpSpace'] | null | leanprover/lean4:v4.11.0
| Mathlib | {"sorries":
[{"proofState": 0,
"pos": {"line": 10, "column": 125},
"goal":
"α : Type u_1\nE : α → Type u_2\np : ℝ≥0∞\ninst✝ : (i : α) → NormedAddCommGroup (E i)\nf : ↥(lp E p)\nhp : 0 < p.toReal\n⊢ ‖-f‖ = ‖f‖",
"endPos": {"line": 10, "column": 130}}],
"messages":
[{"severity": "warning",
"pos": {"line": 10, "column": 6},
"endPos": {"line": 10, "column": 24},
"data": "declaration uses 'sorry'"}],
"env": 0}
|
||||||||
LinearMap.BilinForm.toLin_restrict_range_dualCoannihilator_eq_orthogonal_tac_10941 | import Init
import Mathlib.Algebra.GroupWithZero.NonZeroDivisors
import Mathlib.LinearAlgebra.BilinearForm.Properties
import Mathlib.LinearAlgebra.BilinearForm.Orthogonal
open LinearMap (BilinForm)
| import Init
import Mathlib.Algebra.GroupWithZero.NonZeroDivisors
import Mathlib.LinearAlgebra.BilinearForm.Properties
import Mathlib.LinearAlgebra.BilinearForm.Orthogonal
| open LinearMap (BilinForm)
| lemma toLin_restrict_range_dualCoannihilator_eq_orthogonal_tac_10941 [Field K] [AddCommGroup V] [Module K V] (B : BilinForm K V) (W : Subspace K V) (x : V) : (∀ n ∈ W, B.IsOrtho n x) → x ∈ (range (domRestrict B W)).dualCoannihilator := sorry | lemma toLin_restrict_range_dualCoannihilator_eq_orthogonal_tac_10941 {V : Type*} {K : Type*} [Field K] [AddCommGroup V] [Module K V] (B : BilinForm K V) (W : Subspace K V) (x : V) : (∀ n ∈ W, B.IsOrtho n x) → x ∈ (range (domRestrict B W)).dualCoannihilator := sorry | tactic | false | ['Mathlib', 'LinearAlgebra', 'BilinearForm', 'Orthogonal'] | null | leanprover/lean4:v4.11.0
| Mathlib | {"sorries":
[{"proofState": 0,
"pos": {"line": 7, "column": 236},
"goal":
"K : Type u_1\nV : Type u_2\nx✝ : Sort u_3\nrange : x✝\ninst✝² : Field K\ninst✝¹ : AddCommGroup V\ninst✝ : Module K V\nB : BilinForm K V\nW : Subspace K V\nx : V\n⊢ (∀ n ∈ W, B.IsOrtho n x) → x ∈ sorryAx (?m.2742 B W x) true",
"endPos": {"line": 7, "column": 241}}],
"messages":
[{"severity": "error",
"pos": {"line": 7, "column": 190},
"endPos": {"line": 7, "column": 213},
"data": "function expected at\n range\nterm has type\n ?m.1175"}],
"env": 0}
|
|||||||||
DifferentiableWithinAt.hasGradientWithinAt_tac_5286 | import Init
import Mathlib.Analysis.InnerProductSpace.Dual
import Mathlib.Analysis.Calculus.FDeriv.Basic
import Mathlib.Analysis.Calculus.Deriv.Basic
import Mathlib.Analysis.Calculus.Gradient.Basic
open Topology InnerProductSpace Set
open scoped Gradient
| import Init
import Mathlib.Analysis.InnerProductSpace.Dual
import Mathlib.Analysis.Calculus.FDeriv.Basic
import Mathlib.Analysis.Calculus.Deriv.Basic
import Mathlib.Analysis.Calculus.Gradient.Basic
| open Topology InnerProductSpace Set
open scoped Gradient
| lemma hasGradientWithinAt_tac_5286 [RCLike 𝕜] [NormedAddCommGroup F] [InnerProductSpace 𝕜 F] [CompleteSpace F] (f : F → 𝕜) (x : F) (s : Set F) (h : DifferentiableWithinAt 𝕜 f s x) : HasFDerivWithinAt f (fderivWithin 𝕜 f s x) s x := sorry | lemma hasGradientWithinAt_tac_5286 {𝕜 : Type*} {F : Type*} [RCLike 𝕜] [NormedAddCommGroup F] [InnerProductSpace 𝕜 F] [CompleteSpace F] (f : F → 𝕜) (x : F) (s : Set F) (h : DifferentiableWithinAt 𝕜 f s x) : HasFDerivWithinAt f (fderivWithin 𝕜 f s x) s x := sorry | tactic | true | ['Mathlib', 'Analysis', 'Calculus', 'Gradient', 'Basic'] | null | leanprover/lean4:v4.11.0
| Mathlib | {"sorries":
[{"proofState": 0,
"pos": {"line": 9, "column": 232},
"goal":
"𝕜 : Type u_1\nF : Type u_2\ninst✝³ : RCLike 𝕜\ninst✝² : NormedAddCommGroup F\ninst✝¹ : InnerProductSpace 𝕜 F\ninst✝ : CompleteSpace F\nf : F → 𝕜\nx : F\ns : Set F\nh : DifferentiableWithinAt 𝕜 f s x\n⊢ HasFDerivWithinAt f (fderivWithin 𝕜 f s x) s x",
"endPos": {"line": 9, "column": 237}}],
"messages":
[{"severity": "warning",
"pos": {"line": 9, "column": 6},
"endPos": {"line": 9, "column": 34},
"data": "declaration uses 'sorry'"}],
"env": 0}
|
|||||||||
HomotopyCategory.quotient_obj_mem_subcategoryAcyclic_iff_exactAt_tac_4225 | import Init
import Mathlib.Algebra.Homology.HomotopyCategory.HomologicalFunctor
import Mathlib.Algebra.Homology.HomotopyCategory.ShiftSequence
import Mathlib.Algebra.Homology.HomotopyCategory.SingleFunctors
import Mathlib.Algebra.Homology.HomotopyCategory.Triangulated
import Mathlib.Algebra.Homology.Localization
import Mathlib.Algebra.Homology.DerivedCategory.Basic
open CategoryTheory Limits Pretriangulated
| import Init
import Mathlib.Algebra.Homology.HomotopyCategory.HomologicalFunctor
import Mathlib.Algebra.Homology.HomotopyCategory.ShiftSequence
import Mathlib.Algebra.Homology.HomotopyCategory.SingleFunctors
import Mathlib.Algebra.Homology.HomotopyCategory.Triangulated
import Mathlib.Algebra.Homology.Localization
import Mathlib.Algebra.Homology.DerivedCategory.Basic
| open CategoryTheory Limits Pretriangulated
| lemma quotient_obj_mem_subcategoryAcyclic_iff_exactAt_tac_4225 [Category.{v, u} C] [Abelian C] (K : CochainComplex C ℤ) : (subcategoryAcyclic C).P ((quotient C (ComplexShape.up ℤ)).obj K) ↔ ∀ (n : ℤ), HomologicalComplex.ExactAt K n := sorry | lemma quotient_obj_mem_subcategoryAcyclic_iff_exactAt_tac_4225 {C : Type*} [Category.{v, u} C] [Abelian C] (K : CochainComplex C ℤ) : (subcategoryAcyclic C).P ((quotient C (ComplexShape.up ℤ)).obj K) ↔ ∀ (n : ℤ), HomologicalComplex.ExactAt K n := sorry | tactic | false | ['Mathlib', 'Algebra', 'Homology', 'DerivedCategory', 'Basic'] | null | leanprover/lean4:v4.11.0
| Mathlib | {"sorries":
[{"proofState": 0,
"pos": {"line": 10, "column": 235},
"goal":
"C : Type u\nx✝ : Sort u_1\nsubcategoryAcyclic : x✝\ninst✝¹ : Category.{v, u} C\ninst✝ : Abelian C\nK : CochainComplex C ℤ\n⊢ sorryAx Prop true ↔ ∀ (n : ℤ), HomologicalComplex.ExactAt K n",
"endPos": {"line": 10, "column": 240}}],
"messages":
[{"severity": "error",
"pos": {"line": 10, "column": 123},
"endPos": {"line": 10, "column": 143},
"data":
"function expected at\n subcategoryAcyclic\nterm has type\n ?m.128"}],
"env": 0}
|
|||||||||
MvPolynomial.totalDegree_zero_iff_isHomogeneous_tac_3920 | import Init
import Mathlib.Algebra.DirectSum.Internal
import Mathlib.Algebra.GradedMonoid
import Mathlib.Algebra.MvPolynomial.CommRing
import Mathlib.Algebra.MvPolynomial.Equiv
import Mathlib.Algebra.MvPolynomial.Variables
import Mathlib.RingTheory.MvPolynomial.WeightedHomogeneous
import Mathlib.Algebra.Polynomial.Roots
import Mathlib.RingTheory.MvPolynomial.Homogeneous
open Finsupp
| import Init
import Mathlib.Algebra.DirectSum.Internal
import Mathlib.Algebra.GradedMonoid
import Mathlib.Algebra.MvPolynomial.CommRing
import Mathlib.Algebra.MvPolynomial.Equiv
import Mathlib.Algebra.MvPolynomial.Variables
import Mathlib.RingTheory.MvPolynomial.WeightedHomogeneous
import Mathlib.Algebra.Polynomial.Roots
import Mathlib.RingTheory.MvPolynomial.Homogeneous
| open Finsupp
| lemma totalDegree_zero_iff_isHomogeneous_tac_3920 [CommSemiring R] (p : MvPolynomial σ R) : IsWeightedHomogeneous 1 p 0 ↔ IsWeightedHomogeneous 1 p 0 := sorry | lemma totalDegree_zero_iff_isHomogeneous_tac_3920 {σ : Type*} {R : Type*} [CommSemiring R] (p : MvPolynomial σ R) : IsWeightedHomogeneous 1 p 0 ↔ IsWeightedHomogeneous 1 p 0 := sorry | tactic | false | ['Mathlib', 'RingTheory', 'MvPolynomial', 'Homogeneous'] | null | leanprover/lean4:v4.11.0
| Mathlib | {"sorries":
[{"proofState": 0,
"pos": {"line": 12, "column": 153},
"goal":
"R : Type u_1\nσ : Type u_2\nx✝ : Sort u_3\nIsWeightedHomogeneous : x✝\ninst✝ : CommSemiring R\np : MvPolynomial σ R\n⊢ sorryAx Prop true ↔ sorryAx Prop true",
"endPos": {"line": 12, "column": 158}}],
"messages":
[{"severity": "error",
"pos": {"line": 12, "column": 92},
"endPos": {"line": 12, "column": 119},
"data":
"function expected at\n IsWeightedHomogeneous\nterm has type\n ?m.35"},
{"severity": "error",
"pos": {"line": 12, "column": 122},
"endPos": {"line": 12, "column": 149},
"data":
"function expected at\n IsWeightedHomogeneous\nterm has type\n ?m.35"}],
"env": 0}
|
|||||||||
pNilradical_le_nilradical | import Init
import Mathlib.FieldTheory.PurelyInseparable
import Mathlib.FieldTheory.PerfectClosure
import Mathlib.FieldTheory.IsPerfectClosure
open FiniteDimensional Polynomial IntermediateField Field
| import Init
import Mathlib.FieldTheory.PurelyInseparable
import Mathlib.FieldTheory.PerfectClosure
import Mathlib.FieldTheory.IsPerfectClosure
| open FiniteDimensional Polynomial IntermediateField Field
| theorem pNilradical_le_nilradical {R : Type*} [CommSemiring R] {p : ℕ} :
pNilradical R p ≤ nilradical R := sorry | theorem pNilradical_le_nilradical_extracted : ∀ {R : Type u_1} [inst : CommSemiring R] {p : ℕ}, pNilradical R p ≤ nilradical R := sorry | [['nilradical'], ['CommSemiring', 'toSemiring'], ['pNilradical'], ['Semiring', 'toNonAssocSemiring'], ['PartialOrder', 'toPreorder'], ['NonAssocSemiring', 'toNonUnitalNonAssocSemiring'], ['CompleteLattice', 'instOmegaCompletePartialOrder'], ['OmegaCompletePartialOrder', 'toPartialOrder'], ['Submodule', 'completeLattice'], ['NonUnitalNonAssocSemiring', 'toAddCommMonoid'], ['Ideal'], ['LE', 'le'], ['Semiring', 'toModule'], ['Preorder', 'toLE']] | theorem pNilradical_le_nilradical {R : Type*} [CommSemiring R] {p : ℕ} :
pNilradical R p ≤ nilradical R := by
by_cases hp : 1 < p
· rw [pNilradical, if_pos hp]
simp_rw [pNilradical, if_neg hp, bot_le] | [['CommSemiring', 'toSemiring'], ['OfNat', 'ofNat'], ['PartialOrder', 'toPreorder'], ['OmegaCompletePartialOrder', 'toPartialOrder'], ['Nat', 'decLt'], ['Submodule', 'completeLattice'], ['dite'], ['instLTNat'], ['Preorder', 'toLE'], ['ite'], ['Eq'], ['Semiring', 'toNonAssocSemiring'], ['Eq', 'mpr'], ['instOfNatNat'], ['Nat'], ['Semiring', 'toModule'], ['if_neg'], ['id'], ['nilradical'], ['Submodule', 'instBot'], ['Bot', 'bot'], ['CompleteLattice', 'instOmegaCompletePartialOrder'], ['LE', 'le'], ['pNilradical'], ['if_pos'], ['Submodule', 'instOrderBot'], ['of_eq_true'], ['NonAssocSemiring', 'toNonUnitalNonAssocSemiring'], ['LT', 'lt'], ['OrderBot', 'toBot'], ['le_refl'], ['NonUnitalNonAssocSemiring', 'toAddCommMonoid'], ['congrArg'], ['Ideal'], ['_auxLemma', 1], ['pNilradical', 'eq_1']] | theorem | Syntax(original=True, range=StringRange(start=3131, stop=3346)) | false | ['Mathlib', 'FieldTheory', 'IsPerfectClosure'] | null | leanprover/lean4:v4.11.0
| Mathlib | {"messages":
[{"severity": "error",
"pos": {"line": 7, "column": 8},
"endPos": {"line": 7, "column": 33},
"data": "'pNilradical_le_nilradical' has already been declared"}],
"env": 0}
|
|||||
Module.comap_eval_surjective_tac_19738 | import Init
import Mathlib.LinearAlgebra.FiniteDimensional
import Mathlib.LinearAlgebra.FreeModule.Finite.Basic
import Mathlib.LinearAlgebra.FreeModule.StrongRankCondition
import Mathlib.LinearAlgebra.Projection
import Mathlib.LinearAlgebra.SesquilinearForm
import Mathlib.RingTheory.TensorProduct.Basic
import Mathlib.RingTheory.LocalRing.Basic
import Mathlib.LinearAlgebra.Dual
open Module
open Module Module.Dual Submodule LinearMap Cardinal Function
open Module Module.Dual Submodule LinearMap Cardinal Basis FiniteDimensional
| import Init
import Mathlib.LinearAlgebra.FiniteDimensional
import Mathlib.LinearAlgebra.FreeModule.Finite.Basic
import Mathlib.LinearAlgebra.FreeModule.StrongRankCondition
import Mathlib.LinearAlgebra.Projection
import Mathlib.LinearAlgebra.SesquilinearForm
import Mathlib.RingTheory.TensorProduct.Basic
import Mathlib.RingTheory.LocalRing.Basic
import Mathlib.LinearAlgebra.Dual
| open Module
open Module Module.Dual Submodule LinearMap Cardinal Function
open Module Module.Dual Submodule LinearMap Cardinal Basis FiniteDimensional
| lemma comap_eval_surjective_tac_19738 [CommRing K] [AddCommGroup V] [Module K V] [Free K V] : ker (eval K V) = ⊥ := sorry | lemma comap_eval_surjective_tac_19738 {K : Type*} {V : Type*} [CommRing K] [AddCommGroup V] [Module K V] [Free K V] : ker (eval K V) = ⊥ := sorry | tactic | true | ['Mathlib', 'LinearAlgebra', 'Dual'] | null | leanprover/lean4:v4.11.0
| Mathlib | {"sorries":
[{"proofState": 0,
"pos": {"line": 14, "column": 116},
"goal":
"K : Type u_1\nV : Type u_2\ninst✝³ : CommRing K\ninst✝² : AddCommGroup V\ninst✝¹ : Module K V\ninst✝ : Free K V\n⊢ ker (Dual.eval K V) = ⊥",
"endPos": {"line": 14, "column": 121}}],
"messages":
[{"severity": "warning",
"pos": {"line": 14, "column": 6},
"endPos": {"line": 14, "column": 37},
"data": "declaration uses 'sorry'"}],
"env": 0}
|
|||||||||
isIntegral_iff_isIntegral_closure_finite_tac_6126 | import Init
import Mathlib.RingTheory.IntegralClosure.IsIntegral.Defs
import Mathlib.Algebra.Polynomial.Expand
import Mathlib.RingTheory.Polynomial.Tower
import Mathlib.RingTheory.IntegralClosure.IsIntegral.Basic
open Polynomial Submodule
open Classical in
| import Init
import Mathlib.RingTheory.IntegralClosure.IsIntegral.Defs
import Mathlib.Algebra.Polynomial.Expand
import Mathlib.RingTheory.Polynomial.Tower
import Mathlib.RingTheory.IntegralClosure.IsIntegral.Basic
| open Polynomial Submodule
open Classical in
| lemma isIntegral_iff_isIntegral_closure_finite_tac_6126 [CommRing R] [Ring B] [Algebra R B] (r : B) : IsIntegral R r ↔ ∃ s, s.Finite ∧ IsIntegral (↥(Subring.closure s)) r := sorry | lemma isIntegral_iff_isIntegral_closure_finite_tac_6126 {R : Type*} {B : Type*} [CommRing R] [Ring B] [Algebra R B] (r : B) : IsIntegral R r ↔ ∃ s, s.Finite ∧ IsIntegral (↥(Subring.closure s)) r := sorry | [['aeval_def'], ['hsr'], ['p'], ['hmp'], ['hpr'], ['map_restriction'], ['hr'], ['hsr', 'of_subring'], ['p', 'restriction'], ['Finset', 'finite_toSet'], ['r'], ['R'], ['s'], ['aeval_map_algebraMap'], ['monic_restriction']] | tactic | false | ['Mathlib', 'RingTheory', 'IntegralClosure', 'IsIntegral', 'Basic'] | null | leanprover/lean4:v4.11.0
| Mathlib | {"messages":
[{"severity": "error",
"pos": {"line": 9, "column": 135},
"endPos": {"line": 9, "column": 170},
"data":
"typeclass instance problem is stuck, it is often due to metavariables\n Algebra (↥(Subring.closure s)) B"}],
"env": 0}
|
||||||||
MeasureTheory.Lp.simpleFunc.denseEmbedding_tac_30903 | import Init
import Mathlib.MeasureTheory.Function.L1Space
import Mathlib.MeasureTheory.Function.SimpleFuncDense
import Mathlib.MeasureTheory.Function.SimpleFuncDenseLp
open Set Function Filter TopologicalSpace ENNReal EMetric Finset
open scoped Classical Topology ENNReal MeasureTheory
open AEEqFun
| import Init
import Mathlib.MeasureTheory.Function.L1Space
import Mathlib.MeasureTheory.Function.SimpleFuncDense
import Mathlib.MeasureTheory.Function.SimpleFuncDenseLp
| open Set Function Filter TopologicalSpace ENNReal EMetric Finset
open scoped Classical Topology ENNReal MeasureTheory
open AEEqFun
| lemma denseEmbedding_tac_30903 [MeasurableSpace α] [NormedAddCommGroup E] (p : ℝ≥0∞) (μ : Measure α) [Fact (1 ≤ p)] (hp_ne_top : p ≠ ⊤) (f : ↥(Lp E p μ)) (hfi' : Memℒp (↑↑f) p μ) : ∃ x, (∀ (n : ℕ), x n ∈ Set.range Subtype.val) ∧ Tendsto x atTop (𝓝 f) := sorry | lemma denseEmbedding_tac_30903 {α : Type*} {E : Type*} [MeasurableSpace α] [NormedAddCommGroup E] (p : ℝ≥0∞) (μ : Measure α) [Fact (1 ≤ p)] (hp_ne_top : p ≠ ⊤) (this✝¹ : MeasurableSpace E) (this✝ : BorelSpace E) (f : ↥(Lp E p μ)) (hfi' : Memℒp (↑↑f) p μ) : ∃ x, (∀ (n : ℕ), x n ∈ Set.range Subtype.val) ∧ Tendsto x atTop (𝓝 f) := sorry | [['range'], ['Set'], ['SeparableSpace'], ['separableSpace_range_union_singleton'], [], ['Lp', 'stronglyMeasurable'], ['f'], ['E']] | tactic | null | ['Mathlib', 'MeasureTheory', 'Function', 'SimpleFuncDenseLp'] | null | leanprover/lean4:v4.11.0
| Mathlib | |||||||||
Fintype.mem_piFinset_tac_1262 | import Init
import Mathlib.Data.Finset.Card
import Mathlib.Data.Finset.Pi
import Mathlib.Data.Fintype.Basic
import Mathlib.Data.Fintype.Pi
open Finset Function
| import Init
import Mathlib.Data.Finset.Card
import Mathlib.Data.Finset.Pi
import Mathlib.Data.Fintype.Basic
import Mathlib.Data.Fintype.Pi
| open Finset Function
| lemma mem_piFinset_tac_1262 [DecidableEq α] (t : (a : α) → Finset (δ a)) (f : (a : α) → δ a) : ∀ (x : (a : α) → a ∈ univ → δ a),
(∀ (a : α), x a ⋯ ∈ t a) → { toFun := fun f a => f a ⋯, inj' := ⋯ } x = f → ∀ (a : α), f a ∈ t a := sorry | lemma mem_piFinset_tac_1262 {α : Type*} [DecidableEq α] {inst✝ : Type*} {δ : Type*} (t : (a : α) → Finset (δ a)) (f : (a : α) → δ a) : ∀ (x : (a : α) → a ∈ univ → δ a),
(∀ (a : α), x a ⋯ ∈ t a) → { toFun := fun f a => f a ⋯, inj' := ⋯ } x = f → ∀ (a : α), f a ∈ t a := sorry | [['a'], ['hgf'], ['hg'], ['g']] | tactic | null | ['Mathlib', 'Data', 'Fintype', 'Pi'] | null | leanprover/lean4:v4.11.0
| Mathlib | |||||||||
descPochhammer_succ_right_tac_10942 | import Init
import Mathlib.Algebra.Polynomial.Degree.Definitions
import Mathlib.Algebra.Polynomial.Eval
import Mathlib.Algebra.Polynomial.Monic
import Mathlib.Algebra.Polynomial.RingDivision
import Mathlib.Tactic.Abel
import Mathlib.RingTheory.Polynomial.Pochhammer
open Polynomial
open Polynomial
open Nat
| import Init
import Mathlib.Algebra.Polynomial.Degree.Definitions
import Mathlib.Algebra.Polynomial.Eval
import Mathlib.Algebra.Polynomial.Monic
import Mathlib.Algebra.Polynomial.RingDivision
import Mathlib.Tactic.Abel
import Mathlib.RingTheory.Polynomial.Pochhammer
| open Polynomial
open Polynomial
open Nat
| lemma descPochhammer_succ_right_tac_10942 [Ring R] (n : ℕ) (ih : descPochhammer ℤ (n + 1) = descPochhammer ℤ n * (X - ↑n)) : descPochhammer ℤ (n + 1) * (X - 1 - ↑n) = descPochhammer ℤ (n + 1) * (X - 1 - ↑n) := sorry | lemma descPochhammer_succ_right_tac_10942 {R : Type*} [Ring R] (n : ℕ) (ih : descPochhammer ℤ (n + 1) = descPochhammer ℤ n * (X - ↑n)) : descPochhammer ℤ (n + 1) * (X - 1 - ↑n) = descPochhammer ℤ (n + 1) * (X - 1 - ↑n) := sorry | tactic | false | ['Mathlib', 'RingTheory', 'Polynomial', 'Pochhammer'] | null | leanprover/lean4:v4.11.0
| Mathlib | {"sorries":
[{"proofState": 0,
"pos": {"line": 12, "column": 210},
"goal":
"R : Type u_1\ninst✝ : Ring R\nn : ℕ\nih : descPochhammer ℤ (n + 1) = descPochhammer ℤ n * (X - n)\n⊢ descPochhammer ℤ (n + 1) * (X - 1 - n) = descPochhammer ℤ (n + 1) * (X - 1 - n)",
"endPos": {"line": 12, "column": 215}}],
"messages":
[{"severity": "error",
"pos": {"line": 12, "column": 114},
"endPos": {"line": 12, "column": 120},
"data":
"failed to synthesize\n HSub ?m.99[X] ℕ ?m.218\nAdditional diagnostic information may be available using the `set_option diagnostics true` command."},
{"severity": "error",
"pos": {"line": 12, "column": 125},
"endPos": {"line": 12, "column": 164},
"data":
"failed to synthesize\n HMul ℤ[X] ℕ ?m.881\nAdditional diagnostic information may be available using the `set_option diagnostics true` command."},
{"severity": "error",
"pos": {"line": 12, "column": 167},
"endPos": {"line": 12, "column": 206},
"data":
"failed to synthesize\n HMul ℤ[X] ℕ ?m.881\nAdditional diagnostic information may be available using the `set_option diagnostics true` command."},
{"severity": "error",
"pos": {"line": 12, "column": 153},
"endPos": {"line": 12, "column": 158},
"data":
"failed to synthesize\n HSub ?m.339[X] ℕ ℕ\nAdditional diagnostic information may be available using the `set_option diagnostics true` command."},
{"severity": "error",
"pos": {"line": 12, "column": 195},
"endPos": {"line": 12, "column": 200},
"data":
"failed to synthesize\n HSub ?m.570[X] ℕ ℕ\nAdditional diagnostic information may be available using the `set_option diagnostics true` command."}],
"env": 0}
|
|||||||||
Metric.mem_closure_range_iff_tac_51792 | import Init
import Mathlib.Data.ENNReal.Real
import Mathlib.Tactic.Bound.Attribute
import Mathlib.Topology.EMetricSpace.Defs
import Mathlib.Topology.MetricSpace.Pseudo.Defs
open Set Filter TopologicalSpace Bornology
open scoped ENNReal NNReal Uniformity Topology
open Lean Meta Qq Function
open Metric
| import Init
import Mathlib.Data.ENNReal.Real
import Mathlib.Tactic.Bound.Attribute
import Mathlib.Topology.EMetricSpace.Defs
import Mathlib.Topology.MetricSpace.Pseudo.Defs
| open Set Filter TopologicalSpace Bornology
open scoped ENNReal NNReal Uniformity Topology
open Lean Meta Qq Function
open Metric
| lemma mem_closure_range_iff_tac_51792 [PseudoMetricSpace α] (e : β → α) (a : α) : a ∈ closure (range e) ↔ ∀ ε > 0, ∃ k, dist a (e k) < ε := sorry | lemma mem_closure_range_iff_tac_51792 {α : Type*} {β : Type*} [PseudoMetricSpace α] (e : β → α) (a : α) : a ∈ closure (range e) ↔ ∀ ε > 0, ∃ k, dist a (e k) < ε := sorry | tactic | true | ['Mathlib', 'Topology', 'MetricSpace', 'Pseudo', 'Defs'] | null | leanprover/lean4:v4.11.0
| Mathlib | {"sorries":
[{"proofState": 0,
"pos": {"line": 11, "column": 140},
"goal":
"α : Type u_1\nβ : Sort u_2\ninst✝ : PseudoMetricSpace α\ne : β → α\na : α\n⊢ a ∈ closure (range e) ↔ ∀ ε > 0, ∃ k, dist a (e k) < ε",
"endPos": {"line": 11, "column": 145}}],
"messages":
[{"severity": "warning",
"pos": {"line": 11, "column": 6},
"endPos": {"line": 11, "column": 37},
"data": "declaration uses 'sorry'"}],
"env": 0}
|
|||||||||
NonUnitalStarAlgebra.mem_sup_right_tac_30242 | import Init
import Mathlib.Algebra.Algebra.NonUnitalSubalgebra
import Mathlib.Algebra.Star.StarAlgHom
import Mathlib.Algebra.Star.Center
import Mathlib.Algebra.Star.NonUnitalSubalgebra
open scoped Pointwise
open scoped Pointwise
open NonUnitalStarSubalgebra
| import Init
import Mathlib.Algebra.Algebra.NonUnitalSubalgebra
import Mathlib.Algebra.Star.StarAlgHom
import Mathlib.Algebra.Star.Center
import Mathlib.Algebra.Star.NonUnitalSubalgebra
| open scoped Pointwise
open scoped Pointwise
open NonUnitalStarSubalgebra
| lemma mem_sup_right_tac_30242 [CommSemiring R] [StarRing R] [NonUnitalSemiring A] [StarRing A] [Module R A] [IsScalarTower R A A] [SMulCommClass R A A] [StarModule R A] (S : NonUnitalStarSubalgebra R A) (T : NonUnitalStarSubalgebra R A) : ∀ {x : A}, x ∈ T → x ∈ S ⊔ T := sorry | lemma mem_sup_right_tac_30242 {R : Type*} {A : Type*} [CommSemiring R] [StarRing R] [NonUnitalSemiring A] [StarRing A] [Module R A] [IsScalarTower R A A] [SMulCommClass R A A] [StarModule R A] (S : NonUnitalStarSubalgebra R A) (T : NonUnitalStarSubalgebra R A) : ∀ {x : A}, x ∈ T → x ∈ S ⊔ T := sorry | [['SetLike', 'le_def']] | tactic | true | ['Mathlib', 'Algebra', 'Star', 'NonUnitalSubalgebra'] | null | leanprover/lean4:v4.11.0
| Mathlib | {"sorries":
[{"proofState": 0,
"pos": {"line": 10, "column": 271},
"goal":
"R : Type u_1\nA : Type u_2\ninst✝⁷ : CommSemiring R\ninst✝⁶ : StarRing R\ninst✝⁵ : NonUnitalSemiring A\ninst✝⁴ : StarRing A\ninst✝³ : Module R A\ninst✝² : IsScalarTower R A A\ninst✝¹ : SMulCommClass R A A\ninst✝ : StarModule R A\nS T : NonUnitalStarSubalgebra R A\nx✝ : A\n⊢ x✝ ∈ T → x✝ ∈ S ⊔ T",
"endPos": {"line": 10, "column": 276}}],
"messages":
[{"severity": "warning",
"pos": {"line": 10, "column": 6},
"endPos": {"line": 10, "column": 29},
"data": "declaration uses 'sorry'"}],
"env": 0}
|
||||||||
mem_rootsOfUnity_prime_pow_mul_iff'_tac_10308 | import Init
import Mathlib.Algebra.CharP.Two
import Mathlib.Algebra.CharP.Reduced
import Mathlib.Algebra.NeZero
import Mathlib.Algebra.Polynomial.RingDivision
import Mathlib.GroupTheory.SpecificGroups.Cyclic
import Mathlib.NumberTheory.Divisors
import Mathlib.RingTheory.IntegralDomain
import Mathlib.Tactic.Zify
import Mathlib.RingTheory.RootsOfUnity.Basic
open scoped Classical
open Polynomial
open Finset
| import Init
import Mathlib.Algebra.CharP.Two
import Mathlib.Algebra.CharP.Reduced
import Mathlib.Algebra.NeZero
import Mathlib.Algebra.Polynomial.RingDivision
import Mathlib.GroupTheory.SpecificGroups.Cyclic
import Mathlib.NumberTheory.Divisors
import Mathlib.RingTheory.IntegralDomain
import Mathlib.Tactic.Zify
import Mathlib.RingTheory.RootsOfUnity.Basic
| open scoped Classical
open Polynomial
open Finset
| lemma mem_rootsOfUnity_prime_pow_mul_iff'_tac_10308 [CommRing R] [IsReduced R] (p : ℕ) (k : ℕ) (m : ℕ+) [ExpChar R p] (ζ : Rˣ) : ζ ∈ rootsOfUnity m R ↔ ζ ∈ rootsOfUnity m R := sorry | lemma mem_rootsOfUnity_prime_pow_mul_iff'_tac_10308 {R : Type*} [CommRing R] [IsReduced R] (p : ℕ) (k : ℕ) (m : ℕ+) [ExpChar R p] (ζ : Rˣ) : ζ ∈ rootsOfUnity m R ↔ ζ ∈ rootsOfUnity m R := sorry | tactic | null | ['Mathlib', 'RingTheory', 'RootsOfUnity', 'Basic'] | null | leanprover/lean4:v4.11.0
| Mathlib | ||||||||||
LinearEquiv.prod | import Init
import Mathlib.Algebra.Algebra.Prod
import Mathlib.LinearAlgebra.Span
import Mathlib.Order.PartialSups
import Mathlib.LinearAlgebra.Prod
open Submodule
open LinearMap
| import Init
import Mathlib.Algebra.Algebra.Prod
import Mathlib.LinearAlgebra.Span
import Mathlib.Order.PartialSups
import Mathlib.LinearAlgebra.Prod
| open Submodule
open LinearMap
| /-- Product of linear equivalences; the maps come from `Equiv.prodCongr`. -/
protected def prod : (M × M₃) ≃ₗ[R] M₂ × M₄ := sorry | def prod_extracted : {R : Type u} →
{M : Type v} →
{M₂ : Type w} →
{M₃ : Type y} →
{M₄ : Type z} →
[inst : Semiring R] →
[inst_1 : AddCommMonoid M] →
[inst_2 : AddCommMonoid M₂] →
[inst_3 : AddCommMonoid M₃] →
[inst_4 : AddCommMonoid M₄] →
{module_M : Module R M} →
{module_M₂ : Module R M₂} →
{module_M₃ : Module R M₃} →
{module_M₄ : Module R M₄} → (M ≃ₗ[R] M₂) → (M₃ ≃ₗ[R] M₄) → (M × M₃) ≃ₗ[R] M₂ × M₄ := sorry | [['Semiring', 'toNonAssocSemiring'], ['Prod', 'instModule'], ['Prod', 'instAddCommMonoid'], ['LinearEquiv'], ['Prod'], ['RingHom', 'id'], ['RingHomInvPair', 'ids']] | /-- Product of linear equivalences; the maps come from `Equiv.prodCongr`. -/
protected def prod : (M × M₃) ≃ₗ[R] M₂ × M₄ :=
{ e₁.toAddEquiv.prodCongr e₂.toAddEquiv with
map_smul' := fun c _x => Prod.ext (e₁.map_smulₛₗ c _) (e₂.map_smulₛₗ c _) } | [['AddZeroClass', 'toAdd'], ['AddCommSemigroup', 'toAddCommMagma'], ['Equiv', 'toFun'], ['Prod', 'instModule'], ['Prod', 'instAddCommMonoid'], ['AddHom', 'mk'], ['LinearEquiv', 'prod', 'proof_4'], ['AddCommMonoid', 'toAddMonoid'], ['LinearMap', 'mk'], ['LinearEquiv', 'prod', 'proof_2'], ['AddMonoid', 'toAddZeroClass'], ['AddCommMagma', 'toAdd'], ['LinearEquiv', 'prod', 'proof_1'], ['RingHom', 'id'], ['AddEquiv', 'prodCongr'], ['LinearEquiv', 'mk'], ['Semiring', 'toNonAssocSemiring'], ['Equiv', 'invFun'], ['AddEquiv', 'toEquiv'], ['Prod'], ['Prod', 'instAdd'], ['AddCommMonoid', 'toAddCommSemigroup'], ['LinearEquiv', 'toAddEquiv'], ['LinearEquiv', 'prod', 'proof_3'], ['RingHomInvPair', 'ids']] | Product of linear equivalences; the maps come from `Equiv.prodCongr`. | theorem | Syntax(original=True, range=StringRange(start=25898, stop=26176)) | false | ['Mathlib', 'LinearAlgebra', 'Prod'] | null | leanprover/lean4:v4.11.0
| Mathlib | {"messages":
[{"severity": "error",
"pos": {"line": 10, "column": 14},
"endPos": {"line": 10, "column": 18},
"data": "protected declarations must be in a namespace"}],
"env": 0}
|
||||
Polynomial.isUnit_of_coeff_isUnit_isNilpotent_tac_4567 | import Init
import Mathlib.Algebra.Polynomial.AlgebraMap
import Mathlib.Algebra.Polynomial.Div
import Mathlib.Algebra.Polynomial.Identities
import Mathlib.RingTheory.Ideal.QuotientOperations
import Mathlib.RingTheory.Nilpotent.Lemmas
import Mathlib.RingTheory.Polynomial.Tower
import Mathlib.RingTheory.Nilpotent.Basic
import Mathlib.RingTheory.Polynomial.Nilpotent
| import Init
import Mathlib.Algebra.Polynomial.AlgebraMap
import Mathlib.Algebra.Polynomial.Div
import Mathlib.Algebra.Polynomial.Identities
import Mathlib.RingTheory.Ideal.QuotientOperations
import Mathlib.RingTheory.Nilpotent.Lemmas
import Mathlib.RingTheory.Polynomial.Tower
import Mathlib.RingTheory.Nilpotent.Basic
import Mathlib.RingTheory.Polynomial.Nilpotent
| lemma isUnit_of_coeff_isUnit_isNilpotent_tac_4567 [CommRing R] (k : ℕ) (hind : ∀ m < k, ∀ {P : R[X]}, IsUnit (P.coeff 0) → (∀ (i : ℕ), i ≠ 0 → IsNilpotent (P.coeff i)) → P.natDegree = m → IsUnit P) (P : R[X]) (hunit : IsUnit (P.coeff 0)) (hnil : ∀ (i : ℕ), i ≠ 0 → IsNilpotent (P.coeff i)) (h : P.natDegree = k) (hdeg : ¬P.natDegree = 0) (P₁ : R[X]) (hP₁ : P₁ = P.eraseLead) (hdeg₂ : P.eraseLead.natDegree < P.natDegree) : IsUnit (P₁.coeff 0) := sorry | lemma isUnit_of_coeff_isUnit_isNilpotent_tac_4567 {R : Type*} [CommRing R] (k : ℕ) (hind : ∀ m < k, ∀ {P : R[X]}, IsUnit (P.coeff 0) → (∀ (i : ℕ), i ≠ 0 → IsNilpotent (P.coeff i)) → P.natDegree = m → IsUnit P) (P : R[X]) (hunit : IsUnit (P.coeff 0)) (hnil : ∀ (i : ℕ), i ≠ 0 → IsNilpotent (P.coeff i)) (h : P.natDegree = k) (hdeg : ¬P.natDegree = 0) (P₁ : R[X]) (hP₁ : P₁ = P.eraseLead) (hdeg₂ : P.eraseLead.natDegree < P.natDegree) : IsUnit (P₁.coeff 0) := sorry | tactic | false | ['Mathlib', 'RingTheory', 'Polynomial', 'Nilpotent'] | null | leanprover/lean4:v4.11.0
| Mathlib | {"sorries":
[{"proofState": 0,
"pos": {"line": 12, "column": 446},
"goal":
"R : Type u_1\nidx✝ : Type u_2\nX : idx✝\ninst✝ : CommRing R\nk : ℕ\nhind :\n ∀ m < k,\n ∀ {P : R[X]},\n IsUnit (sorryAx (?m.10444 k m) true) →\n (∀ (i : ℕ), i ≠ 0 → IsNilpotent (sorryAx (?m.10448 k m i) true)) → sorryAx ℕ true = m → IsUnit P\nP : R[X]\nhunit : IsUnit (sorryAx (?m.10460 k hind P) true)\nhnil : ∀ (i : ℕ), i ≠ 0 → IsNilpotent (sorryAx (?m.10466 k hind P hunit i) true)\nh : sorryAx ℕ true = k\nhdeg : ¬sorryAx ℕ true = 0\nP₁ : R[X]\nhP₁ : P₁ = sorryAx R[X] true\nhdeg₂ :\n sorryAx (?m.10478 k hind P hunit hnil h hdeg P₁ hP₁) true < sorryAx (?m.10478 k hind P hunit hnil h hdeg P₁ hP₁) true\n⊢ IsUnit (sorryAx (?m.10484 k hind P hunit hnil h hdeg P₁ hP₁ hdeg₂) true)",
"endPos": {"line": 12, "column": 451}}],
"messages":
[{"severity": "error",
"pos": {"line": 12, "column": 110},
"endPos": {"line": 12, "column": 119},
"data":
"invalid field 'coeff', the environment does not contain 'GetElem.getElem.coeff'\n P\nhas type\n R[X]"},
{"severity": "error",
"pos": {"line": 12, "column": 110},
"endPos": {"line": 12, "column": 119},
"data":
"invalid field notation, type is not of the form (C ...) where C is a constant\n P\nhas type\n ?m.63.1 R X ?m.64"},
{"severity": "error",
"pos": {"line": 12, "column": 156},
"endPos": {"line": 12, "column": 165},
"data":
"invalid field 'coeff', the environment does not contain 'GetElem.getElem.coeff'\n P\nhas type\n R[X]"},
{"severity": "error",
"pos": {"line": 12, "column": 156},
"endPos": {"line": 12, "column": 165},
"data":
"invalid field notation, type is not of the form (C ...) where C is a constant\n P\nhas type\n ?m.63.1 R X ?m.64"},
{"severity": "error",
"pos": {"line": 12, "column": 170},
"endPos": {"line": 12, "column": 181},
"data":
"invalid field 'natDegree', the environment does not contain 'GetElem.getElem.natDegree'\n P\nhas type\n R[X]"},
{"severity": "error",
"pos": {"line": 12, "column": 170},
"endPos": {"line": 12, "column": 181},
"data":
"invalid field notation, type is not of the form (C ...) where C is a constant\n P\nhas type\n ?m.63.1 R X ?m.64"},
{"severity": "error",
"pos": {"line": 12, "column": 226},
"endPos": {"line": 12, "column": 235},
"data":
"invalid field 'coeff', the environment does not contain 'GetElem.getElem.coeff'\n P\nhas type\n R[X]"},
{"severity": "error",
"pos": {"line": 12, "column": 226},
"endPos": {"line": 12, "column": 235},
"data":
"invalid field notation, type is not of the form (C ...) where C is a constant\n P\nhas type\n ?m.1102.1 R X ?m.1103"},
{"severity": "error",
"pos": {"line": 12, "column": 278},
"endPos": {"line": 12, "column": 287},
"data":
"invalid field 'coeff', the environment does not contain 'GetElem.getElem.coeff'\n P\nhas type\n R[X]"},
{"severity": "error",
"pos": {"line": 12, "column": 278},
"endPos": {"line": 12, "column": 287},
"data":
"invalid field notation, type is not of the form (C ...) where C is a constant\n P\nhas type\n ?m.1102.1 R X ?m.1103"},
{"severity": "error",
"pos": {"line": 12, "column": 295},
"endPos": {"line": 12, "column": 306},
"data":
"invalid field 'natDegree', the environment does not contain 'GetElem.getElem.natDegree'\n P\nhas type\n R[X]"},
{"severity": "error",
"pos": {"line": 12, "column": 295},
"endPos": {"line": 12, "column": 306},
"data":
"invalid field notation, type is not of the form (C ...) where C is a constant\n P\nhas type\n ?m.1102.1 R X ?m.1103"},
{"severity": "error",
"pos": {"line": 12, "column": 321},
"endPos": {"line": 12, "column": 332},
"data":
"invalid field 'natDegree', the environment does not contain 'GetElem.getElem.natDegree'\n P\nhas type\n R[X]"},
{"severity": "error",
"pos": {"line": 12, "column": 321},
"endPos": {"line": 12, "column": 332},
"data":
"invalid field notation, type is not of the form (C ...) where C is a constant\n P\nhas type\n ?m.1102.1 R X ?m.1103"},
{"severity": "error",
"pos": {"line": 12, "column": 362},
"endPos": {"line": 12, "column": 373},
"data":
"invalid field 'eraseLead', the environment does not contain 'GetElem.getElem.eraseLead'\n P\nhas type\n R[X]"},
{"severity": "error",
"pos": {"line": 12, "column": 362},
"endPos": {"line": 12, "column": 373},
"data":
"invalid field notation, type is not of the form (C ...) where C is a constant\n P\nhas type\n ?m.1102.1 R X ?m.1103"},
{"severity": "error",
"pos": {"line": 12, "column": 384},
"endPos": {"line": 12, "column": 405},
"data":
"invalid field 'eraseLead', the environment does not contain 'GetElem.getElem.eraseLead'\n P\nhas type\n R[X]"},
{"severity": "error",
"pos": {"line": 12, "column": 384},
"endPos": {"line": 12, "column": 405},
"data":
"invalid field notation, type is not of the form (C ...) where C is a constant\n P\nhas type\n ?m.1102.1 R X ?m.1103"},
{"severity": "error",
"pos": {"line": 12, "column": 408},
"endPos": {"line": 12, "column": 419},
"data":
"invalid field 'natDegree', the environment does not contain 'GetElem.getElem.natDegree'\n P\nhas type\n R[X]"},
{"severity": "error",
"pos": {"line": 12, "column": 408},
"endPos": {"line": 12, "column": 419},
"data":
"invalid field notation, type is not of the form (C ...) where C is a constant\n P\nhas type\n ?m.1102.1 R X ?m.1103"},
{"severity": "error",
"pos": {"line": 12, "column": 431},
"endPos": {"line": 12, "column": 441},
"data":
"invalid field 'coeff', the environment does not contain 'GetElem.getElem.coeff'\n P₁\nhas type\n R[X]"},
{"severity": "error",
"pos": {"line": 12, "column": 431},
"endPos": {"line": 12, "column": 441},
"data":
"invalid field notation, type is not of the form (C ...) where C is a constant\n P₁\nhas type\n ?m.2438.1 R X ?m.2439"}],
"env": 0}
|
||||||||||
CategoryTheory.Limits.splitEpiOfIdempotentOfIsColimitCofork_tac_50078 | import Init
import Mathlib.CategoryTheory.EpiMono
import Mathlib.CategoryTheory.Limits.HasLimits
import Mathlib.CategoryTheory.Limits.Shapes.Equalizers
open CategoryTheory Opposite
open WalkingParallelPair
open WalkingParallelPairHom
| import Init
import Mathlib.CategoryTheory.EpiMono
import Mathlib.CategoryTheory.Limits.HasLimits
import Mathlib.CategoryTheory.Limits.Shapes.Equalizers
| open CategoryTheory Opposite
open WalkingParallelPair
open WalkingParallelPairHom
| lemma splitEpiOfIdempotentOfIsColimitCofork_tac_50078 [Category.{v, u} C] (Y : C) (g : X✝ ⟶ Y) (X : C) (f : X ⟶ X) (hf : f ≫ f = f) (c : Cofork (𝟙 X) f) (i : IsColimit c) (this : Epi c.π) : i.desc (Cofork.ofπ f ⋯) ≫ c.π = 𝟙 (((Functor.const WalkingParallelPair).obj c.pt).obj one) := sorry | lemma splitEpiOfIdempotentOfIsColimitCofork_tac_50078 {C : Type*} [Category.{v, u} C] (X✝ : C) (Y : C) (f✝ : X✝ ⟶ Y) (g : X✝ ⟶ Y) (X : C) (f : X ⟶ X) (hf : f ≫ f = f) (c : Cofork (𝟙 X) f) (i : IsColimit c) (this : Epi c.π) : i.desc (Cofork.ofπ f ⋯) ≫ c.π = 𝟙 (((Functor.const WalkingParallelPair).obj c.pt).obj one) := sorry | [['c', 'π'], ['cancel_epi_id']] | tactic | false | ['Mathlib', 'CategoryTheory', 'Limits', 'Shapes', 'Equalizers'] | null | leanprover/lean4:v4.11.0
| Mathlib | {"messages":
[{"severity": "error",
"pos": {"line": 6, "column": 5},
"endPos": {"line": 6, "column": 24},
"data": "unknown namespace 'WalkingParallelPair'"},
{"severity": "error",
"pos": {"line": 7, "column": 5},
"endPos": {"line": 7, "column": 27},
"data": "unknown namespace 'WalkingParallelPairHom'"},
{"severity": "error",
"pos": {"line": 9, "column": 88},
"endPos": null,
"data": "expected token"}],
"env": 0}
|
||||||||
Algebra.traceForm_toMatrix_tac_6552 | import Init
import Mathlib.LinearAlgebra.Matrix.BilinearForm
import Mathlib.LinearAlgebra.FiniteDimensional
import Mathlib.LinearAlgebra.Trace
import Mathlib.RingTheory.Trace.Defs
open FiniteDimensional
open LinearMap (BilinForm)
open LinearMap
open Matrix
open scoped Matrix
| import Init
import Mathlib.LinearAlgebra.Matrix.BilinearForm
import Mathlib.LinearAlgebra.FiniteDimensional
import Mathlib.LinearAlgebra.Trace
import Mathlib.RingTheory.Trace.Defs
| open FiniteDimensional
open LinearMap (BilinForm)
open LinearMap
open Matrix
open scoped Matrix
| lemma traceForm_toMatrix_tac_6552 [CommRing R] [CommRing S] [Algebra R S] [DecidableEq ι] (b : Basis ι R S) (i : ι) (j : ι) : ((traceForm R S) (b i)) (b j) = (trace R S) (b i * b j) := sorry | lemma traceForm_toMatrix_tac_6552 {R : Type*} {S : Type*} [CommRing R] [CommRing S] [Algebra R S] {ι : Type*} {inst✝¹ : Type*} [DecidableEq ι] (b : Basis ι R S) (i : ι) (j : ι) : ((traceForm R S) (b i)) (b j) = (trace R S) (b i * b j) := sorry | [['traceForm_apply']] | tactic | false | ['Mathlib', 'RingTheory', 'Trace', 'Defs'] | null | leanprover/lean4:v4.11.0
| Mathlib | {"sorries":
[{"proofState": 0,
"pos": {"line": 12, "column": 185},
"goal":
"R : Type u_1\nS : Type u_2\nι : Type u_3\nx✝ : Sort u_4\ntraceForm : x✝\ninst✝³ : CommRing R\ninst✝² : CommRing S\ninst✝¹ : Algebra R S\ninst✝ : DecidableEq ι\nb : Basis ι R S\ni j : ι\n⊢ sorryAx R true = (LinearMap.trace R S) (sorryAx (S →ₗ[R] S) true)",
"endPos": {"line": 12, "column": 190}}],
"messages":
[{"severity": "error",
"pos": {"line": 12, "column": 171},
"endPos": {"line": 12, "column": 180},
"data":
"type mismatch\n b i * b j\nhas type\n S : outParam (Type ?u.1260)\nbut is expected to have type\n S →ₗ[R] S : Type ?u.1260"},
{"severity": "error",
"pos": {"line": 12, "column": 128},
"endPos": {"line": 12, "column": 141},
"data": "function expected at\n traceForm\nterm has type\n ?m.1254"}],
"env": 0}
|
||||||||
MeasureTheory.Measure.haar.index_mono_tac_9181 | import Init
import Mathlib.MeasureTheory.Measure.Content
import Mathlib.MeasureTheory.Group.Prod
import Mathlib.Topology.Algebra.Group.Compact
import Mathlib.MeasureTheory.Measure.Haar.Basic
open Set Inv Function TopologicalSpace MeasurableSpace
open scoped NNReal ENNReal Pointwise Topology
| import Init
import Mathlib.MeasureTheory.Measure.Content
import Mathlib.MeasureTheory.Group.Prod
import Mathlib.Topology.Algebra.Group.Compact
import Mathlib.MeasureTheory.Measure.Haar.Basic
| open Set Inv Function TopologicalSpace MeasurableSpace
open scoped NNReal ENNReal Pointwise Topology
| lemma index_mono_tac_9181 [Group G] [TopologicalSpace G] [TopologicalGroup G] (K : Set G) (K' : Set G) (V : Set G) (hK' : IsCompact K') (h : K ⊆ K') (hV : (interior V).Nonempty) (s : Finset G) (h1s : K' ⊆ ⋃ g ∈ s, (fun h => g * h) ⁻¹' V) (h2s : s.card = index K' V) : ∃ x ∈ {t | K ⊆ ⋃ g ∈ t, (fun h => g * h) ⁻¹' V}, x.card = index K' V := sorry | lemma index_mono_tac_9181 {G : Type*} [Group G] [TopologicalSpace G] [TopologicalGroup G] (K : Set G) (K' : Set G) (V : Set G) (hK' : IsCompact K') (h : K ⊆ K') (hV : (interior V).Nonempty) (s : Finset G) (h1s : K' ⊆ ⋃ g ∈ s, (fun h => g * h) ⁻¹' V) (h2s : s.card = index K' V) : ∃ x ∈ {t | K ⊆ ⋃ g ∈ t, (fun h => g * h) ⁻¹' V}, x.card = index K' V := sorry | tactic | null | ['Mathlib', 'MeasureTheory', 'Measure', 'Haar', 'Basic'] | null | leanprover/lean4:v4.11.0
| Mathlib | ||||||||||
Isometry.diam_range_tac_7777 | import Init
import Mathlib.Topology.MetricSpace.Antilipschitz
import Mathlib.Topology.MetricSpace.Isometry
open Function Set
open scoped Topology ENNReal
| import Init
import Mathlib.Topology.MetricSpace.Antilipschitz
import Mathlib.Topology.MetricSpace.Isometry
| open Function Set
open scoped Topology ENNReal
| lemma diam_range_tac_7777 [PseudoMetricSpace α] [PseudoMetricSpace β] (f : α → β) (hf : Isometry f) : Metric.diam (range f) = Metric.diam univ := sorry | lemma diam_range_tac_7777 {α : Type*} {β : Type*} [PseudoMetricSpace α] [PseudoMetricSpace β] (f : α → β) (hf : Isometry f) : Metric.diam (range f) = Metric.diam univ := sorry | [['hf', 'diam_image'], ['univ'], ['image_univ']] | tactic | false | ['Mathlib', 'Topology', 'MetricSpace', 'Isometry'] | null | leanprover/lean4:v4.11.0
| Mathlib | {"messages":
[{"severity": "error",
"pos": {"line": 7, "column": 126},
"endPos": {"line": 7, "column": 142},
"data":
"typeclass instance problem is stuck, it is often due to metavariables\n PseudoMetricSpace ?m.131"}],
"env": 0}
|
||||||||
ZMod.LFunction_eq_LSeries_tac_4411 | import Init
import Mathlib.Analysis.Fourier.ZMod
import Mathlib.Analysis.NormedSpace.Connected
import Mathlib.LinearAlgebra.Dimension.DivisionRing
import Mathlib.NumberTheory.LSeries.RiemannZeta
import Mathlib.Topology.Algebra.Module.Cardinality
import Mathlib.NumberTheory.LSeries.ZMod
open HurwitzZeta Complex ZMod Finset Classical Topology Filter
open scoped Real
| import Init
import Mathlib.Analysis.Fourier.ZMod
import Mathlib.Analysis.NormedSpace.Connected
import Mathlib.LinearAlgebra.Dimension.DivisionRing
import Mathlib.NumberTheory.LSeries.RiemannZeta
import Mathlib.Topology.Algebra.Module.Cardinality
import Mathlib.NumberTheory.LSeries.ZMod
| open HurwitzZeta Complex ZMod Finset Classical Topology Filter
open scoped Real
| lemma LFunction_eq_LSeries_tac_4411 (N : ℕ) [NeZero N] (Φ : ZMod N → ℂ) (s : ℂ) (hs : 1 < s.re) (j : ZMod N) (this : ↑j.val / ↑N ∈ Set.Icc 0 1) (m : ℕ) : Φ j / (↑j.val + ↑N * ↑m) ^ s = Φ j / (↑j.val + ↑N * ↑m) ^ s := sorry | lemma LFunction_eq_LSeries_tac_4411 (N : ℕ) [NeZero N] (Φ : ZMod N → ℂ) (s : ℂ) (hs : 1 < s.re) (j : ZMod N) (this : ↑j.val / ↑N ∈ Set.Icc 0 1) (m : ℕ) : Φ j / (↑j.val + ↑N * ↑m) ^ s = Φ j / (↑j.val + ↑N * ↑m) ^ s := sorry | tactic | true | ['Mathlib', 'NumberTheory', 'LSeries', 'ZMod'] | null | leanprover/lean4:v4.11.0
| Mathlib | {"sorries":
[{"proofState": 0,
"pos": {"line": 11, "column": 217},
"goal":
"N : ℕ\ninst✝ : NeZero N\nΦ : ZMod N → ℂ\ns : ℂ\nhs : 1 < s.re\nj : ZMod N\nthis : j.val / N ∈ Set.Icc 0 1\nm : ℕ\n⊢ Φ j / (↑j.val + ↑N * ↑m) ^ s = Φ j / (↑j.val + ↑N * ↑m) ^ s",
"endPos": {"line": 11, "column": 222}}],
"messages":
[{"severity": "warning",
"pos": {"line": 11, "column": 6},
"endPos": {"line": 11, "column": 35},
"data": "declaration uses 'sorry'"}],
"env": 0}
|
|||||||||
Pi.isPWO_tac_33380 | import Init
import Mathlib.Data.Prod.Lex
import Mathlib.Data.Sigma.Lex
import Mathlib.Order.Antichain
import Mathlib.Order.OrderIsoNat
import Mathlib.Order.WellFounded
import Mathlib.Tactic.TFAE
import Mathlib.Order.WellFoundedSet
open Relation
open List in
open Set
| import Init
import Mathlib.Data.Prod.Lex
import Mathlib.Data.Sigma.Lex
import Mathlib.Order.Antichain
import Mathlib.Order.OrderIsoNat
import Mathlib.Order.WellFounded
import Mathlib.Tactic.TFAE
import Mathlib.Order.WellFoundedSet
| open Relation
open List in
open Set
| lemma isPWO_tac_33380 [(i : ι) → LinearOrder (α i)] [∀ (i : ι), IsWellOrder (α i) fun x x_1 => x < x_1] [Finite ι] (s : Set ((i : ι) → α i)) : ∀ (a : ι) (s : Finset ι) (h : a ∉ s),
(∀ (f : ℕ → (s : ι) → α s), ∃ g, ∀ ⦃a b : ℕ⦄, a ≤ b → ∀ x ∈ s, (f ∘ ⇑g) a x ≤ (f ∘ ⇑g) b x) →
∀ (f : ℕ → (s : ι) → α s), ∃ g, ∀ ⦃a_2 b : ℕ⦄, a_2 ≤ b → ∀ x ∈ Finset.cons a s h, (f ∘ ⇑g) a_2 x ≤ (f ∘ ⇑g) b x := sorry | lemma isPWO_tac_33380 {ι : Type*} {α : Type*} [(i : ι) → LinearOrder (α i)] [∀ (i : ι), IsWellOrder (α i) fun x x_1 => x < x_1] [Finite ι] (s : Set ((i : ι) → α i)) {val✝ : Type*} : ∀ (a : ι) (s : Finset ι) (h : a ∉ s),
(∀ (f : ℕ → (s : ι) → α s), ∃ g, ∀ ⦃a b : ℕ⦄, a ≤ b → ∀ x ∈ s, (f ∘ ⇑g) a x ≤ (f ∘ ⇑g) b x) →
∀ (f : ℕ → (s : ι) → α s), ∃ g, ∀ ⦃a_2 b : ℕ⦄, a_2 ≤ b → ∀ x ∈ Finset.cons a s h, (f ∘ ⇑g) a_2 x ≤ (f ∘ ⇑g) b x := sorry | [['OrderHomClass', 'mono'], ['Finset', 'forall_mem_cons'], ['IsWellFounded', 'wf', 'isWF'], ['mem_univ'], ["hg'"], ["g'", 'trans'], ['s'], ['hg'], ["g'"], ['b'], ['isPWO', 'exists_monotone_subseq'], ['ih'], ['x'], ['n'], ['univ'], ['hx'], ['a'], ['f'], ['g'], ['hab']] | tactic | false | ['Mathlib', 'Order', 'WellFoundedSet'] | null | leanprover/lean4:v4.11.0
| Mathlib | {"messages":
[{"severity": "error",
"pos": {"line": 14, "column": 70},
"endPos": {"line": 14, "column": 72},
"data": "cannot coerce to function\n g"},
{"severity": "error",
"pos": {"line": 14, "column": 85},
"endPos": {"line": 14, "column": 87},
"data": "cannot coerce to function\n g"},
{"severity": "error",
"pos": {"line": 15, "column": 91},
"endPos": {"line": 15, "column": 93},
"data": "cannot coerce to function\n g"},
{"severity": "error",
"pos": {"line": 15, "column": 108},
"endPos": {"line": 15, "column": 110},
"data": "cannot coerce to function\n g"},
{"severity": "error",
"pos": {"line": 13, "column": 46},
"endPos": {"line": 13, "column": 49},
"data": "function expected at\n α\nterm has type\n ?m.12"},
{"severity": "error",
"pos": {"line": 13, "column": 77},
"endPos": {"line": 13, "column": 80},
"data": "function expected at\n α\nterm has type\n ?m.12"},
{"severity": "error",
"pos": {"line": 13, "column": 135},
"endPos": {"line": 13, "column": 138},
"data": "function expected at\n α\nterm has type\n ?m.12"},
{"severity": "error",
"pos": {"line": 14, "column": 24},
"endPos": {"line": 14, "column": 27},
"data": "function expected at\n α\nterm has type\n ?m.12"},
{"severity": "error",
"pos": {"line": 15, "column": 25},
"endPos": {"line": 15, "column": 28},
"data": "function expected at\n α\nterm has type\n ?m.12"},
{"severity": "error",
"pos": {"line": 13, "column": 0},
"endPos": {"line": 15, "column": 115},
"data":
"stuck at solving universe constraint\n imax (?u.108+1) ?u.99 =?= ?u.96+1\nwhile trying to unify\n Sort (imax (?u.108 + 1) ?u.99) : Type (imax (?u.108 + 1) ?u.99)\nwith\n Type ?u.96 : Type (?u.96 + 1)"}],
"env": 0}
|
||||||||
Computation.corec_eq_tac_7053 | import Init
import Mathlib.Data.Nat.Find
import Mathlib.Data.Stream.Init
import Mathlib.Tactic.Common
import Mathlib.Data.Seq.Computation
open Function
| import Init
import Mathlib.Data.Nat.Find
import Mathlib.Data.Stream.Init
import Mathlib.Tactic.Common
import Mathlib.Data.Seq.Computation
| open Function
| lemma corec_eq_tac_7053 (f : β → α ⊕ β) (b : β) : (match Sum.rec some (fun x => none) (f b) with
| none => Sum.inr (tail ⟨Stream'.corec' (Corec.f f) (Sum.inr b), ⋯⟩)
| some a => Sum.inl a) =
match f b with
| Sum.inl a => Sum.inl a
| Sum.inr b => Sum.inr ⟨Stream'.corec' (Corec.f f) (Sum.inr b), ⋯⟩ := sorry | lemma corec_eq_tac_7053 {α : Type*} {β : Type*} (f : β → α ⊕ β) (b : β) : (match Sum.rec some (fun x => none) (f b) with
| none => Sum.inr (tail ⟨Stream'.corec' (Corec.f f) (Sum.inr b), ⋯⟩)
| some a => Sum.inl a) =
match f b with
| Sum.inl a => Sum.inl a
| Sum.inr b => Sum.inr ⟨Stream'.corec' (Corec.f f) (Sum.inr b), ⋯⟩ := sorry | tactic | false | ['Mathlib', 'Data', 'Seq', 'Computation'] | null | leanprover/lean4:v4.11.0
| Mathlib | {"sorries":
[{"proofState": 0,
"pos": {"line": 13, "column": 70},
"goal":
"β : Type u_1\nα : Type u_2\nx✝ : Sort u_3\ntail : x✝\nf : β → α ⊕ β\nb : β\n⊢ sorryAx (α ⊕ ?m.556 f b) true =\n match f b with\n | Sum.inl a => Sum.inl a\n | Sum.inr b_1 => Sum.inr (sorryAx (?m.556 f b) true)",
"endPos": {"line": 13, "column": 75}}],
"messages":
[{"severity": "error",
"pos": {"line": 8, "column": 57},
"endPos": {"line": 8, "column": 91},
"data": "failed to elaborate eliminator, expected type is not available"},
{"severity": "error",
"pos": {"line": 9, "column": 21},
"endPos": {"line": 9, "column": 67},
"data": "function expected at\n tail\nterm has type\n ?m.166"},
{"severity": "error",
"pos": {"line": 13, "column": 25},
"endPos": {"line": 13, "column": 66},
"data":
"invalid constructor ⟨...⟩, expected type must be an inductive type \n ?m.488"}],
"env": 0}
|
|||||||||
CategoryTheory.isCofilteredOrEmpty_of_directed_ge_tac_22424 | import Init
import Mathlib.CategoryTheory.FinCategory.Basic
import Mathlib.CategoryTheory.Limits.Cones
import Mathlib.CategoryTheory.Limits.Shapes.FiniteLimits
import Mathlib.CategoryTheory.Adjunction.Basic
import Mathlib.CategoryTheory.Category.Preorder
import Mathlib.CategoryTheory.Category.ULift
import Mathlib.CategoryTheory.PEmpty
import Mathlib.CategoryTheory.Filtered.Basic
open Function
open IsFiltered
open CategoryTheory.Limits
open CategoryTheory.Limits
| import Init
import Mathlib.CategoryTheory.FinCategory.Basic
import Mathlib.CategoryTheory.Limits.Cones
import Mathlib.CategoryTheory.Limits.Shapes.FiniteLimits
import Mathlib.CategoryTheory.Adjunction.Basic
import Mathlib.CategoryTheory.Category.Preorder
import Mathlib.CategoryTheory.Category.ULift
import Mathlib.CategoryTheory.PEmpty
import Mathlib.CategoryTheory.Filtered.Basic
| open Function
open IsFiltered
open CategoryTheory.Limits
open CategoryTheory.Limits
| lemma isCofilteredOrEmpty_of_directed_ge_tac_22424 [Category.{v, u} C] [Preorder α] [IsDirected α fun x x_1 => x ≥ x_1] (X : α) (Y : α) (f : X ⟶ Y) (g : X ⟶ Y) : 𝟙 X ≫ f = 𝟙 X ≫ g := sorry | lemma isCofilteredOrEmpty_of_directed_ge_tac_22424 {C : Type*} [Category.{v, u} C] {α : Type*} [Preorder α] [IsDirected α fun x x_1 => x ≥ x_1] (X : α) (Y : α) (f : X ⟶ Y) (g : X ⟶ Y) : 𝟙 X ≫ f = 𝟙 X ≫ g := sorry | [['ULift', 'ext']] | tactic | false | ['Mathlib', 'CategoryTheory', 'Filtered', 'Basic'] | null | leanprover/lean4:v4.11.0
| Mathlib | {"messages":
[{"severity": "error",
"pos": {"line": 11, "column": 5},
"endPos": {"line": 11, "column": 15},
"data": "unknown namespace 'IsFiltered'"},
{"severity": "error",
"pos": {"line": 15, "column": 162},
"endPos": null,
"data": "expected token"}],
"env": 0}
|
||||||||
Polynomial.aroots_X_pow_tac_16080 | import Init
import Mathlib.Algebra.Polynomial.RingDivision
import Mathlib.RingTheory.Localization.FractionRing
import Mathlib.SetTheory.Cardinal.Basic
import Mathlib.Algebra.Polynomial.Roots
open Multiset Finset
| import Init
import Mathlib.Algebra.Polynomial.RingDivision
import Mathlib.RingTheory.Localization.FractionRing
import Mathlib.SetTheory.Cardinal.Basic
import Mathlib.Algebra.Polynomial.Roots
| open Multiset Finset
| lemma aroots_X_pow_tac_16080 [CommRing T] [CommRing S] [IsDomain S] [Algebra T S] (n : ℕ) : n • {0} = n • {0} := sorry | lemma aroots_X_pow_tac_16080 {S : Type*} {T : Type*} [CommRing T] [CommRing S] [IsDomain S] [Algebra T S] (n : ℕ) : n • {0} = n • {0} := sorry | tactic | false | ['Mathlib', 'Algebra', 'Polynomial', 'Roots'] | null | leanprover/lean4:v4.11.0
| Mathlib | {"messages":
[{"severity": "error",
"pos": {"line": 8, "column": 102},
"endPos": {"line": 8, "column": 109},
"data":
"typeclass instance problem is stuck, it is often due to metavariables\n HSMul ℕ ?m.655 ?m.752"}],
"env": 0}
|
|||||||||
jacobiSym.list_prod_right_tac_11520 | import Init
import Mathlib.NumberTheory.LegendreSymbol.QuadraticReciprocity
import Mathlib.NumberTheory.LegendreSymbol.JacobiSymbol
open Nat ZMod
open NumberTheorySymbols
| import Init
import Mathlib.NumberTheory.LegendreSymbol.QuadraticReciprocity
import Mathlib.NumberTheory.LegendreSymbol.JacobiSymbol
| open Nat ZMod
open NumberTheorySymbols
| lemma list_prod_right_tac_11520 (a : ℤ) (n : ℕ) (l' : List ℕ) (ih : (∀ n ∈ l', n ≠ 0) → J(a | l'.prod) = (List.map (fun n => J(a | n)) l').prod) (hl : ∀ n_1 ∈ n :: l', n_1 ≠ 0) (hn : n ≠ 0) (hl' : l'.prod ≠ 0) (h : ∀ m ∈ l', m ≠ 0) : J(a | n) * (List.map (fun n => J(a | n)) l').prod = J(a | n) * (List.map (fun n => J(a | n)) l').prod := sorry | lemma list_prod_right_tac_11520 (a : ℤ) (n : ℕ) (l' : List ℕ) (ih : (∀ n ∈ l', n ≠ 0) → J(a | l'.prod) = (List.map (fun n => J(a | n)) l').prod) (hl : ∀ n_1 ∈ n :: l', n_1 ≠ 0) (hn : n ≠ 0) (hl' : l'.prod ≠ 0) (h : ∀ m ∈ l', m ≠ 0) : J(a | n) * (List.map (fun n => J(a | n)) l').prod = J(a | n) * (List.map (fun n => J(a | n)) l').prod := sorry | tactic | null | ['Mathlib', 'NumberTheory', 'LegendreSymbol', 'JacobiSymbol'] | null | leanprover/lean4:v4.11.0
| Mathlib | ||||||||||
Equiv.equivCongr_trans_tac_14409 | import Init
import Mathlib.Data.FunLike.Equiv
import Mathlib.Data.Quot
import Mathlib.Data.Bool.Basic
import Mathlib.Logic.Unique
import Mathlib.Tactic.Substs
import Mathlib.Tactic.Conv
import Mathlib.Logic.Equiv.Defs
open Function
| import Init
import Mathlib.Data.FunLike.Equiv
import Mathlib.Data.Quot
import Mathlib.Data.Bool.Basic
import Mathlib.Logic.Unique
import Mathlib.Tactic.Substs
import Mathlib.Tactic.Conv
import Mathlib.Logic.Equiv.Defs
| open Function
| lemma equivCongr_trans_tac_14409 (α : Sort u) (β : Sort v) (γ : Sort w) (δ : Sort u_1) (ε : Sort u_2) (ζ : Sort u_3) (ab : α ≃ β) (de : δ ≃ ε) (bc : β ≃ γ) (ef : ε ≃ ζ) : (ab.equivCongr de).trans (bc.equivCongr ef) = (ab.trans bc).equivCongr (de.trans ef) := sorry | lemma equivCongr_trans_tac_14409 (α : Sort u) (β : Sort v) (γ : Sort w) (δ : Sort u_1) (ε : Sort u_2) (ζ : Sort u_3) (ab : α ≃ β) (de : δ ≃ ε) (bc : β ≃ γ) (ef : ε ≃ ζ) : (ab.equivCongr de).trans (bc.equivCongr ef) = (ab.trans bc).equivCongr (de.trans ef) := sorry | tactic | true | ['Mathlib', 'Logic', 'Equiv', 'Defs'] | null | leanprover/lean4:v4.11.0
| Mathlib | {"sorries":
[{"proofState": 0,
"pos": {"line": 11, "column": 259},
"goal":
"α : Sort u\nβ : Sort v\nγ : Sort w\nδ : Sort u_1\nε : Sort u_2\nζ : Sort u_3\nab : α ≃ β\nde : δ ≃ ε\nbc : β ≃ γ\nef : ε ≃ ζ\n⊢ (ab.equivCongr de).trans (bc.equivCongr ef) = (ab.trans bc).equivCongr (de.trans ef)",
"endPos": {"line": 11, "column": 264}}],
"messages":
[{"severity": "warning",
"pos": {"line": 11, "column": 6},
"endPos": {"line": 11, "column": 32},
"data": "declaration uses 'sorry'"}],
"env": 0}
|
|||||||||
Order.Ideal.instCompleteLattice_tac_13092 | import Init
import Mathlib.Logic.Encodable.Basic
import Mathlib.Order.Atoms
import Mathlib.Order.Chain
import Mathlib.Order.UpperLower.Basic
import Mathlib.Data.Set.Subsingleton
import Mathlib.Order.Ideal
open Function Set
| import Init
import Mathlib.Logic.Encodable.Basic
import Mathlib.Order.Atoms
import Mathlib.Order.Chain
import Mathlib.Order.UpperLower.Basic
import Mathlib.Data.Set.Subsingleton
import Mathlib.Order.Ideal
| open Function Set
| lemma instCompleteLattice_tac_13092 [SemilatticeSup P] [OrderBot P] (x : P) (I : Ideal P) (J : Ideal P) (K : Ideal P) (S : Set (Ideal P)) (s : Ideal P) (hs : s ∈ lowerBounds S) : ↑s ⊆ ⋂ s ∈ S, ↑s := sorry | lemma instCompleteLattice_tac_13092 {P : Type*} [SemilatticeSup P] [OrderBot P] (x : P) (I : Ideal P) (J : Ideal P) (K : Ideal P) (S✝ : Set (Ideal P)) (S : Set (Ideal P)) (s : Ideal P) (hs : s ∈ lowerBounds S) : ↑s ⊆ ⋂ s ∈ S, ↑s := sorry | [['subset_iInter₂_iff']] | tactic | false | ['Mathlib', 'Order', 'Ideal'] | null | leanprover/lean4:v4.11.0
| Mathlib | {"messages":
[{"severity": "error",
"pos": {"line": 10, "column": 81},
"endPos": {"line": 10, "column": 88},
"data": "function expected at\n Ideal\nterm has type\n ?m.248"},
{"severity": "error",
"pos": {"line": 10, "column": 95},
"endPos": {"line": 10, "column": 102},
"data": "function expected at\n Ideal\nterm has type\n ?m.248"},
{"severity": "error",
"pos": {"line": 10, "column": 109},
"endPos": {"line": 10, "column": 116},
"data": "function expected at\n Ideal\nterm has type\n ?m.248"},
{"severity": "error",
"pos": {"line": 10, "column": 128},
"endPos": {"line": 10, "column": 135},
"data": "function expected at\n Ideal\nterm has type\n ?m.248"},
{"severity": "error",
"pos": {"line": 10, "column": 143},
"endPos": {"line": 10, "column": 150},
"data": "function expected at\n Ideal\nterm has type\n ?m.248"}],
"env": 0}
|
||||||||
CategoryTheory.Limits.image.isoStrongEpiMono_hom_comp_ι_tac_34554 | import Init
import Mathlib.CategoryTheory.Limits.Shapes.Equalizers
import Mathlib.CategoryTheory.Limits.Shapes.Pullback.Mono
import Mathlib.CategoryTheory.Limits.Shapes.StrongEpi
import Mathlib.CategoryTheory.MorphismProperty.Factorization
import Mathlib.CategoryTheory.Limits.Shapes.Images
open CategoryTheory
open CategoryTheory.Limits.WalkingParallelPair
| import Init
import Mathlib.CategoryTheory.Limits.Shapes.Equalizers
import Mathlib.CategoryTheory.Limits.Shapes.Pullback.Mono
import Mathlib.CategoryTheory.Limits.Shapes.StrongEpi
import Mathlib.CategoryTheory.MorphismProperty.Factorization
import Mathlib.CategoryTheory.Limits.Shapes.Images
| open CategoryTheory
open CategoryTheory.Limits.WalkingParallelPair
| lemma isoStrongEpiMono_hom_comp_ι_tac_34554 [Category.{v, u} C] [HasStrongEpiMonoFactorisations C] (X : C) (Y : C) (f : X ⟶ Y) (I' : C) (e : X ⟶ I') (m : I' ⟶ Y) (comm : e ≫ m = f) [StrongEpi e] [Mono m] : (isoStrongEpiMono e m comm).hom ≫ ι f = m := sorry | lemma isoStrongEpiMono_hom_comp_ι_tac_34554 {C : Type*} [Category.{v, u} C] [HasStrongEpiMonoFactorisations C] (X : C) (Y : C) (f : X ⟶ Y) (I' : C) (e : X ⟶ I') (m : I' ⟶ Y) (comm : e ≫ m = f) [StrongEpi e] [Mono m] : (isoStrongEpiMono e m comm).hom ≫ ι f = m := sorry | [['isoStrongEpiMono']] | tactic | null | ['Mathlib', 'CategoryTheory', 'Limits', 'Shapes', 'Images'] | null | leanprover/lean4:v4.11.0
| Mathlib | |||||||||
CategoryTheory.IsFiltered.sup_exists_tac_10283 | import Init
import Mathlib.CategoryTheory.FinCategory.Basic
import Mathlib.CategoryTheory.Limits.Cones
import Mathlib.CategoryTheory.Limits.Shapes.FiniteLimits
import Mathlib.CategoryTheory.Adjunction.Basic
import Mathlib.CategoryTheory.Category.Preorder
import Mathlib.CategoryTheory.Category.ULift
import Mathlib.CategoryTheory.PEmpty
import Mathlib.CategoryTheory.Filtered.Basic
open Function
open IsFiltered
open CategoryTheory.Limits
| import Init
import Mathlib.CategoryTheory.FinCategory.Basic
import Mathlib.CategoryTheory.Limits.Cones
import Mathlib.CategoryTheory.Limits.Shapes.FiniteLimits
import Mathlib.CategoryTheory.Adjunction.Basic
import Mathlib.CategoryTheory.Category.Preorder
import Mathlib.CategoryTheory.Category.ULift
import Mathlib.CategoryTheory.PEmpty
import Mathlib.CategoryTheory.Filtered.Basic
| open Function
open IsFiltered
open CategoryTheory.Limits
| lemma sup_exists_tac_10283 [Category.{v, u} C] [IsFiltered C] (O : Finset C) (H : Finset ((X : C) ×' (Y : C) ×' (_ : X ∈ O) ×' (_ : Y ∈ O) ×' (X ⟶ Y))) (S : C) (f : ∀ {X : C}, X ∈ O → Nonempty (X ⟶ S)) : ∀ {X Y : C} (mX : X ∈ O) (mY : Y ∈ O) {f_1 : X ⟶ Y},
⟨X, ⟨Y, ⟨mX, ⟨mY, f_1⟩⟩⟩⟩ ∈ ∅ → f_1 ≫ (fun {X} mX => ⋯.some) mY = (fun {X} mX => ⋯.some) mX := sorry | lemma sup_exists_tac_10283 {C : Type*} [Category.{v, u} C] [IsFiltered C] (O : Finset C) (H : Finset ((X : C) ×' (Y : C) ×' (_ : X ∈ O) ×' (_ : Y ∈ O) ×' (X ⟶ Y))) (S : C) (f : ∀ {X : C}, X ∈ O → Nonempty (X ⟶ S)) : ∀ {X Y : C} (mX : X ∈ O) (mY : Y ∈ O) {f_1 : X ⟶ Y},
⟨X, ⟨Y, ⟨mX, ⟨mY, f_1⟩⟩⟩⟩ ∈ ∅ → f_1 ≫ (fun {X} mX => ⋯.some) mY = (fun {X} mX => ⋯.some) mX := sorry | tactic | null | ['Mathlib', 'CategoryTheory', 'Filtered', 'Basic'] | null | leanprover/lean4:v4.11.0
| Mathlib | ||||||||||
ONote.fundamentalSequence_has_prop_tac_41262 | import Init
import Mathlib.Algebra.Ring.Divisibility.Basic
import Mathlib.Data.Ordering.Lemmas
import Mathlib.SetTheory.Ordinal.Principal
import Mathlib.Tactic.NormNum
import Mathlib.Data.PNat.Basic
import Mathlib.SetTheory.Ordinal.Notation
open Ordinal Order
open Lean in
| import Init
import Mathlib.Algebra.Ring.Divisibility.Basic
import Mathlib.Data.Ordering.Lemmas
import Mathlib.SetTheory.Ordinal.Principal
import Mathlib.Tactic.NormNum
import Mathlib.Data.PNat.Basic
import Mathlib.SetTheory.Ordinal.Notation
| open Ordinal Order
open Lean in
| lemma fundamentalSequence_has_prop_tac_41262 (a : ONote) (m : ℕ+) (b : ONote) (ihb : b = 0) (f : ℕ → ONote) (iha : a.repr.IsLimit ∧ (∀ (i : ℕ), f i < f (i + 1) ∧ f i < a ∧ (a.NF → (f i).NF)) ∧ ∀ a_1 < a.repr, ∃ i, a_1 < (f i).repr) (e : a.fundamentalSequence = Sum.inr f) (e' : m.natPred = 0) : (a.oadd 1 b).repr.IsLimit ∧
(∀ (i : ℕ),
(f i).oadd 1 zero < (f (i + 1)).oadd 1 zero ∧
(f i).oadd 1 zero < a.oadd 1 b ∧ ((a.oadd 1 b).NF → ((f i).oadd 1 zero).NF)) ∧
∀ a_1 < (a.oadd 1 b).repr, ∃ i, a_1 < ((f i).oadd 1 zero).repr := sorry | lemma fundamentalSequence_has_prop_tac_41262 (a : ONote) (m : ℕ+) (b : ONote) (ihb : b = 0) (e✝ : b.fundamentalSequence = Sum.inl none) (f : ℕ → ONote) (iha : a.repr.IsLimit ∧ (∀ (i : ℕ), f i < f (i + 1) ∧ f i < a ∧ (a.NF → (f i).NF)) ∧ ∀ a_1 < a.repr, ∃ i, a_1 < (f i).repr) (e : a.fundamentalSequence = Sum.inr f) (e' : m.natPred = 0) : (a.oadd 1 b).repr.IsLimit ∧
(∀ (i : ℕ),
(f i).oadd 1 zero < (f (i + 1)).oadd 1 zero ∧
(f i).oadd 1 zero < a.oadd 1 b ∧ ((a.oadd 1 b).NF → ((f i).oadd 1 zero).NF)) ∧
∀ a_1 < (a.oadd 1 b).repr, ∃ i, a_1 < ((f i).oadd 1 zero).repr := sorry | [['succPNat'], ['m'], ['PNat', 'natPred_add_one'], ['PNat', 'coe_inj'], ["m'"], ["e'"], ['Nat', 'succPNat_coe'], ['Nat', 'add_one']] | tactic | null | ['Mathlib', 'SetTheory', 'Ordinal', 'Notation'] | null | leanprover/lean4:v4.11.0
| Mathlib | |||||||||
Nat.Prime.pow_dvd_factorial_iff_tac_7650 | import Init
import Mathlib.Algebra.BigOperators.Intervals
import Mathlib.Algebra.GeomSum
import Mathlib.Algebra.Order.Ring.Abs
import Mathlib.Data.Nat.Bitwise
import Mathlib.Data.Nat.Log
import Mathlib.Data.Nat.Prime.Defs
import Mathlib.Data.Nat.Digits
import Mathlib.RingTheory.Multiplicity
import Mathlib.Data.Nat.Multiplicity
open Finset Nat multiplicity
open Nat
| import Init
import Mathlib.Algebra.BigOperators.Intervals
import Mathlib.Algebra.GeomSum
import Mathlib.Algebra.Order.Ring.Abs
import Mathlib.Data.Nat.Bitwise
import Mathlib.Data.Nat.Log
import Mathlib.Data.Nat.Prime.Defs
import Mathlib.Data.Nat.Digits
import Mathlib.RingTheory.Multiplicity
import Mathlib.Data.Nat.Multiplicity
| open Finset Nat multiplicity
open Nat
| lemma pow_dvd_factorial_iff_tac_7650 (p : ℕ) (n : ℕ) (r : ℕ) (b : ℕ) (hp : Prime p) (hbn : log p n < b) : p ^ r ∣ n ! ↔ r ≤ ∑ i ∈ Ico 1 b, n / p ^ i := sorry | lemma pow_dvd_factorial_iff_tac_7650 (p : ℕ) (n : ℕ) (r : ℕ) (b : ℕ) (hp : Prime p) (hbn : log p n < b) : p ^ r ∣ n ! ↔ r ≤ ∑ i ∈ Ico 1 b, n / p ^ i := sorry | [['hp', 'multiplicity_factorial'], ['hbn'], ['PartENat', 'coe_le_coe'], ['pow_dvd_iff_le_multiplicity']] | tactic | false | ['Mathlib', 'Data', 'Nat', 'Multiplicity'] | null | leanprover/lean4:v4.11.0
| Mathlib | {"sorries":
[{"proofState": 0,
"pos": {"line": 14, "column": 152},
"goal":
"p n r b : ℕ\nhp : sorryAx Prop true\nhbn : log p n < b\n⊢ p ^ r ∣ n ! ↔ r ≤ ∑ i ∈ Ico 1 b, n / p ^ i",
"endPos": {"line": 14, "column": 157}}],
"messages":
[{"severity": "error",
"pos": {"line": 14, "column": 75},
"endPos": {"line": 14, "column": 80},
"data":
"ambiguous, possible interpretations \n _root_.Prime p : Prop\n \n Nat.Prime p : Prop"}],
"env": 0}
|
||||||||
Subgroup.sup_eq_closure_mul_tac_7967 | import Init
import Mathlib.Algebra.Group.Subgroup.MulOpposite
import Mathlib.Algebra.Group.Submonoid.Pointwise
import Mathlib.GroupTheory.GroupAction.ConjAct
import Mathlib.Algebra.Group.Subgroup.Pointwise
open Set
open Pointwise
| import Init
import Mathlib.Algebra.Group.Subgroup.MulOpposite
import Mathlib.Algebra.Group.Submonoid.Pointwise
import Mathlib.GroupTheory.GroupAction.ConjAct
import Mathlib.Algebra.Group.Subgroup.Pointwise
| open Set
open Pointwise
| lemma sup_eq_closure_mul_tac_7967 [Group G] (H : Subgroup G) (K : Subgroup G) : closure ↑H ⊔ closure ↑K ≤ H ⊔ K := sorry | lemma sup_eq_closure_mul_tac_7967 {G : Type*} [Group G] (H : Subgroup G) (K : Subgroup G) : closure ↑H ⊔ closure ↑K ≤ H ⊔ K := sorry | [['closure_eq']] | tactic | false | ['Mathlib', 'Algebra', 'Group', 'Subgroup', 'Pointwise'] | null | leanprover/lean4:v4.11.0
| Mathlib | {"sorries":
[{"proofState": 0,
"pos": {"line": 9, "column": 115},
"goal":
"G : Type u_1\nx✝ : Sort u_2\nclosure : x✝\ninst✝ : Group G\nH K : Subgroup G\n⊢ sorryAx (Subgroup G) true ⊔ sorryAx (Subgroup G) true ≤ H ⊔ K",
"endPos": {"line": 9, "column": 120}}],
"messages":
[{"severity": "error",
"pos": {"line": 9, "column": 80},
"endPos": {"line": 9, "column": 90},
"data": "function expected at\n closure\nterm has type\n ?m.26"},
{"severity": "error",
"pos": {"line": 9, "column": 93},
"endPos": {"line": 9, "column": 103},
"data": "function expected at\n closure\nterm has type\n ?m.26"}],
"env": 0}
|
||||||||
PEquiv.toMatrix_swap_tac_4821 | import Init
import Mathlib.Data.Matrix.Basic
import Mathlib.Data.PEquiv
import Mathlib.Data.Matrix.PEquiv
open Matrix
open Matrix
| import Init
import Mathlib.Data.Matrix.Basic
import Mathlib.Data.PEquiv
import Mathlib.Data.Matrix.PEquiv
| open Matrix
open Matrix
| lemma toMatrix_swap_tac_4821 [DecidableEq n] [Ring α] (i : n) (j : n) : 0 =
((1 - if j✝ ∈ some i then 1 else 0) - if j✝ ∈ if i✝ = j then some j else none then 1 else 0) + 0 +
if j✝ ∈ if i✝ = j then some i else none then 1 else 0 := sorry | lemma toMatrix_swap_tac_4821 {n : Type*} {α : Type*} [DecidableEq n] [Ring α] (i : n) (j : n) (i✝ : n) (j✝ : n) (h✝² : i✝ = i) (h✝¹ : j✝ ∉ some j) (h✝ : i✝ = j✝) : 0 =
((1 - if j✝ ∈ some i then 1 else 0) - if j✝ ∈ if i✝ = j then some j else none then 1 else 0) + 0 +
if j✝ ∈ if i✝ = j then some i else none then 1 else 0 := sorry | [['m', '_@', '_hyg', 1461], ['Classical', '_@', '_hyg', 1463], ['h', '_@', '_hyg', 1460], ['neg', '_@', '_hyg', 1463], ['pos', '_@', '_hyg', 1463]] | tactic | false | ['Mathlib', 'Data', 'Matrix', 'PEquiv'] | null | leanprover/lean4:v4.11.0
| Mathlib | {"messages":
[{"severity": "error",
"pos": {"line": 9, "column": 12},
"endPos": null,
"data": "expected token"}],
"env": 0}
|
||||||||
IsSubmonoid.list_prod_mem_tac_9101 | import Init
import Mathlib.Algebra.BigOperators.Group.Finset
import Mathlib.Algebra.Group.Submonoid.Basic
import Mathlib.Deprecated.Group
import Mathlib.Deprecated.Submonoid
| import Init
import Mathlib.Algebra.BigOperators.Group.Finset
import Mathlib.Algebra.Group.Submonoid.Basic
import Mathlib.Deprecated.Group
import Mathlib.Deprecated.Submonoid
| lemma list_prod_mem_tac_9101 [Monoid M] (s : Set M) (hs : IsSubmonoid s) (a : M) (l : List M) (h : ∀ x ∈ a :: l, x ∈ s) : a ∈ s ∧ ∀ x ∈ l, x ∈ s := sorry | lemma list_prod_mem_tac_9101 {M : Type*} [Monoid M] (s : Set M) (hs : IsSubmonoid s) (a : M) (l : List M) (h : ∀ x ∈ a :: l, x ∈ s) : a ∈ s ∧ ∀ x ∈ l, x ∈ s := sorry | [['h']] | tactic | true | ['Mathlib', 'Deprecated', 'Submonoid'] | null | leanprover/lean4:v4.11.0
| Mathlib | {"sorries":
[{"proofState": 0,
"pos": {"line": 8, "column": 148},
"goal":
"M : Type u_1\ninst✝ : Monoid M\ns : Set M\nhs : IsSubmonoid s\na : M\nl : List M\nh : ∀ x ∈ a :: l, x ∈ s\n⊢ a ∈ s ∧ ∀ x ∈ l, x ∈ s",
"endPos": {"line": 8, "column": 153}}],
"messages":
[{"severity": "warning",
"pos": {"line": 8, "column": 6},
"endPos": {"line": 8, "column": 28},
"data": "declaration uses 'sorry'"}],
"env": 0}
|
|||||||||
hasDerivAt_ofReal_cpow_tac_11485 | import Init
import Mathlib.Analysis.SpecialFunctions.Pow.Continuity
import Mathlib.Analysis.SpecialFunctions.Complex.LogDeriv
import Mathlib.Analysis.Calculus.FDeriv.Extend
import Mathlib.Analysis.Calculus.Deriv.Prod
import Mathlib.Analysis.SpecialFunctions.Log.Deriv
import Mathlib.Analysis.SpecialFunctions.Trigonometric.Deriv
import Mathlib.Analysis.SpecialFunctions.Pow.Deriv
open scoped Real Topology NNReal ENNReal
open Filter
open Complex
open Complex
| import Init
import Mathlib.Analysis.SpecialFunctions.Pow.Continuity
import Mathlib.Analysis.SpecialFunctions.Complex.LogDeriv
import Mathlib.Analysis.Calculus.FDeriv.Extend
import Mathlib.Analysis.Calculus.Deriv.Prod
import Mathlib.Analysis.SpecialFunctions.Log.Deriv
import Mathlib.Analysis.SpecialFunctions.Trigonometric.Deriv
import Mathlib.Analysis.SpecialFunctions.Pow.Deriv
| open scoped Real Topology NNReal ENNReal
open Filter
open Complex
open Complex
| lemma hasDerivAt_ofReal_cpow_tac_11485 (x : ℝ) (r : ℂ) (hr : r + 1 ≠ 0) (hx : 0 > x) (this : ∀ᶠ (y : ℝ) in 𝓝 x, ↑y ^ (r + 1) / (r + 1) = (-↑y) ^ (r + 1) * cexp (↑π * I * (r + 1)) / (r + 1)) : HasDerivAt (fun y => (-↑y) ^ (r + 1) * cexp (↑π * I * (r + 1))) ((r + 1) * (-↑x) ^ r * cexp (↑π * I * r)) x := sorry | lemma hasDerivAt_ofReal_cpow_tac_11485 (x : ℝ) (hx✝ : x ≠ 0) (r : ℂ) (hr : r + 1 ≠ 0) (hx : 0 > x) (this : ∀ᶠ (y : ℝ) in 𝓝 x, ↑y ^ (r + 1) / (r + 1) = (-↑y) ^ (r + 1) * cexp (↑π * I * (r + 1)) / (r + 1)) : HasDerivAt (fun y => (-↑y) ^ (r + 1) * cexp (↑π * I * (r + 1))) ((r + 1) * (-↑x) ^ r * cexp (↑π * I * r)) x := sorry | [['mul_comm'], ['mul_add'], ['exp_add'], ['neg_one_mul'], ['mul_one'], ['exp_pi_mul_I']] | tactic | true | ['Mathlib', 'Analysis', 'SpecialFunctions', 'Pow', 'Deriv'] | null | leanprover/lean4:v4.11.0
| Mathlib | {"sorries":
[{"proofState": 0,
"pos": {"line": 14, "column": 303},
"goal":
"x : ℝ\nr : ℂ\nhr : r + 1 ≠ 0\nhx : 0 > x\nthis : ∀ᶠ (y : ℝ) in 𝓝 x, ↑y ^ (r + 1) / (r + 1) = (-↑y) ^ (r + 1) * cexp (↑π * I * (r + 1)) / (r + 1)\n⊢ HasDerivAt (fun y => (-y) ^ (r + 1) * cexp (↑π * I * (r + 1))) ((r + 1) * (-↑x) ^ r * cexp (↑π * I * r)) ↑x",
"endPos": {"line": 14, "column": 308}}],
"messages":
[{"severity": "warning",
"pos": {"line": 14, "column": 6},
"endPos": {"line": 14, "column": 38},
"data": "declaration uses 'sorry'"}],
"env": 0}
|
||||||||
Commute.add_pow_tac_1960 | import Init
import Mathlib.Algebra.BigOperators.Intervals
import Mathlib.Algebra.BigOperators.NatAntidiagonal
import Mathlib.Algebra.BigOperators.Ring
import Mathlib.Algebra.Order.BigOperators.Group.Finset
import Mathlib.Data.Nat.Choose.Basic
import Mathlib.Tactic.Linarith
import Mathlib.Tactic.Ring
import Mathlib.Data.Nat.Choose.Sum
open Nat Finset
| import Init
import Mathlib.Algebra.BigOperators.Intervals
import Mathlib.Algebra.BigOperators.NatAntidiagonal
import Mathlib.Algebra.BigOperators.Ring
import Mathlib.Algebra.Order.BigOperators.Group.Finset
import Mathlib.Data.Nat.Choose.Basic
import Mathlib.Tactic.Linarith
import Mathlib.Tactic.Ring
import Mathlib.Data.Nat.Choose.Sum
| open Nat Finset
| lemma add_pow_tac_1960 [Semiring R] (x : R) (y : R) (h : Commute x y) (t : ℕ → ℕ → R) (h_first : ∀ (n : ℕ), t n 0 = y ^ n) (h_last : ∀ (n : ℕ), t n n.succ = 0) (n : ℕ) (i : ℕ) (h_mem : i ∈ range n.succ) (h_le : i ≤ n) (h_eq : ¬i = n) : x ^ i.succ * (y * (y ^ (n - i.succ) * ↑(n.choose i.succ))) = x ^ i.succ * (y * (y ^ (n - i.succ) * ↑(n.choose i.succ))) := sorry | lemma add_pow_tac_1960 {R : Type*} [Semiring R] (x : R) (y : R) (h : Commute x y) (n✝ : ℕ) (t : ℕ → ℕ → R) (h_first : ∀ (n : ℕ), t n 0 = y ^ n) (h_last : ∀ (n : ℕ), t n n.succ = 0) (n : ℕ) (i : ℕ) (h_mem : i ∈ range n.succ) (h_le : i ≤ n) (h_eq : ¬i = n) : x ^ i.succ * (y * (y ^ (n - i.succ) * ↑(n.choose i.succ))) = x ^ i.succ * (y * (y ^ (n - i.succ) * ↑(n.choose i.succ))) := sorry | tactic | true | ['Mathlib', 'Data', 'Nat', 'Choose', 'Sum'] | null | leanprover/lean4:v4.11.0
| Mathlib | {"sorries":
[{"proofState": 0,
"pos": {"line": 12, "column": 359},
"goal":
"R : Type u_1\ninst✝ : Semiring R\nx y : R\nh : Commute x y\nt : ℕ → ℕ → R\nh_first : ∀ (n : ℕ), t n 0 = y ^ n\nh_last : ∀ (n : ℕ), t n n.succ = 0\nn i : ℕ\nh_mem : i ∈ range n.succ\nh_le : i ≤ n\nh_eq : ¬i = n\n⊢ x ^ i.succ * (y * (y ^ (n - i.succ) * ↑(n.choose i.succ))) =\n x ^ i.succ * (y * (y ^ (n - i.succ) * ↑(n.choose i.succ)))",
"endPos": {"line": 12, "column": 364}}],
"messages":
[{"severity": "warning",
"pos": {"line": 12, "column": 6},
"endPos": {"line": 12, "column": 22},
"data": "declaration uses 'sorry'"}],
"env": 0}
|
|||||||||
_private.0.Complex.Gamma_integrand_intervalIntegrable_tac_6748 | import Init
import Mathlib.MeasureTheory.Integral.ExpDecay
import Mathlib.Analysis.MellinTransform
import Mathlib.Analysis.SpecialFunctions.Gamma.Basic
open Filter intervalIntegral Set Real MeasureTheory Asymptotics
open scoped Nat Topology ComplexConjugate
| import Init
import Mathlib.MeasureTheory.Integral.ExpDecay
import Mathlib.Analysis.MellinTransform
import Mathlib.Analysis.SpecialFunctions.Gamma.Basic
| open Filter intervalIntegral Set Real MeasureTheory Asymptotics
open scoped Nat Topology ComplexConjugate
| lemma Gamma_integrand_intervalIntegrable_tac_6748 (s : ℂ) (X : ℝ) (hs : 0 < s.re) (hX : 0 ≤ X) : IntegrableOn (fun x => ↑(rexp (-x)) * ↑x ^ (s - 1)) (Ioc 0 X) volume := sorry | lemma Gamma_integrand_intervalIntegrable_tac_6748 (s : ℂ) (X : ℝ) (hs : 0 < s.re) (hX : 0 ≤ X) : IntegrableOn (fun x => ↑(rexp (-x)) * ↑x ^ (s - 1)) (Ioc 0 X) volume := sorry | tactic | false | ['Mathlib', 'Analysis', 'SpecialFunctions', 'Gamma', 'Basic'] | null | leanprover/lean4:v4.11.0
| Mathlib | {"sorries":
[{"proofState": 0,
"pos": {"line": 8, "column": 169},
"goal":
"s : ℂ\nX : ℝ\nhs : 0 < s.re\nhX : 0 ≤ X\n⊢ IntegrableOn (fun x => rexp (-x) * x ^ (s - 1)) (Ioc 0 X) volume",
"endPos": {"line": 8, "column": 174}}],
"messages":
[{"severity": "error",
"pos": {"line": 8, "column": 135},
"endPos": {"line": 8, "column": 147},
"data":
"failed to synthesize\n HPow ℝ ℂ (?m.347 x)\nAdditional diagnostic information may be available using the `set_option diagnostics true` command."}],
"env": 0}
|
|||||||||
CoxeterSystem.length_mul_le_tac_3760 | import Init
import Mathlib.Data.ZMod.Basic
import Mathlib.GroupTheory.Coxeter.Basic
import Mathlib.Tactic.Zify
import Mathlib.GroupTheory.Coxeter.Length
open List Matrix Function Classical
| import Init
import Mathlib.Data.ZMod.Basic
import Mathlib.GroupTheory.Coxeter.Basic
import Mathlib.Tactic.Zify
import Mathlib.GroupTheory.Coxeter.Length
| open List Matrix Function Classical
| lemma length_mul_le_tac_3760 [Group W] (M : CoxeterMatrix B) (cs : CoxeterSystem M W) (w₁ : W) (w₂ : W) : cs.length (w₁ * w₂) ≤ cs.length w₁ + cs.length w₂ := sorry | lemma length_mul_le_tac_3760 {B : Type*} {W : Type*} [Group W] (M : CoxeterMatrix B) (cs : CoxeterSystem M W) (w₁ : W) (w₂ : W) : cs.length (w₁ * w₂) ≤ cs.length w₁ + cs.length w₂ := sorry | [['hω₂'], ['cs', 'length_wordProd_le'], ['w₂'], ['this'], ['wordProd_append'], ['hω₁'], [], ['ω₂'], ['w₁'], ['rfl'], ['ω₁'], ['cs', 'exists_reduced_word']] | tactic | true | ['Mathlib', 'GroupTheory', 'Coxeter', 'Length'] | null | leanprover/lean4:v4.11.0
| Mathlib | {"sorries":
[{"proofState": 0,
"pos": {"line": 8, "column": 159},
"goal":
"W : Type u_1\nB : Type u_2\ninst✝ : Group W\nM : CoxeterMatrix B\ncs : CoxeterSystem M W\nw₁ w₂ : W\n⊢ cs.length (w₁ * w₂) ≤ cs.length w₁ + cs.length w₂",
"endPos": {"line": 8, "column": 164}}],
"messages":
[{"severity": "warning",
"pos": {"line": 8, "column": 6},
"endPos": {"line": 8, "column": 28},
"data": "declaration uses 'sorry'"}],
"env": 0}
|
||||||||
Complex.I_mul_re_tac_6641 | import Init
import Mathlib.Algebra.CharZero.Lemmas
import Mathlib.Algebra.GroupWithZero.Divisibility
import Mathlib.Algebra.Star.Basic
import Mathlib.Data.Real.Basic
import Mathlib.Data.Set.Image
import Mathlib.Tactic.Ring
import Mathlib.Data.Complex.Basic
open Set Function
open ComplexConjugate
| import Init
import Mathlib.Algebra.CharZero.Lemmas
import Mathlib.Algebra.GroupWithZero.Divisibility
import Mathlib.Algebra.Star.Basic
import Mathlib.Data.Real.Basic
import Mathlib.Data.Set.Image
import Mathlib.Tactic.Ring
import Mathlib.Data.Complex.Basic
| open Set Function
open ComplexConjugate
| lemma I_mul_re_tac_6641 (z : ℂ) : (I * z).re = -z.im := sorry | lemma I_mul_re_tac_6641 (z : ℂ) : (I * z).re = -z.im := sorry | tactic | true | ['Mathlib', 'Data', 'Complex', 'Basic'] | null | leanprover/lean4:v4.11.0
| Mathlib | {"sorries":
[{"proofState": 0,
"pos": {"line": 12, "column": 56},
"goal": "I z : ℂ\n⊢ (I * z).re = -z.im",
"endPos": {"line": 12, "column": 61}}],
"messages":
[{"severity": "warning",
"pos": {"line": 12, "column": 6},
"endPos": {"line": 12, "column": 23},
"data": "declaration uses 'sorry'"}],
"env": 0}
|
|||||||||
Nat.sqrt_eq_zero_tac_5777 | import Init
import Mathlib.Data.Nat.Defs
import Batteries.Data.Nat.Basic
import Mathlib.Data.Nat.Sqrt
| import Init
import Mathlib.Data.Nat.Defs
import Batteries.Data.Nat.Basic
import Mathlib.Data.Nat.Sqrt
| lemma sqrt_eq_zero_tac_5777 (n : ℕ) (h : n.sqrt = 0) : 0 < 1 := sorry | lemma sqrt_eq_zero_tac_5777 (n : ℕ) (h : n.sqrt = 0) : 0 < 1 := sorry | tactic | true | ['Mathlib', 'Data', 'Nat', 'Sqrt'] | null | leanprover/lean4:v4.11.0
| Mathlib | {"sorries":
[{"proofState": 0,
"pos": {"line": 7, "column": 64},
"goal": "n : ℕ\nh : n.sqrt = 0\n⊢ 0 < 1",
"endPos": {"line": 7, "column": 69}}],
"messages":
[{"severity": "warning",
"pos": {"line": 7, "column": 6},
"endPos": {"line": 7, "column": 27},
"data": "declaration uses 'sorry'"}],
"env": 0}
|
||||||||||
not_differentiableWithinAt_of_deriv_tendsto_atTop_Ioi_tac_46199 | import Init
import Mathlib.Analysis.Calculus.Deriv.AffineMap
import Mathlib.Analysis.Calculus.Deriv.Slope
import Mathlib.Analysis.Calculus.Deriv.Mul
import Mathlib.Analysis.Calculus.Deriv.Comp
import Mathlib.Analysis.Calculus.LocalExtr.Rolle
import Mathlib.Analysis.Convex.Normed
import Mathlib.Analysis.RCLike.Basic
import Mathlib.Analysis.Calculus.MeanValue
open Metric Set Asymptotics ContinuousLinearMap Filter
open scoped Topology NNReal
| import Init
import Mathlib.Analysis.Calculus.Deriv.AffineMap
import Mathlib.Analysis.Calculus.Deriv.Slope
import Mathlib.Analysis.Calculus.Deriv.Mul
import Mathlib.Analysis.Calculus.Deriv.Comp
import Mathlib.Analysis.Calculus.LocalExtr.Rolle
import Mathlib.Analysis.Convex.Normed
import Mathlib.Analysis.RCLike.Basic
import Mathlib.Analysis.Calculus.MeanValue
| open Metric Set Asymptotics ContinuousLinearMap Filter
open scoped Topology NNReal
| lemma not_differentiableWithinAt_of_deriv_tendsto_atTop_Ioi_tac_46199 (f : ℝ → ℝ) (a : ℝ) (hf : Tendsto (derivWithin f (Ioi a)) (𝓝[>] a) atTop) (hcont_at_a : ContinuousWithinAt f (Ici a) a) (hdiff : Tendsto (slope f a) (𝓝[>] a) (𝓝 (derivWithin f (Ioi a) a))) (h₀ : ∀ᶠ (b : ℝ) in 𝓝[>] a, ∀ x ∈ Ioc a b, max (derivWithin f (Ioi a) a + 1) 0 < derivWithin f (Ioi a) x) (h₁ : ∀ᶠ (b : ℝ) in 𝓝[>] a, slope f a b < derivWithin f (Ioi a) a + 1) (b : ℝ) (hb : ∀ x ∈ Ioc a b, max (derivWithin f (Ioi a) a + 1) 0 < derivWithin f (Ioi a) x) (hslope : slope f a b < derivWithin f (Ioi a) a + 1) (hab : a < b) (hdiff' : DifferentiableOn ℝ f (Ioc a b)) (z : ℝ) (hz'' : z ∈ Ioc a b) : 𝓝[Ioc a b] z = 𝓝[Icc a b] z := sorry | lemma not_differentiableWithinAt_of_deriv_tendsto_atTop_Ioi_tac_46199 (f : ℝ → ℝ) (a : ℝ) (hf : Tendsto (derivWithin f (Ioi a)) (𝓝[>] a) atTop) (hcont_at_a : ContinuousWithinAt f (Ici a) a) (hdiff : Tendsto (slope f a) (𝓝[>] a) (𝓝 (derivWithin f (Ioi a) a))) (h₀ : ∀ᶠ (b : ℝ) in 𝓝[>] a, ∀ x ∈ Ioc a b, max (derivWithin f (Ioi a) a + 1) 0 < derivWithin f (Ioi a) x) (h₁ : ∀ᶠ (b : ℝ) in 𝓝[>] a, slope f a b < derivWithin f (Ioi a) a + 1) (b : ℝ) (hb : ∀ x ∈ Ioc a b, max (derivWithin f (Ioi a) a + 1) 0 < derivWithin f (Ioi a) x) (hslope : slope f a b < derivWithin f (Ioi a) a + 1) (hab : a < b) (hdiff' : DifferentiableOn ℝ f (Ioc a b)) (z : ℝ) (hz'' : z ∈ Ioc a b) : 𝓝[Ioc a b] z = 𝓝[Icc a b] z := sorry | [['h'], ["hz''"], ["nhdsWithin_eq_nhdsWithin'"], ['Ioi_mem_nhds'], ['mem_Icc_of_Ioc'], ['Ioi'], ['mem_of_mem_inter_left'], ['sup_of_le_left'], ['le_refl'], ['a'], ['y'], ['s'], ['H2'], ['H1'], ['Ioc_inter_Ioi']] | tactic | null | ['Mathlib', 'Analysis', 'Calculus', 'MeanValue'] | null | leanprover/lean4:v4.11.0
| Mathlib | |||||||||
MeasureTheory.integrableOn_Ioi_deriv_of_nonneg_tac_41386 | import Init
import Mathlib.Analysis.Calculus.Deriv.Support
import Mathlib.Analysis.SpecialFunctions.Pow.Deriv
import Mathlib.MeasureTheory.Integral.FundThmCalculus
import Mathlib.Order.Filter.AtTopBot
import Mathlib.MeasureTheory.Function.Jacobian
import Mathlib.MeasureTheory.Measure.Haar.NormedSpace
import Mathlib.MeasureTheory.Measure.Haar.Unique
import Mathlib.MeasureTheory.Integral.IntegralEqImproper
open MeasureTheory Filter Set TopologicalSpace
open scoped ENNReal NNReal Topology
open Real
open scoped Interval
open UniformSpace in
| import Init
import Mathlib.Analysis.Calculus.Deriv.Support
import Mathlib.Analysis.SpecialFunctions.Pow.Deriv
import Mathlib.MeasureTheory.Integral.FundThmCalculus
import Mathlib.Order.Filter.AtTopBot
import Mathlib.MeasureTheory.Function.Jacobian
import Mathlib.MeasureTheory.Measure.Haar.NormedSpace
import Mathlib.MeasureTheory.Measure.Haar.Unique
import Mathlib.MeasureTheory.Integral.IntegralEqImproper
| open MeasureTheory Filter Set TopologicalSpace
open scoped ENNReal NNReal Topology
open Real
open scoped Interval
open UniformSpace in
| lemma integrableOn_Ioi_deriv_of_nonneg_tac_41386 (g : ℝ → ℝ) (g' : ℝ → ℝ) (a : ℝ) (l : ℝ) (hcont : ContinuousWithinAt g (Ici a) a) (hderiv : ∀ x ∈ Ioi a, HasDerivAt g (g' x) x) (g'pos : ∀ x ∈ Ioi a, 0 ≤ g' x) (hg : Tendsto g atTop (𝓝 l)) : ContinuousOn g (Ici a) := sorry | lemma integrableOn_Ioi_deriv_of_nonneg_tac_41386 (g : ℝ → ℝ) (g' : ℝ → ℝ) (a : ℝ) (l : ℝ) (hcont : ContinuousWithinAt g (Ici a) a) (hderiv : ∀ x ∈ Ioi a, HasDerivAt g (g' x) x) (g'pos : ∀ x ∈ Ioi a, 0 ≤ g' x) (hg : Tendsto g atTop (𝓝 l)) : ContinuousOn g (Ici a) := sorry | [['hcont'], ['x'], ['hx', 'out', 'eq_or_lt'], ['hderiv'], ['hx'], ['body', '_@', '_hyg', 11370], ['continuousAt', 'continuousWithinAt'], ['rfl']] | tactic | null | ['Mathlib', 'MeasureTheory', 'Integral', 'IntegralEqImproper'] | null | leanprover/lean4:v4.11.0
| Mathlib | |||||||||
pow_dvd_pow_iff_tac_5611 | import Init
import Mathlib.Algebra.GroupWithZero.Units.Basic
import Mathlib.Algebra.Divisibility.Units
import Mathlib.Algebra.GroupWithZero.Divisibility
| import Init
import Mathlib.Algebra.GroupWithZero.Units.Basic
import Mathlib.Algebra.Divisibility.Units
import Mathlib.Algebra.GroupWithZero.Divisibility
| lemma pow_dvd_pow_iff_tac_5611 [CancelCommMonoidWithZero α] (a : α) (m : ℕ) (n : ℕ) (ha₀ : a ≠ 0) (ha : ¬IsUnit a) (h : a ^ n ∣ a ^ m) : ¬m < n := sorry | lemma pow_dvd_pow_iff_tac_5611 {α : Type*} [CancelCommMonoidWithZero α] (a : α) (m : ℕ) (n : ℕ) (ha₀ : a ≠ 0) (ha : ¬IsUnit a) (h : a ^ n ∣ a ^ m) : ¬m < n := sorry | tactic | true | ['Mathlib', 'Algebra', 'GroupWithZero', 'Divisibility'] | null | leanprover/lean4:v4.11.0
| Mathlib | {"sorries":
[{"proofState": 0,
"pos": {"line": 7, "column": 147},
"goal":
"α : Type u_1\ninst✝ : CancelCommMonoidWithZero α\na : α\nm n : ℕ\nha₀ : a ≠ 0\nha : ¬IsUnit a\nh : a ^ n ∣ a ^ m\n⊢ ¬m < n",
"endPos": {"line": 7, "column": 152}}],
"messages":
[{"severity": "warning",
"pos": {"line": 7, "column": 6},
"endPos": {"line": 7, "column": 30},
"data": "declaration uses 'sorry'"}],
"env": 0}
|
||||||||||
CategoryTheory.CosimplicialObject.δ_comp_δ_self'_tac_15091 | import Init
import Mathlib.AlgebraicTopology.SimplexCategory
import Mathlib.CategoryTheory.Comma.Arrow
import Mathlib.CategoryTheory.Limits.FunctorCategory.Basic
import Mathlib.CategoryTheory.Opposites
import Mathlib.AlgebraicTopology.SimplicialObject
open Opposite
open CategoryTheory
open CategoryTheory.Limits
open Simplicial
open Simplicial
open Simplicial
| import Init
import Mathlib.AlgebraicTopology.SimplexCategory
import Mathlib.CategoryTheory.Comma.Arrow
import Mathlib.CategoryTheory.Limits.FunctorCategory.Basic
import Mathlib.CategoryTheory.Opposites
import Mathlib.AlgebraicTopology.SimplicialObject
| open Opposite
open CategoryTheory
open CategoryTheory.Limits
open Simplicial
open Simplicial
open Simplicial
| lemma δ_comp_δ_self'_tac_15091 [Category.{v, u} C] (X : CosimplicialObject C) (n : ℕ) (i : Fin (n + 2)) : X.δ i ≫ X.δ i.castSucc = X.δ i ≫ X.δ i.succ := sorry | lemma δ_comp_δ_self'_tac_15091 {C : Type*} [Category.{v, u} C] (X : CosimplicialObject C) (n : ℕ) (i : Fin (n + 2)) : X.δ i ≫ X.δ i.castSucc = X.δ i ≫ X.δ i.succ := sorry | [['δ_comp_δ_self']] | tactic | null | ['Mathlib', 'AlgebraicTopology', 'SimplicialObject'] | null | leanprover/lean4:v4.11.0
| Mathlib | |||||||||
PowerSeries.trunc_derivativeFun_tac_2399 | import Init
import Mathlib.RingTheory.PowerSeries.Trunc
import Mathlib.RingTheory.PowerSeries.Inverse
import Mathlib.RingTheory.Derivation.Basic
import Mathlib.RingTheory.PowerSeries.Derivative
open Polynomial Derivation Nat
| import Init
import Mathlib.RingTheory.PowerSeries.Trunc
import Mathlib.RingTheory.PowerSeries.Inverse
import Mathlib.RingTheory.Derivation.Basic
import Mathlib.RingTheory.PowerSeries.Derivative
| open Polynomial Derivation Nat
| lemma trunc_derivativeFun_tac_2399 [CommSemiring R] (f : R⟦X⟧) (n : ℕ) (d : ℕ) (h : ¬d < n) : 0 = (derivative (trunc (n + 1) f)).coeff d := sorry | lemma trunc_derivativeFun_tac_2399 {R : Type*} [CommSemiring R] (f : R⟦X⟧) (n : ℕ) (d : ℕ) (h : ¬d < n) : 0 = (derivative (trunc (n + 1) f)).coeff d := sorry | [['d'], ['n'], [], ['succ_lt_succ_iff']] | tactic | false | ['Mathlib', 'RingTheory', 'PowerSeries', 'Derivative'] | null | leanprover/lean4:v4.11.0
| Mathlib | {"messages":
[{"severity": "error",
"pos": {"line": 8, "column": 58},
"endPos": {"line": 8, "column": 59},
"data": "unexpected token '⟦'; expected ')'"}],
"env": 0}
|
||||||||
FreeAbelianGroup.ring_tac_15871 | import Init
import Mathlib.GroupTheory.Abelianization
import Mathlib.GroupTheory.FreeGroup.Basic
import Mathlib.GroupTheory.FreeAbelianGroup
open FreeAbelianGroup
open scoped Classical
| import Init
import Mathlib.GroupTheory.Abelianization
import Mathlib.GroupTheory.FreeGroup.Basic
import Mathlib.GroupTheory.FreeAbelianGroup
| open FreeAbelianGroup
open scoped Classical
| lemma ring_tac_15871 [Monoid α] [Ring R] (x : FreeAbelianGroup α) (L : α) : of (Mul.mul L One.one) = of L := sorry | lemma ring_tac_15871 {α : Type*} {β : Type*} {γ : Type*} {R : Type*} [Monoid α] [Ring R] (x : FreeAbelianGroup α) (L : α) : of (Mul.mul L One.one) = of L := sorry | tactic | true | ['Mathlib', 'GroupTheory', 'FreeAbelianGroup'] | null | leanprover/lean4:v4.11.0
| Mathlib | {"sorries":
[{"proofState": 0,
"pos": {"line": 8, "column": 109},
"goal":
"α : Type u_1\nR : Type u_2\ninst✝¹ : Monoid α\ninst✝ : Ring R\nx : FreeAbelianGroup α\nL : α\n⊢ of (Mul.mul L One.one) = of L",
"endPos": {"line": 8, "column": 114}}],
"messages":
[{"severity": "warning",
"pos": {"line": 8, "column": 6},
"endPos": {"line": 8, "column": 20},
"data": "declaration uses 'sorry'"}],
"env": 0}
|
|||||||||
Turing.TM1to1.trTape'_move_left_tac_71109 | import Init
import Mathlib.Data.Fintype.Option
import Mathlib.Data.Fintype.Prod
import Mathlib.Data.Fintype.Pi
import Mathlib.Data.Vector.Basic
import Mathlib.Data.PFun
import Mathlib.Logic.Function.Iterate
import Mathlib.Order.Basic
import Mathlib.Tactic.ApplyFun
import Mathlib.Data.List.GetD
import Mathlib.Computability.TuringMachine
open Mathlib (Vector)
open Relation
open Nat (iterate)
open Function (update iterate_succ iterate_succ_apply iterate_succ' iterate_succ_apply'
open Stmt
open scoped Classical
open TM0.Stmt
open scoped Classical
open TM1
| import Init
import Mathlib.Data.Fintype.Option
import Mathlib.Data.Fintype.Prod
import Mathlib.Data.Fintype.Pi
import Mathlib.Data.Vector.Basic
import Mathlib.Data.PFun
import Mathlib.Logic.Function.Iterate
import Mathlib.Order.Basic
import Mathlib.Tactic.ApplyFun
import Mathlib.Data.List.GetD
import Mathlib.Computability.TuringMachine
| open Mathlib (Vector)
open Relation
open Nat (iterate)
open Function (update iterate_succ iterate_succ_apply iterate_succ' iterate_succ_apply'
open Stmt
open scoped Classical
open TM0.Stmt
open scoped Classical
open TM1
| lemma trTape'_move_left_tac_71109 (n : ℕ) (enc : Γ → Vector Bool n) [Inhabited Γ] (enc0 : enc default = Vector.replicate n false) (R : ListBlank Γ) (a : Γ) (L : ListBlank Γ) : (Tape.move Dir.left)^[n]
(Tape.mk' (ListBlank.append (enc a).toList.reverse (L.bind (fun x => (enc x).toList.reverse) ⋯))
(R.bind (fun x => (enc x).toList) ⋯)) =
Tape.mk' (L.bind (fun x => (enc x).toList.reverse) ⋯)
(ListBlank.append (enc a).toList (R.bind (fun x => (enc x).toList) ⋯)) := sorry | lemma trTape'_move_left_tac_71109 {Γ : Type*} (n : ℕ) (enc : Γ → Vector Bool n) [Inhabited Γ] (enc0 : enc default = Vector.replicate n false) (R : ListBlank Γ) (a : Γ) (L : ListBlank Γ) : (Tape.move Dir.left)^[n]
(Tape.mk' (ListBlank.append (enc a).toList.reverse (L.bind (fun x => (enc x).toList.reverse) ⋯))
(R.bind (fun x => (enc x).toList) ⋯)) =
Tape.mk' (L.bind (fun x => (enc x).toList.reverse) ⋯)
(ListBlank.append (enc a).toList (R.bind (fun x => (enc x).toList) ⋯)) := sorry | tactic | null | ['Mathlib', 'Computability', 'TuringMachine'] | null | leanprover/lean4:v4.11.0
| Mathlib | ||||||||||
Affine.Simplex.sum_pointWeightsWithCircumcenter_tac_26667 | import Init
import Mathlib.Geometry.Euclidean.Sphere.Basic
import Mathlib.LinearAlgebra.AffineSpace.FiniteDimensional
import Mathlib.Tactic.DeriveFintype
import Mathlib.Geometry.Euclidean.Circumcenter
open RealInnerProductSpace
open AffineSubspace
open Finset AffineSubspace EuclideanGeometry
open PointsWithCircumcenterIndex
| import Init
import Mathlib.Geometry.Euclidean.Sphere.Basic
import Mathlib.LinearAlgebra.AffineSpace.FiniteDimensional
import Mathlib.Tactic.DeriveFintype
import Mathlib.Geometry.Euclidean.Circumcenter
| open RealInnerProductSpace
open AffineSubspace
open Finset AffineSubspace EuclideanGeometry
open PointsWithCircumcenterIndex
| lemma sum_pointWeightsWithCircumcenter_tac_26667 (n : ℕ) (i : Fin (n + 1)) (j : PointsWithCircumcenterIndex n) : pointWeightsWithCircumcenter i j = if j = pointIndex i then Function.const (PointsWithCircumcenterIndex n) 1 j else 0 := sorry | lemma sum_pointWeightsWithCircumcenter_tac_26667 (n : ℕ) (i : Fin (n + 1)) (j : PointsWithCircumcenterIndex n) (a✝ : j ∈ univ) : pointWeightsWithCircumcenter i j = if j = pointIndex i then Function.const (PointsWithCircumcenterIndex n) 1 j else 0 := sorry | [['pointWeightsWithCircumcenter'], ['j']] | tactic | false | ['Mathlib', 'Geometry', 'Euclidean', 'Circumcenter'] | null | leanprover/lean4:v4.11.0
| Mathlib | {"sorries":
[{"proofState": 0,
"pos": {"line": 11, "column": 234},
"goal":
"x✝² : Sort u_1\nPointsWithCircumcenterIndex : x✝²\nx✝¹ : Sort u_2\npointWeightsWithCircumcenter : x✝¹\nx✝ : Sort u_3\npointIndex : x✝\nn : ℕ\ni : Fin (n + 1)\nj : sorryAx Prop true\n⊢ sorryAx ℕ true = if j = ⋯ then Function.const (sorryAx Prop true) 1 j else 0",
"endPos": {"line": 11, "column": 239}}],
"messages":
[{"severity": "error",
"pos": {"line": 9, "column": 5},
"endPos": {"line": 9, "column": 32},
"data": "unknown namespace 'PointsWithCircumcenterIndex'"},
{"severity": "error",
"pos": {"line": 11, "column": 80},
"endPos": {"line": 11, "column": 109},
"data":
"function expected at\n PointsWithCircumcenterIndex\nterm has type\n ?m.67"},
{"severity": "error",
"pos": {"line": 11, "column": 113},
"endPos": {"line": 11, "column": 145},
"data":
"function expected at\n pointWeightsWithCircumcenter\nterm has type\n ?m.122"},
{"severity": "error",
"pos": {"line": 11, "column": 155},
"endPos": {"line": 11, "column": 167},
"data": "function expected at\n pointIndex\nterm has type\n ?m.181"},
{"severity": "error",
"pos": {"line": 11, "column": 189},
"endPos": {"line": 11, "column": 218},
"data":
"function expected at\n PointsWithCircumcenterIndex\nterm has type\n ?m.67"}],
"env": 0}
|
||||||||
Submodule.orthogonal_orthogonal_tac_36368 | import Init
import Mathlib.Analysis.Convex.Basic
import Mathlib.Analysis.InnerProductSpace.Orthogonal
import Mathlib.Analysis.InnerProductSpace.Symmetric
import Mathlib.Analysis.NormedSpace.RCLike
import Mathlib.Analysis.RCLike.Lemmas
import Mathlib.Algebra.DirectSum.Decomposition
import Mathlib.Analysis.InnerProductSpace.Projection
open RCLike Real Filter
open LinearMap (ker range)
open Topology Finsupp
| import Init
import Mathlib.Analysis.Convex.Basic
import Mathlib.Analysis.InnerProductSpace.Orthogonal
import Mathlib.Analysis.InnerProductSpace.Symmetric
import Mathlib.Analysis.NormedSpace.RCLike
import Mathlib.Analysis.RCLike.Lemmas
import Mathlib.Algebra.DirectSum.Decomposition
import Mathlib.Analysis.InnerProductSpace.Projection
| open RCLike Real Filter
open LinearMap (ker range)
open Topology Finsupp
| lemma orthogonal_orthogonal_tac_36368 [RCLike 𝕜] [NormedAddCommGroup E] [InnerProductSpace 𝕜 E] (K : Submodule 𝕜 E) [HasOrthogonalProjection K] (y : E) (hy : y ∈ K) (z : E) (hz : z ∈ Kᗮ) (hv : y + z ∈ Kᗮᗮ) : z = 0 := sorry | lemma orthogonal_orthogonal_tac_36368 {𝕜 : Type*} {E : Type*} [RCLike 𝕜] [NormedAddCommGroup E] [InnerProductSpace 𝕜 E] (K : Submodule 𝕜 E) [HasOrthogonalProjection K] (y : E) (hy : y ∈ K) (z : E) (hz : z ∈ Kᗮ) (hv : y + z ∈ Kᗮᗮ) : z = 0 := sorry | tactic | true | ['Mathlib', 'Analysis', 'InnerProductSpace', 'Projection'] | null | leanprover/lean4:v4.11.0
| Mathlib | {"sorries":
[{"proofState": 0,
"pos": {"line": 13, "column": 217},
"goal":
"𝕜 : Type u_1\nE : Type u_2\ninst✝³ : RCLike 𝕜\ninst✝² : NormedAddCommGroup E\ninst✝¹ : InnerProductSpace 𝕜 E\nK : Submodule 𝕜 E\ninst✝ : HasOrthogonalProjection K\ny : E\nhy : y ∈ K\nz : E\nhz : z ∈ Kᗮ\nhv : y + z ∈ Kᗮᗮ\n⊢ z = 0",
"endPos": {"line": 13, "column": 222}}],
"messages":
[{"severity": "warning",
"pos": {"line": 13, "column": 6},
"endPos": {"line": 13, "column": 37},
"data": "declaration uses 'sorry'"}],
"env": 0}
|
|||||||||
IsGalois.card_aut_eq_finrank_tac_3708 | import Init
import Mathlib.FieldTheory.Fixed
import Mathlib.FieldTheory.NormalClosure
import Mathlib.FieldTheory.PrimitiveElement
import Mathlib.GroupTheory.GroupAction.FixingSubgroup
import Mathlib.FieldTheory.Galois
open scoped Polynomial IntermediateField
open FiniteDimensional AlgEquiv
| import Init
import Mathlib.FieldTheory.Fixed
import Mathlib.FieldTheory.NormalClosure
import Mathlib.FieldTheory.PrimitiveElement
import Mathlib.GroupTheory.GroupAction.FixingSubgroup
import Mathlib.FieldTheory.Galois
| open scoped Polynomial IntermediateField
open FiniteDimensional AlgEquiv
| lemma card_aut_eq_finrank_tac_3708 [Field F] [Field E] [Algebra F E] [FiniteDimensional F E] [IsGalois F E] (α : E) (hα : F⟮α⟯ = ⊤) (iso : ↥F⟮α⟯ ≃ₐ[F] E) (H : IsIntegral F α) (h_sep : IsSeparable F α) (h_splits : Polynomial.Splits (algebraMap F E) (minpoly F α)) : Fintype.card (E ≃ₐ[F] E) = finrank F E := sorry | lemma card_aut_eq_finrank_tac_3708 {F : Type*} [Field F] {E : Type*} [Field E] [Algebra F E] [FiniteDimensional F E] [IsGalois F E] (α : E) (hα : F⟮α⟯ = ⊤) (iso : ↥F⟮α⟯ ≃ₐ[F] E) (H : IsIntegral F α) (h_sep : IsSeparable F α) (h_splits : Polynomial.Splits (algebraMap F E) (minpoly F α)) : Fintype.card (E ≃ₐ[F] E) = finrank F E := sorry | tactic | true | ['Mathlib', 'FieldTheory', 'Galois'] | null | leanprover/lean4:v4.11.0
| Mathlib | {"sorries":
[{"proofState": 0,
"pos": {"line": 10, "column": 307},
"goal":
"F : Type u_1\nE : Type u_2\ninst✝⁴ : Field F\ninst✝³ : Field E\ninst✝² : Algebra F E\ninst✝¹ : FiniteDimensional F E\ninst✝ : IsGalois F E\nα : E\nhα : F⟮α⟯ = ⊤\niso : ↥F⟮α⟯ ≃ₐ[F] E\nH : IsIntegral F α\nh_sep : IsSeparable F α\nh_splits : Polynomial.Splits (algebraMap F E) (minpoly F α)\n⊢ Fintype.card (E ≃ₐ[F] E) = finrank F E",
"endPos": {"line": 10, "column": 312}}],
"messages":
[{"severity": "warning",
"pos": {"line": 10, "column": 6},
"endPos": {"line": 10, "column": 34},
"data": "declaration uses 'sorry'"}],
"env": 0}
|
|||||||||
pow_sub_of_lt_tac_13595 | import Init
import Mathlib.Algebra.Group.Units
import Mathlib.Algebra.GroupWithZero.Basic
import Mathlib.Logic.Equiv.Defs
import Mathlib.Tactic.Contrapose
import Mathlib.Tactic.Nontriviality
import Mathlib.Tactic.Spread
import Mathlib.Util.AssertExists
import Mathlib.Data.Subtype
import Mathlib.Algebra.GroupWithZero.Units.Basic
open Classical in
| import Init
import Mathlib.Algebra.Group.Units
import Mathlib.Algebra.GroupWithZero.Basic
import Mathlib.Logic.Equiv.Defs
import Mathlib.Tactic.Contrapose
import Mathlib.Tactic.Nontriviality
import Mathlib.Tactic.Spread
import Mathlib.Util.AssertExists
import Mathlib.Data.Subtype
import Mathlib.Algebra.GroupWithZero.Units.Basic
| open Classical in
| lemma pow_sub_of_lt_tac_13595 [GroupWithZero G₀] (m : ℕ) (n : ℕ) (h : n < m) : m ≠ 0 := sorry | lemma pow_sub_of_lt_tac_13595 {G₀ : Type*} [GroupWithZero G₀] (m : ℕ) (n : ℕ) (h : n < m) : m ≠ 0 := sorry | tactic | true | ['Mathlib', 'Algebra', 'GroupWithZero', 'Units', 'Basic'] | null | leanprover/lean4:v4.11.0
| Mathlib | {"sorries":
[{"proofState": 0,
"pos": {"line": 13, "column": 88},
"goal":
"G₀ : Type u_1\ninst✝ : GroupWithZero G₀\nm n : ℕ\nh : n < m\n⊢ m ≠ 0",
"endPos": {"line": 13, "column": 93}}],
"messages":
[{"severity": "warning",
"pos": {"line": 13, "column": 6},
"endPos": {"line": 13, "column": 29},
"data": "declaration uses 'sorry'"}],
"env": 0}
|
|||||||||
MeasureTheory.Measure.exists_measure_inter_spanningSets_pos_tac_32610 | import Init
import Mathlib.MeasureTheory.Measure.Restrict
import Mathlib.MeasureTheory.Measure.Typeclasses
open scoped ENNReal NNReal Topology
open Set MeasureTheory Measure Filter Function MeasurableSpace ENNReal
open scoped symmDiff
open Interval
open Measure
open scoped Classical in
open scoped Classical in
open scoped Classical in
| import Init
import Mathlib.MeasureTheory.Measure.Restrict
import Mathlib.MeasureTheory.Measure.Typeclasses
| open scoped ENNReal NNReal Topology
open Set MeasureTheory Measure Filter Function MeasurableSpace ENNReal
open scoped symmDiff
open Interval
open Measure
open scoped Classical in
open scoped Classical in
open scoped Classical in
| lemma exists_measure_inter_spanningSets_pos_tac_32610 [MeasurableSpace α] (μ : Measure α) [SigmaFinite μ] (s : Set α) : (∃ n, 0 < μ (s ∩ spanningSets μ n)) ↔ 0 < μ s := sorry | lemma exists_measure_inter_spanningSets_pos_tac_32610 {α : Type*} [MeasurableSpace α] (μ : Measure α) [SigmaFinite μ] (s : Set α) : (∃ n, 0 < μ (s ∩ spanningSets μ n)) ↔ 0 < μ s := sorry | [['not_iff_not']] | tactic | true | ['Mathlib', 'MeasureTheory', 'Measure', 'Typeclasses'] | null | leanprover/lean4:v4.11.0
| Mathlib | {"sorries":
[{"proofState": 0,
"pos": {"line": 13, "column": 169},
"goal":
"α : Type u_1\ninst✝¹ : MeasurableSpace α\nμ : Measure α\ninst✝ : SigmaFinite μ\ns : Set α\n⊢ (∃ n, 0 < μ (s ∩ spanningSets μ n)) ↔ 0 < μ s",
"endPos": {"line": 13, "column": 174}}],
"messages":
[{"severity": "warning",
"pos": {"line": 13, "column": 6},
"endPos": {"line": 13, "column": 53},
"data": "declaration uses 'sorry'"}],
"env": 0}
|
||||||||
DyckWord.le_add_self_tac_16486 | import Init
import Mathlib.Combinatorics.Enumerative.Catalan
import Mathlib.Data.List.Indexes
import Mathlib.Combinatorics.Enumerative.DyckWord
open List
open DyckStep
| import Init
import Mathlib.Combinatorics.Enumerative.Catalan
import Mathlib.Data.List.Indexes
import Mathlib.Combinatorics.Enumerative.DyckWord
| open List
open DyckStep
| lemma le_add_self_tac_16486 (p : DyckWord) (q : DyckWord) (h : ¬p = 0) (this : p.outsidePart.semilength < p.semilength) : p.outsidePart.semilength < p.semilength := sorry | lemma le_add_self_tac_16486 (p : DyckWord) (q : DyckWord) (a✝ : ∀ (y : (_ : DyckWord) ×' DyckWord),
(invImage (fun x => PSigma.casesOn x fun p q => p.semilength) instWellFoundedRelationOfSizeOf).1 y ⟨p, q⟩ →
y.2 ≤ y.1 + y.2) (h : ¬p = 0) (this : p.outsidePart.semilength < p.semilength) : p.outsidePart.semilength < p.semilength := sorry | [['PSigma', 'Lex', 'left', '_@', '_hyg', 5690], ['PSigma', 'Lex', 'right', '_@', '_hyg', 5690]] | tactic | true | ['Mathlib', 'Combinatorics', 'Enumerative', 'DyckWord'] | null | leanprover/lean4:v4.11.0
| Mathlib | {"sorries":
[{"proofState": 0,
"pos": {"line": 8, "column": 165},
"goal":
"p q : DyckWord\nh : ¬p = 0\nthis : p.outsidePart.semilength < p.semilength\n⊢ p.outsidePart.semilength < p.semilength",
"endPos": {"line": 8, "column": 170}}],
"messages":
[{"severity": "warning",
"pos": {"line": 8, "column": 6},
"endPos": {"line": 8, "column": 27},
"data": "declaration uses 'sorry'"}],
"env": 0}
|
||||||||
IsDedekindDomainInv.dimensionLEOne_tac_13312 | import Init
import Mathlib.Algebra.Algebra.Subalgebra.Pointwise
import Mathlib.RingTheory.MaximalSpectrum
import Mathlib.RingTheory.ChainOfDivisors
import Mathlib.RingTheory.DedekindDomain.Basic
import Mathlib.RingTheory.FractionalIdeal.Operations
import Mathlib.RingTheory.DedekindDomain.Ideal
open scoped nonZeroDivisors Polynomial
open Submodule Submodule.IsPrincipal
open FractionalIdeal
open Ring
| import Init
import Mathlib.Algebra.Algebra.Subalgebra.Pointwise
import Mathlib.RingTheory.MaximalSpectrum
import Mathlib.RingTheory.ChainOfDivisors
import Mathlib.RingTheory.DedekindDomain.Basic
import Mathlib.RingTheory.FractionalIdeal.Operations
import Mathlib.RingTheory.DedekindDomain.Ideal
| open scoped nonZeroDivisors Polynomial
open Submodule Submodule.IsPrincipal
open FractionalIdeal
open Ring
| lemma dimensionLEOne_tac_13312 [CommRing A] [IsDomain A] (h : IsDedekindDomainInv A) (P : Ideal A) (P_ne : P ≠ ⊥) (hP : P.IsPrime) (M : Ideal A) (hM : P < M) (P'_ne : ↑P ≠ 0) (M'_ne : ↑M ≠ 0) (this : (↑M)⁻¹ * ↑P ≤ ↑P) : 1 ≤ ↑M := sorry | lemma dimensionLEOne_tac_13312 {A : Type*} [CommRing A] [IsDomain A] (h : IsDedekindDomainInv A) (P : Ideal A) (P_ne : P ≠ ⊥) (hP : P.IsPrime) (M : Ideal A) (hM : P < M) (P'_ne : ↑P ≠ 0) (M'_ne : ↑M ≠ 0) (this : (↑M)⁻¹ * ↑P ≤ ↑P) : 1 ≤ ↑M := sorry | tactic | null | ['Mathlib', 'RingTheory', 'DedekindDomain', 'Ideal'] | null | leanprover/lean4:v4.11.0
| Mathlib | ||||||||||
Localization.r'_tac_8553 | import Init
import Mathlib.Algebra.Group.Submonoid.Membership
import Mathlib.GroupTheory.Congruence.Basic
import Mathlib.RingTheory.OreLocalization.Basic
import Mathlib.GroupTheory.MonoidLocalization.Basic
open Function
| import Init
import Mathlib.Algebra.Group.Submonoid.Membership
import Mathlib.GroupTheory.Congruence.Basic
import Mathlib.RingTheory.OreLocalization.Basic
import Mathlib.GroupTheory.MonoidLocalization.Basic
| open Function
| lemma r'_tac_8553 [CommMonoid M] (S : Submonoid M) [CommMonoid N] [CommMonoid P] (a : M × ↥S) (b : M × ↥S) (c : M × ↥S) (d : M × ↥S) (t₁ : ↥S) (ht₁ : ↑t₁ * (↑b.2 * a.1) = ↑t₁ * (↑a.2 * b.1)) (t₂ : ↥S) (ht₂ : ↑t₂ * (↑d.2 * c.1) = ↑t₂ * (↑c.2 * d.1)) : ↑t₂ * (↑c.2 * d.1) * (↑t₁ * (↑a.2 * b.1)) = ↑t₂ * ↑t₁ * (↑a.2 * ↑c.2 * (b.1 * d.1)) := sorry | lemma r'_tac_8553 {M : Type*} [CommMonoid M] (S : Submonoid M) {N : Type*} [CommMonoid N] {P : Type*} [CommMonoid P] (a : M × ↥S) (b : M × ↥S) (c : M × ↥S) (d : M × ↥S) (t₁ : ↥S) (ht₁ : ↑t₁ * (↑b.2 * a.1) = ↑t₁ * (↑a.2 * b.1)) (t₂ : ↥S) (ht₂ : ↑t₂ * (↑d.2 * c.1) = ↑t₂ * (↑c.2 * d.1)) : ↑t₂ * (↑c.2 * d.1) * (↑t₁ * (↑a.2 * b.1)) = ↑t₂ * ↑t₁ * (↑a.2 * ↑c.2 * (b.1 * d.1)) := sorry | tactic | null | ['Mathlib', 'GroupTheory', 'MonoidLocalization', 'Basic'] | null | leanprover/lean4:v4.11.0
| Mathlib | ||||||||||
Ordinal.toPGame_nmul_tac_7452 | import Init
import Mathlib.SetTheory.Game.Basic
import Mathlib.SetTheory.Ordinal.NaturalOps
import Mathlib.SetTheory.Game.Ordinal
open SetTheory PGame
open scoped NaturalOps PGame
| import Init
import Mathlib.SetTheory.Game.Basic
import Mathlib.SetTheory.Ordinal.NaturalOps
import Mathlib.SetTheory.Game.Ordinal
| open SetTheory PGame
open scoped NaturalOps PGame
| lemma toPGame_nmul_tac_7452 (a : Ordinal.{u}) (b : Ordinal.{u}) (i : a.toPGame.LeftMoves) (j : b.toPGame.LeftMoves) : ¬⟦(a ⨳ b).toPGame⟧ + ⟦(↑(toLeftMovesToPGame.symm i)).toPGame * (↑(toLeftMovesToPGame.symm j)).toPGame⟧ ≤
⟦(↑(toLeftMovesToPGame.symm i)).toPGame * b.toPGame⟧ + ⟦a.toPGame * (↑(toLeftMovesToPGame.symm j)).toPGame⟧ := sorry | lemma toPGame_nmul_tac_7452 (a : Ordinal.{u}) (b : Ordinal.{u}) (i✝ : (a.toPGame * b.toPGame).LeftMoves) (i : a.toPGame.LeftMoves) (j : b.toPGame.LeftMoves) : ¬⟦(a ⨳ b).toPGame⟧ + ⟦(↑(toLeftMovesToPGame.symm i)).toPGame * (↑(toLeftMovesToPGame.symm j)).toPGame⟧ ≤
⟦(↑(toLeftMovesToPGame.symm i)).toPGame * b.toPGame⟧ + ⟦a.toPGame * (↑(toLeftMovesToPGame.symm j)).toPGame⟧ := sorry | tactic | false | ['Mathlib', 'SetTheory', 'Game', 'Ordinal'] | null | leanprover/lean4:v4.11.0
| Mathlib | {"sorries":
[{"proofState": 0,
"pos": {"line": 9, "column": 115},
"goal":
"a b : Ordinal.{u}\ni : a.toPGame.LeftMoves\nj : b.toPGame.LeftMoves\n⊢ ¬⟦(a ⨳ b).toPGame⟧ + ⟦sorryAx (?m.882 a b i j) true * sorryAx (?m.883 a b i j) true⟧ ≤\n ⟦sorryAx PGame true * b.toPGame⟧ + ⟦a.toPGame * sorryAx PGame true⟧",
"endPos": {"line": 9, "column": 120}}],
"messages":
[{"severity": "error",
"pos": {"line": 8, "column": 143},
"endPos": {"line": 8, "column": 166},
"data": "unknown identifier 'toLeftMovesToPGame.symm'"},
{"severity": "error",
"pos": {"line": 8, "column": 141},
"endPos": {"line": 8, "column": 169},
"data": "invalid coercion notation, expected type is not known"},
{"severity": "error",
"pos": {"line": 8, "column": 184},
"endPos": {"line": 8, "column": 207},
"data": "unknown identifier 'toLeftMovesToPGame.symm'"},
{"severity": "error",
"pos": {"line": 8, "column": 182},
"endPos": {"line": 8, "column": 210},
"data": "invalid coercion notation, expected type is not known"},
{"severity": "error",
"pos": {"line": 9, "column": 8},
"endPos": {"line": 9, "column": 31},
"data": "unknown identifier 'toLeftMovesToPGame.symm'"},
{"severity": "error",
"pos": {"line": 9, "column": 6},
"endPos": {"line": 9, "column": 34},
"data": "invalid coercion notation, expected type is not known"},
{"severity": "error",
"pos": {"line": 9, "column": 75},
"endPos": {"line": 9, "column": 98},
"data": "unknown identifier 'toLeftMovesToPGame.symm'"},
{"severity": "error",
"pos": {"line": 9, "column": 73},
"endPos": {"line": 9, "column": 101},
"data": "invalid coercion notation, expected type is not known"}],
"env": 0}
|
|||||||||
sub_div_sub_smul_slope_add_sub_div_sub_smul_slope_tac_4001 | import Init
import Mathlib.LinearAlgebra.AffineSpace.AffineMap
import Mathlib.Tactic.FieldSimp
import Mathlib.LinearAlgebra.AffineSpace.Slope
open AffineMap
| import Init
import Mathlib.LinearAlgebra.AffineSpace.AffineMap
import Mathlib.Tactic.FieldSimp
import Mathlib.LinearAlgebra.AffineSpace.Slope
| open AffineMap
| lemma sub_div_sub_smul_slope_add_sub_div_sub_smul_slope_tac_4001 [Field k] [AddCommGroup E] [Module k E] [AddTorsor E PE] (f : k → PE) (a : k) (c : k) (hac : ¬a = c) : slope f a c = slope f a c := sorry | lemma sub_div_sub_smul_slope_add_sub_div_sub_smul_slope_tac_4001 {k : Type*} {E : Type*} {PE : Type*} [Field k] [AddCommGroup E] [Module k E] [AddTorsor E PE] (f : k → PE) (a : k) (c : k) (hac : ¬a = c) : slope f a c = slope f a c := sorry | tactic | true | ['Mathlib', 'LinearAlgebra', 'AffineSpace', 'Slope'] | null | leanprover/lean4:v4.11.0
| Mathlib | {"sorries":
[{"proofState": 0,
"pos": {"line": 7, "column": 197},
"goal":
"k : Type u_1\nE : Type u_2\nPE : Type u_3\ninst✝³ : Field k\ninst✝² : AddCommGroup E\ninst✝¹ : Module k E\ninst✝ : AddTorsor E PE\nf : k → PE\na c : k\nhac : ¬a = c\n⊢ slope f a c = slope f a c",
"endPos": {"line": 7, "column": 202}}],
"messages":
[{"severity": "warning",
"pos": {"line": 7, "column": 6},
"endPos": {"line": 7, "column": 64},
"data": "declaration uses 'sorry'"}],
"env": 0}
|
|||||||||
inv_mul_lt_iff_lt_mul_tac_3023 | import Init
import Mathlib.Algebra.Order.Monoid.Unbundled.Basic
import Mathlib.Algebra.Order.Sub.Defs
import Mathlib.Util.AssertExists
import Mathlib.Algebra.Order.Group.Unbundled.Basic
open Function
| import Init
import Mathlib.Algebra.Order.Monoid.Unbundled.Basic
import Mathlib.Algebra.Order.Sub.Defs
import Mathlib.Util.AssertExists
import Mathlib.Algebra.Order.Group.Unbundled.Basic
| open Function
| lemma inv_mul_lt_iff_lt_mul_tac_3023 [Group α] [LT α] [CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x < x_1] (a : α) (b : α) (c : α) : a < b * c ↔ a < b * c := sorry | lemma inv_mul_lt_iff_lt_mul_tac_3023 {α : Type*} [Group α] [LT α] [CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x < x_1] (a : α) (b : α) (c : α) : a < b * c ↔ a < b * c := sorry | tactic | true | ['Mathlib', 'Algebra', 'Order', 'Group', 'Unbundled', 'Basic'] | null | leanprover/lean4:v4.11.0
| Mathlib | {"sorries":
[{"proofState": 0,
"pos": {"line": 8, "column": 170},
"goal":
"α : Type u_1\ninst✝² : Group α\ninst✝¹ : LT α\ninst✝ : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x < x_1\na b c : α\n⊢ a < b * c ↔ a < b * c",
"endPos": {"line": 8, "column": 175}}],
"messages":
[{"severity": "warning",
"pos": {"line": 8, "column": 6},
"endPos": {"line": 8, "column": 36},
"data": "declaration uses 'sorry'"}],
"env": 0}
|
|||||||||
PowerSeries.coe_zero | import Init
import Mathlib.Data.Int.Interval
import Mathlib.RingTheory.Binomial
import Mathlib.RingTheory.DedekindDomain.Basic
import Mathlib.RingTheory.HahnSeries.PowerSeries
import Mathlib.RingTheory.HahnSeries.Summable
import Mathlib.RingTheory.PowerSeries.Inverse
import Mathlib.FieldTheory.RatFunc.AsPolynomial
import Mathlib.RingTheory.Localization.FractionRing
import Mathlib.RingTheory.LaurentSeries
open scoped Classical
open HahnSeries Polynomial
open LaurentSeries
| import Init
import Mathlib.Data.Int.Interval
import Mathlib.RingTheory.Binomial
import Mathlib.RingTheory.DedekindDomain.Basic
import Mathlib.RingTheory.HahnSeries.PowerSeries
import Mathlib.RingTheory.HahnSeries.Summable
import Mathlib.RingTheory.PowerSeries.Inverse
import Mathlib.FieldTheory.RatFunc.AsPolynomial
import Mathlib.RingTheory.Localization.FractionRing
import Mathlib.RingTheory.LaurentSeries
| open scoped Classical
open HahnSeries Polynomial
open LaurentSeries
| @[norm_cast] -- Porting note (#10618): simp can prove this
theorem coe_zero : ((0 : PowerSeries R) : LaurentSeries R) = 0 := sorry | theorem coe_zero_extracted : ∀ {R : Type u_1} [inst : Semiring R], (ofPowerSeries ℤ R) 0 = 0 := sorry | [['HahnSeries', 'instZero'], ['RingHom'], ['OfNat', 'ofNat'], ['StrictOrderedSemiring', 'toOrderedCancelAddCommMonoid'], ['Semiring', 'toMonoidWithZero'], ['HahnSeries', 'ofPowerSeries'], ['PowerSeries'], ['RingHom', 'instFunLike'], ['HahnSeries', 'instNonAssocSemiring'], ['HahnSeries'], ['Eq'], ['Zero', 'toOfNat0'], ['LinearOrderedCommRing', 'toLinearOrderedCommSemiring'], ['Int', 'instLinearOrderedCommRing'], ['Semiring', 'toNonAssocSemiring'], ['PowerSeries', 'instZero'], ['StrictOrderedSemiring', 'toPartialOrder'], ['LinearOrderedSemiring', 'toStrictOrderedSemiring'], ['MonoidWithZero', 'toZero'], ['DFunLike', 'coe'], ['Int'], ['LinearOrderedCommSemiring', 'toLinearOrderedSemiring'], ['PowerSeries', 'instSemiring']] | @[norm_cast] -- Porting note (#10618): simp can prove this
theorem coe_zero : ((0 : PowerSeries R) : LaurentSeries R) = 0 :=
(ofPowerSeries ℤ R).map_zero | [['Semiring', 'toNonAssocSemiring'], ['Int', 'instLinearOrderedCommRing'], ['LinearOrderedCommRing', 'toLinearOrderedCommSemiring'], ['StrictOrderedSemiring', 'toPartialOrder'], ['StrictOrderedSemiring', 'toOrderedCancelAddCommMonoid'], ['Semiring', 'toMonoidWithZero'], ['HahnSeries', 'ofPowerSeries'], ['LinearOrderedSemiring', 'toStrictOrderedSemiring'], ['PowerSeries'], ['RingHom', 'map_zero'], ['MonoidWithZero', 'toZero'], ['HahnSeries', 'instNonAssocSemiring'], ['LinearOrderedCommSemiring', 'toLinearOrderedSemiring'], ['Int'], ['HahnSeries'], ['PowerSeries', 'instSemiring']] | theorem | Syntax(original=True, range=StringRange(start=7697, stop=7854)) | false | ['Mathlib', 'RingTheory', 'LaurentSeries'] | null | leanprover/lean4:v4.11.0
| Mathlib | {"sorries":
[{"proofState": 0,
"pos": {"line": 16, "column": 66},
"goal": "R : Type u_1\n⊢ sorryAx ℕ true = 0",
"endPos": {"line": 16, "column": 71}}],
"messages":
[{"severity": "error",
"pos": {"line": 16, "column": 42},
"endPos": {"line": 16, "column": 57},
"data":
"failed to synthesize\n Zero R\nAdditional diagnostic information may be available using the `set_option diagnostics true` command."},
{"severity": "error",
"pos": {"line": 16, "column": 21},
"endPos": {"line": 16, "column": 22},
"data":
"failed to synthesize\n OfNat (PowerSeries R) 0\nnumerals are polymorphic in Lean, but the numeral `0` cannot be used in a context where the expected type is\n PowerSeries R\ndue to the absence of the instance above\nAdditional diagnostic information may be available using the `set_option diagnostics true` command."}],
"env": 0}
|
|||||
WittVector.init_zsmul_tac_7912 | import Init
import Mathlib.RingTheory.WittVector.Basic
import Mathlib.RingTheory.WittVector.IsPoly
import Mathlib.RingTheory.WittVector.InitTail
open MvPolynomial
open scoped Classical
open Lean Elab Tactic in
| import Init
import Mathlib.RingTheory.WittVector.Basic
import Mathlib.RingTheory.WittVector.IsPoly
import Mathlib.RingTheory.WittVector.InitTail
| open MvPolynomial
open scoped Classical
open Lean Elab Tactic in
| lemma init_zsmul_tac_7912 (p : ℕ) [CommRing R] [Fact (Nat.Prime p)] (m : ℤ) (x : 𝕎 R) (n : ℕ) (i : ℕ) (hi : i < n) : peval (wittZSMul p m i) ![x.coeff] =
peval (wittZSMul p m i) ![(mk p fun n_1 => if n_1 < n then x.coeff n_1 else 0).coeff] := sorry | lemma init_zsmul_tac_7912 (p : ℕ) {R : Type*} [CommRing R] [Fact (Nat.Prime p)] (m : ℤ) (x : 𝕎 R) (n : ℕ) (i : ℕ) (hi : i < n) : peval (wittZSMul p m i) ![x.coeff] =
peval (wittZSMul p m i) ![(mk p fun n_1 => if n_1 < n then x.coeff n_1 else 0).coeff] := sorry | [['MvPolynomial', "eval₂Hom_congr'"], ['RingHom', 'ext_int'], ['rfl']] | tactic | false | ['Mathlib', 'RingTheory', 'WittVector', 'InitTail'] | null | leanprover/lean4:v4.11.0
| Mathlib | {"sorries":
[{"proofState": 0,
"pos": {"line": 10, "column": 91},
"goal":
"x✝¹ : Sort u_1\n𝕎 : x✝¹\nx✝ : Sort u_2\npeval : x✝\np : ℕ\ninst✝¹ : CommRing (sorryAx (Type u_3) true)\ninst✝ : Fact (Nat.Prime p)\nm : ℤ\nx : sorryAx (Sort u_4) true\nn i : ℕ\nhi : i < n\n⊢ sorryAx (?m.2448 p m x n i hi) true = sorryAx (?m.2448 p m x n i hi) true",
"endPos": {"line": 10, "column": 96}}],
"messages":
[{"severity": "error",
"pos": {"line": 9, "column": 44},
"endPos": {"line": 9, "column": 45},
"data":
"application type mismatch\n CommRing R\nargument\n R\nhas type\n Type ?u.1429 → (K : Type ?u.1429) → [inst : Fintype K] → [inst : CommRing K] → Type ?u.1429 : Type (?u.1429 + 1)\nbut is expected to have type\n Type ?u.1428 : Type (?u.1428 + 1)"},
{"severity": "error",
"pos": {"line": 9, "column": 81},
"endPos": {"line": 9, "column": 84},
"data": "function expected at\n 𝕎\nterm has type\n ?m.703"},
{"severity": "error",
"pos": {"line": 9, "column": 117},
"endPos": {"line": 9, "column": 151},
"data": "function expected at\n peval\nterm has type\n ?m.1423"},
{"severity": "error",
"pos": {"line": 10, "column": 2},
"endPos": {"line": 10, "column": 87},
"data": "function expected at\n peval\nterm has type\n ?m.1423"}],
"env": 0}
|
||||||||
RegularExpression.star_rmatch_iff_tac_9558 | import Init
import Mathlib.Computability.Language
import Mathlib.Tactic.AdaptationNote
import Mathlib.Computability.RegularExpressions
open List Set
open Computability
| import Init
import Mathlib.Computability.Language
import Mathlib.Tactic.AdaptationNote
import Mathlib.Computability.RegularExpressions
| open List Set
open Computability
| lemma star_rmatch_iff_tac_9558 [DecidableEq α] (P : RegularExpression α) (a : α) (x : List α) (IH : ∀ (t : List α),
t.length < (a :: x).length → (P.star.rmatch t = true ↔ ∃ S, t = S.join ∧ ∀ t ∈ S, t ≠ [] ∧ P.rmatch t = true)) (t : List α) (u : List α) (hs : x = t ++ u) (ht : (P.deriv a).rmatch t = true) (hwf : u.length < (a :: x).length) (S' : List (List α)) (hsum : u = S'.join) (helem : ∀ t ∈ S', t ≠ [] ∧ P.rmatch t = true) : (P.deriv a).rmatch t = true := sorry | lemma star_rmatch_iff_tac_9558 {α : Type*} [DecidableEq α] (P : RegularExpression α) (a : α) (x : List α) (IH : ∀ (t : List α),
t.length < (a :: x).length → (P.star.rmatch t = true ↔ ∃ S, t = S.join ∧ ∀ t ∈ S, t ≠ [] ∧ P.rmatch t = true)) (t : List α) (u : List α) (hs : x = t ++ u) (ht : (P.deriv a).rmatch t = true) (hwf : u.length < (a :: x).length) (S' : List (List α)) (hsum : u = S'.join) (helem : ∀ t ∈ S', t ≠ [] ∧ P.rmatch t = true) : (P.deriv a).rmatch t = true := sorry | [['ht']] | tactic | null | ['Mathlib', 'Computability', 'RegularExpressions'] | null | leanprover/lean4:v4.11.0
| Mathlib | |||||||||
iSup_ne_bot_subtype_tac_52739 | import Init
import Mathlib.Data.Bool.Set
import Mathlib.Data.Nat.Set
import Mathlib.Data.Set.Prod
import Mathlib.Data.ULift
import Mathlib.Order.Bounds.Basic
import Mathlib.Order.Hom.Set
import Mathlib.Order.SetNotation
import Mathlib.Order.CompleteLattice
open Function OrderDual Set
open OrderDual
| import Init
import Mathlib.Data.Bool.Set
import Mathlib.Data.Nat.Set
import Mathlib.Data.Set.Prod
import Mathlib.Data.ULift
import Mathlib.Order.Bounds.Basic
import Mathlib.Order.Hom.Set
import Mathlib.Order.SetNotation
import Mathlib.Order.CompleteLattice
| open Function OrderDual Set
open OrderDual
| lemma iSup_ne_bot_subtype_tac_52739 (ι : Sort u_5) [CompleteLattice α] (f : ι → α) (htriv : ¬∀ (i : ι), f i = ⊥) (i : ι) (hi : f i = ⊥) : ∃ i', ⊥ ≤ f ↑i' := sorry | lemma iSup_ne_bot_subtype_tac_52739 {α : Type*} (ι : Sort u_5) [CompleteLattice α] (f : ι → α) (htriv : ¬∀ (i : ι), f i = ⊥) (i : ι) (hi : f i = ⊥) : ∃ i', ⊥ ≤ f ↑i' := sorry | tactic | true | ['Mathlib', 'Order', 'CompleteLattice'] | null | leanprover/lean4:v4.11.0
| Mathlib | {"sorries":
[{"proofState": 0,
"pos": {"line": 13, "column": 155},
"goal":
"α : Type u_1\nι : Sort u_5\ninst✝ : CompleteLattice α\nf : ι → α\nhtriv : ¬∀ (i : ι), f i = ⊥\ni : ι\nhi : f i = ⊥\n⊢ ∃ i, ⊥ ≤ f i",
"endPos": {"line": 13, "column": 160}}],
"messages":
[{"severity": "warning",
"pos": {"line": 13, "column": 6},
"endPos": {"line": 13, "column": 35},
"data": "declaration uses 'sorry'"}],
"env": 0}
|
|||||||||
Set.preimage_boolIndicator_tac_1605 | import Init
import Mathlib.Data.Set.Basic
import Mathlib.Data.Set.BoolIndicator
open Bool
open scoped Classical
| import Init
import Mathlib.Data.Set.Basic
import Mathlib.Data.Set.BoolIndicator
| open Bool
open scoped Classical
| lemma preimage_boolIndicator_tac_1605 (s : Set α) (t : Set Bool) : s ∪ sᶜ = univ ∨ s ∪ sᶜ = s ∨ s ∪ sᶜ = sᶜ ∨ s ∪ sᶜ = ∅ := sorry | lemma preimage_boolIndicator_tac_1605 {α : Type*} (s : Set α) (t : Set Bool) (h✝¹ : true ∈ t) (h✝ : false ∈ t) : s ∪ sᶜ = univ ∨ s ∪ sᶜ = s ∨ s ∪ sᶜ = sᶜ ∨ s ∪ sᶜ = ∅ := sorry | [['s', 'union_compl_self']] | tactic | true | ['Mathlib', 'Data', 'Set', 'BoolIndicator'] | null | leanprover/lean4:v4.11.0
| Mathlib | {"sorries":
[{"proofState": 0,
"pos": {"line": 7, "column": 124},
"goal":
"α : Type u_1\nuniv s : Set α\nt : Set Bool\n⊢ s ∪ sᶜ = univ ∨ s ∪ sᶜ = s ∨ s ∪ sᶜ = sᶜ ∨ s ∪ sᶜ = ∅",
"endPos": {"line": 7, "column": 129}}],
"messages":
[{"severity": "warning",
"pos": {"line": 7, "column": 6},
"endPos": {"line": 7, "column": 37},
"data": "declaration uses 'sorry'"}],
"env": 0}
|
||||||||
HasCompactSupport.smul_left_tac_12202 | import Init
import Mathlib.Algebra.GroupWithZero.Indicator
import Mathlib.Algebra.Module.Basic
import Mathlib.Topology.Separation
import Mathlib.Topology.Support
open Function Set Filter Topology
| import Init
import Mathlib.Algebra.GroupWithZero.Indicator
import Mathlib.Algebra.Module.Basic
import Mathlib.Topology.Separation
import Mathlib.Topology.Support
| open Function Set Filter Topology
| lemma smul_left_tac_12202 [TopologicalSpace α] [Zero M] [SMulZeroClass R M] (f : α → R) (f' : α → M) (hf : f' =ᶠ[coclosedCompact α] 0) : f • f' =ᶠ[coclosedCompact α] 0 := sorry | lemma smul_left_tac_12202 {α : Type*} {M : Type*} {R : Type*} [TopologicalSpace α] [Zero M] [SMulZeroClass R M] (f : α → R) (f' : α → M) (hf : f' =ᶠ[coclosedCompact α] 0) : f • f' =ᶠ[coclosedCompact α] 0 := sorry | tactic | null | ['Mathlib', 'Topology', 'Support'] | null | leanprover/lean4:v4.11.0
| Mathlib | ||||||||||
MvPolynomial.IsHomogeneous.inj_right_tac_5275 | import Init
import Mathlib.Algebra.DirectSum.Internal
import Mathlib.Algebra.GradedMonoid
import Mathlib.Algebra.MvPolynomial.CommRing
import Mathlib.Algebra.MvPolynomial.Equiv
import Mathlib.Algebra.MvPolynomial.Variables
import Mathlib.RingTheory.MvPolynomial.WeightedHomogeneous
import Mathlib.Algebra.Polynomial.Roots
import Mathlib.RingTheory.MvPolynomial.Homogeneous
open Finsupp
| import Init
import Mathlib.Algebra.DirectSum.Internal
import Mathlib.Algebra.GradedMonoid
import Mathlib.Algebra.MvPolynomial.CommRing
import Mathlib.Algebra.MvPolynomial.Equiv
import Mathlib.Algebra.MvPolynomial.Variables
import Mathlib.RingTheory.MvPolynomial.WeightedHomogeneous
import Mathlib.Algebra.Polynomial.Roots
import Mathlib.RingTheory.MvPolynomial.Homogeneous
| open Finsupp
| lemma inj_right_tac_5275 [CommSemiring R] (φ : MvPolynomial σ R) (m : ℕ) (n : ℕ) (hm : φ.IsHomogeneous m) (hn : φ.IsHomogeneous n) (hφ : φ ≠ 0) (d : σ →₀ ℕ) (hd : coeff d φ ≠ 0) : (weight 1) d = (weight 1) d := sorry | lemma inj_right_tac_5275 {σ : Type*} {R : Type*} [CommSemiring R] (φ : MvPolynomial σ R) (m : ℕ) (n : ℕ) (hm : φ.IsHomogeneous m) (hn : φ.IsHomogeneous n) (hφ : φ ≠ 0) (d : σ →₀ ℕ) (hd : coeff d φ ≠ 0) : (weight 1) d = (weight 1) d := sorry | tactic | false | ['Mathlib', 'RingTheory', 'MvPolynomial', 'Homogeneous'] | null | leanprover/lean4:v4.11.0
| Mathlib | {"sorries":
[{"proofState": 0,
"pos": {"line": 12, "column": 211},
"goal":
"R : Type u_1\nσ : Type u_2\nx✝ : Sort u_3\ncoeff : x✝\ninst✝ : CommSemiring R\nφ : MvPolynomial σ R\nm n : ℕ\nhm : φ.IsHomogeneous m\nhn : φ.IsHomogeneous n\nhφ : φ ≠ 0\nd : σ →₀ ℕ\nhd : sorryAx ℕ true ≠ 0\n⊢ (weight 1) d = (weight 1) d",
"endPos": {"line": 12, "column": 216}}],
"messages":
[{"severity": "error",
"pos": {"line": 12, "column": 163},
"endPos": {"line": 12, "column": 172},
"data": "function expected at\n coeff\nterm has type\n ?m.196"}],
"env": 0}
|
|||||||||
UniformSpace.toCore_tac_15242 | import Init
import Mathlib.Order.Filter.SmallSets
import Mathlib.Tactic.Monotonicity
import Mathlib.Topology.Compactness.Compact
import Mathlib.Topology.NhdsSet
import Mathlib.Algebra.Group.Defs
import Mathlib.Topology.UniformSpace.Basic
open Set Filter Topology
open Uniformity
| import Init
import Mathlib.Order.Filter.SmallSets
import Mathlib.Tactic.Monotonicity
import Mathlib.Topology.Compactness.Compact
import Mathlib.Topology.NhdsSet
import Mathlib.Algebra.Group.Defs
import Mathlib.Topology.UniformSpace.Basic
| open Set Filter Topology
open Uniformity
| lemma toCore_tac_15242 (ι : Sort u_1) (u : UniformSpace α) (U : Set (α × α)) (hU : U ∈ UniformSpace.uniformity) (x : α) : Prod.mk x ⁻¹' U ∈ 𝓝 x := sorry | lemma toCore_tac_15242 {α : Type*} {β : Type*} {γ : Type*} {δ : Type*} (ι : Sort u_1) (u : UniformSpace α) (U : Set (α × α)) (hU : U ∈ UniformSpace.uniformity) (x : α) : Prod.mk x ⁻¹' U ∈ 𝓝 x := sorry | [['UniformSpace', 'nhds_eq_comap_uniformity']] | tactic | null | ['Mathlib', 'Topology', 'UniformSpace', 'Basic'] | null | leanprover/lean4:v4.11.0
| Mathlib | |||||||||
RelSeries.insertNth_tac_13411 | import Init
import Mathlib.Algebra.Order.Ring.Nat
import Mathlib.Data.Fintype.Card
import Mathlib.Data.Fintype.Pi
import Mathlib.Data.Fintype.Sigma
import Mathlib.Data.Rel
import Mathlib.Order.RelSeries
| import Init
import Mathlib.Algebra.Order.Ring.Nat
import Mathlib.Data.Fintype.Card
import Mathlib.Data.Fintype.Pi
import Mathlib.Data.Fintype.Sigma
import Mathlib.Data.Rel
import Mathlib.Order.RelSeries
| lemma insertNth_tac_13411 (r : Rel α α) (s : Rel β β) (p : RelSeries r) (i : Fin p.length) (a : α) (prev_connect : r (p.toFun i.castSucc) a) (connect_next : r a (p.toFun i.succ)) (m : Fin (p.length + 1)) (x : α) (y : α) (hm : ↑i + 1 < ↑m ∨ ↑i + 1 = ↑m) : r x y := sorry | lemma insertNth_tac_13411 {α : Type*} (r : Rel α α) {β : Type*} (s : Rel β β) (p : RelSeries r) (i : Fin p.length) (a : α) (prev_connect : r (p.toFun i.castSucc) a) (connect_next : r a (p.toFun i.succ)) (m : Fin (p.length + 1)) (x : α) (y : α) (hm : ↑i + 1 < ↑m ∨ ↑i + 1 = ↑m) : r x y := sorry | tactic | false | ['Mathlib', 'Order', 'RelSeries'] | null | leanprover/lean4:v4.11.0
| Mathlib | {"sorries":
[{"proofState": 0,
"pos": {"line": 10, "column": 264},
"goal":
"α : Type u_1\nβ : Type u_2\nr : Rel α α\ns : Rel β β\np : RelSeries r\ni : Fin p.length\na : α\nprev_connect : r (p.toFun i.castSucc) a\nconnect_next : r a (p.toFun i.succ)\nm : Fin (p.length + 1)\nx y : α\nhm : i + 1 < m ∨ i + 1 = m\n⊢ r x y",
"endPos": {"line": 10, "column": 269}}],
"messages":
[{"severity": "error",
"pos": {"line": 10, "column": 226},
"endPos": {"line": 10, "column": 232},
"data":
"failed to synthesize\n HAdd (Fin p.length) ℕ (Fin (p.length + 1))\nAdditional diagnostic information may be available using the `set_option diagnostics true` command."},
{"severity": "error",
"pos": {"line": 10, "column": 240},
"endPos": {"line": 10, "column": 246},
"data":
"failed to synthesize\n HAdd (Fin p.length) ℕ (Fin (p.length + 1))\nAdditional diagnostic information may be available using the `set_option diagnostics true` command."}],
"env": 0}
|
||||||||||
Filter.isBoundedUnder_ge_sum_tac_16270 | import Init
import Mathlib.Order.Filter.Cofinite
import Mathlib.Order.Hom.CompleteLattice
import Mathlib.Order.LiminfLimsup
open Filter Set Function
open Filter BigOperators Set
| import Init
import Mathlib.Order.Filter.Cofinite
import Mathlib.Order.Hom.CompleteLattice
import Mathlib.Order.LiminfLimsup
| open Filter Set Function
open Filter BigOperators Set
| lemma isBoundedUnder_ge_sum_tac_16270 (f : Filter α) [Preorder R] [AddCommMonoid R] [CovariantClass R R (fun a b => a + b) fun x x_1 => x ≤ x_1] [CovariantClass R R (fun a b => b + a) fun x x_1 => x ≤ x_1] (u : κ → α → R) (s : Finset κ) : (∀ k ∈ s, IsBoundedUnder (fun x x_1 => x ≥ x_1) f (u k)) → IsBoundedUnder (fun x x_1 => x ≥ x_1) f (∑ k ∈ s, u k) := sorry | lemma isBoundedUnder_ge_sum_tac_16270 {α : Type*} (f : Filter α) {R : Type*} [Preorder R] {κ : Type*} [AddCommMonoid R] [CovariantClass R R (fun a b => a + b) fun x x_1 => x ≤ x_1] [CovariantClass R R (fun a b => b + a) fun x x_1 => x ≤ x_1] (u : κ → α → R) (s : Finset κ) : (∀ k ∈ s, IsBoundedUnder (fun x x_1 => x ≥ x_1) f (u k)) → IsBoundedUnder (fun x x_1 => x ≥ x_1) f (∑ k ∈ s, u k) := sorry | [['x'], ['hy'], ['CovariantClass'], ['a'], ['aux'], ['R'], ['elim'], ['add_le_add_left'], ['b']] | tactic | true | ['Mathlib', 'Order', 'LiminfLimsup'] | null | leanprover/lean4:v4.11.0
| Mathlib | {"sorries":
[{"proofState": 0,
"pos": {"line": 8, "column": 356},
"goal":
"α : Type u_1\nR : Type u_2\nκ : Type u_3\nf : Filter α\ninst✝³ : Preorder R\ninst✝² : AddCommMonoid R\ninst✝¹ : CovariantClass R R (fun a b => a + b) fun x x_1 => x ≤ x_1\ninst✝ : CovariantClass R R (fun a b => b + a) fun x x_1 => x ≤ x_1\nu : κ → α → R\ns : Finset κ\n⊢ (∀ k ∈ s, IsBoundedUnder (fun x x_1 => x ≥ x_1) f (u k)) → IsBoundedUnder (fun x x_1 => x ≥ x_1) f (∑ k ∈ s, u k)",
"endPos": {"line": 8, "column": 361}}],
"messages":
[{"severity": "warning",
"pos": {"line": 8, "column": 6},
"endPos": {"line": 8, "column": 37},
"data": "declaration uses 'sorry'"}],
"env": 0}
|
||||||||
Convex.helly_theorem_compact'_tac_9592 | import Init
import Mathlib.Analysis.Convex.Combination
import Mathlib.Data.Set.Card
import Mathlib.LinearAlgebra.AffineSpace.FiniteDimensional
import Mathlib.Topology.Separation
import Mathlib.Analysis.Convex.Radon
open Fintype Finset Set
open FiniteDimensional
| import Init
import Mathlib.Analysis.Convex.Combination
import Mathlib.Data.Set.Card
import Mathlib.LinearAlgebra.AffineSpace.FiniteDimensional
import Mathlib.Topology.Separation
import Mathlib.Analysis.Convex.Radon
| open Fintype Finset Set
open FiniteDimensional
| lemma helly_theorem_compact'_tac_9592 [LinearOrderedField 𝕜] [AddCommGroup E] [Module 𝕜 E] [FiniteDimensional 𝕜 E] [TopologicalSpace E] [T2Space E] (F : ι → Set E) (h_convex : ∀ (i : ι), Convex 𝕜 (F i)) (h_compact : ∀ (i : ι), IsCompact (F i)) (h_inter : ∀ (I : Finset ι), I.card ≤ finrank 𝕜 E + 1 → (⋂ i ∈ I, F i).Nonempty) (h_nonempty : Nonempty ι) : (⋂ i, F i).Nonempty := sorry | lemma helly_theorem_compact'_tac_9592 {ι : Type*} {𝕜 : Type*} {E : Type*} [LinearOrderedField 𝕜] [AddCommGroup E] [Module 𝕜 E] [FiniteDimensional 𝕜 E] [TopologicalSpace E] [T2Space E] (F : ι → Set E) (h_convex : ∀ (i : ι), Convex 𝕜 (F i)) (h_compact : ∀ (i : ι), IsCompact (F i)) (h_inter : ∀ (I : Finset ι), I.card ≤ finrank 𝕜 E + 1 → (⋂ i ∈ I, F i).Nonempty) (h_nonempty : Nonempty ι) : (⋂ i, F i).Nonempty := sorry | [['hJ_card'], ["helly_theorem'"], ['I'], ['𝕜'], ['h_convex'], ['J'], ['Finset'], ['h_inter'], ['h_fin'], ['s'], ['ι'], ['F'], ['i'], ['Nonempty']] | tactic | null | ['Mathlib', 'Analysis', 'Convex', 'Radon'] | null | leanprover/lean4:v4.11.0
| Mathlib | |||||||||
antivaryOn_inv₀_tac_13151 | import Init
import Mathlib.Algebra.Order.Field.Basic
import Mathlib.Algebra.Order.Group.Instances
import Mathlib.Algebra.Order.Module.OrderedSMul
import Mathlib.Algebra.Order.Module.Synonym
import Mathlib.Algebra.Order.Monoid.Unbundled.MinMax
import Mathlib.Order.Monotone.Monovary
import Mathlib.Algebra.Order.Monovary
| import Init
import Mathlib.Algebra.Order.Field.Basic
import Mathlib.Algebra.Order.Group.Instances
import Mathlib.Algebra.Order.Module.OrderedSMul
import Mathlib.Algebra.Order.Module.Synonym
import Mathlib.Algebra.Order.Monoid.Unbundled.MinMax
import Mathlib.Order.Monotone.Monovary
import Mathlib.Algebra.Order.Monovary
| lemma antivaryOn_inv₀_tac_13151 [LinearOrderedSemifield α] [LinearOrderedSemifield β] (s : Set ι) (f : ι → α) (g : ι → β) (hf : ∀ i ∈ s, 0 < f i) (hg : ∀ i ∈ s, 0 < g i) : AntivaryOn f g s ↔ AntivaryOn f g s := sorry | lemma antivaryOn_inv₀_tac_13151 {ι : Type*} {α : Type*} {β : Type*} [LinearOrderedSemifield α] [LinearOrderedSemifield β] (s : Set ι) (f : ι → α) (g : ι → β) (hf : ∀ i ∈ s, 0 < f i) (hg : ∀ i ∈ s, 0 < g i) : AntivaryOn f g s ↔ AntivaryOn f g s := sorry | tactic | true | ['Mathlib', 'Algebra', 'Order', 'Monovary'] | null | leanprover/lean4:v4.11.0
| Mathlib | {"sorries":
[{"proofState": 0,
"pos": {"line": 11, "column": 211},
"goal":
"α : Type u_1\nβ : Type u_2\nι : Type u_3\ninst✝¹ : LinearOrderedSemifield α\ninst✝ : LinearOrderedSemifield β\ns : Set ι\nf : ι → α\ng : ι → β\nhf : ∀ i ∈ s, 0 < f i\nhg : ∀ i ∈ s, 0 < g i\n⊢ AntivaryOn f g s ↔ AntivaryOn f g s",
"endPos": {"line": 11, "column": 216}}],
"messages":
[{"severity": "warning",
"pos": {"line": 11, "column": 6},
"endPos": {"line": 11, "column": 31},
"data": "declaration uses 'sorry'"}],
"env": 0}
|
End of preview. Expand
in Dataset Viewer.
README.md exists but content is empty.
Use the Edit dataset card button to edit it.
- Downloads last month
- 35