Slashblade/extract_mathlib_notype · Datasets at Hugging Face

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

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

[['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

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

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

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

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

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

[['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

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

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

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

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

[['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

[['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

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

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

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}

FirstOrder.Language.DirectLimit.relMap_quotient_mk'_sigma_mk'_tac_10978

import Init import Mathlib.Data.Fintype.Order import Mathlib.Algebra.DirectLimit import Mathlib.ModelTheory.Quotients import Mathlib.ModelTheory.FinitelyGenerated import Mathlib.ModelTheory.DirectLimit open FirstOrder open Structure Set

import Init import Mathlib.Data.Fintype.Order import Mathlib.Algebra.DirectLimit import Mathlib.ModelTheory.Quotients import Mathlib.ModelTheory.FinitelyGenerated import Mathlib.ModelTheory.DirectLimit

open FirstOrder open Structure Set

lemma relMap_quotient_mk'_sigma_mk'_tac_10978 (L : Language) [Preorder ι] [(i : ι) → L.Structure (G i)] (f : (i j : ι) → i ≤ j → G i ↪[L] G j) [IsDirected ι fun x x_1 => x ≤ x_1] [DirectedSystem G fun i j h => ⇑(f i j h)] [Nonempty ι] (n : ℕ) (R : L.Relations n) (i : ι) (x : Fin n → G i) : (RelMap R fun a => ⟦Structure.Sigma.mk f i (x a)⟧) = RelMap R x := sorry

lemma relMap_quotient_mk'_sigma_mk'_tac_10978 (L : Language) {ι : Type*} [Preorder ι] {G : Type*} [(i : ι) → L.Structure (G i)] (f : (i j : ι) → i ≤ j → G i ↪[L] G j) [IsDirected ι fun x x_1 => x ≤ x_1] [DirectedSystem G fun i j h => ⇑(f i j h)] [Nonempty ι] (n : ℕ) (R : L.Relations n) (i : ι) (x : Fin n → G i) : (RelMap R fun a => ⟦Structure.Sigma.mk f i (x a)⟧) = RelMap R x := sorry

[['k'], ['Classical', 'choose'], ['x'], ['n'], ['relMap_equiv_unify'], ['G'], ['directed_of'], ['Finite', 'bddAbove_range'], ['a'], ['R'], ['f'], ['Fin'], ['i'], ['unify_sigma_mk_self'], ["relMap_quotient_mk'"], ['mk']]

tactic

false

['Mathlib', 'ModelTheory', 'DirectLimit']

null

leanprover/lean4:v4.11.0

Mathlib

{"sorries": [{"proofState": 0, "pos": {"line": 10, "column": 356}, "goal": "ι : Type u_1\nG : ι → Type u_2\nx✝ : Sort u_3\nRelMap : x✝\nL : Language\ninst✝⁴ : Preorder ι\ninst✝³ : (i : ι) → L.Structure (G i)\nf : (i j : ι) → i ≤ j → G i ↪[L] G j\ninst✝² : IsDirected ι fun x x_1 => x ≤ x_1\ninst✝¹ : DirectedSystem G fun i j h => sorryAx (G i → G j) true\ninst✝ : Nonempty ι\nn : ℕ\nR : L.Relations n\ni : ι\nx : Fin n → G i\n⊢ sorryAx (?m.780 L f n R i x) true = sorryAx (?m.780 L f n R i x) true", "endPos": {"line": 10, "column": 361}}], "messages": [{"severity": "error", "pos": {"line": 8, "column": 5}, "endPos": {"line": 8, "column": 14}, "data": "unknown namespace 'Structure'"}, {"severity": "error", "pos": {"line": 10, "column": 208}, "endPos": {"line": 10, "column": 218}, "data": "cannot coerce to function\n f i j h"}, {"severity": "error", "pos": {"line": 10, "column": 290}, "endPos": {"line": 10, "column": 338}, "data": "function expected at\n RelMap\nterm has type\n ?m.287"}, {"severity": "error", "pos": {"line": 10, "column": 342}, "endPos": {"line": 10, "column": 352}, "data": "function expected at\n RelMap\nterm has type\n ?m.287"}], "env": 0}

Convex.helly_theorem'_tac_3822

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'_tac_3822 [LinearOrderedField 𝕜] [AddCommGroup E] [Module 𝕜 E] [FiniteDimensional 𝕜 E] (F : ι → Set E) (s : Finset ι) (h_convex : ∀ i ∈ s, Convex 𝕜 (F i)) (h_inter : ∀ I ⊆ s, I.card ≤ finrank 𝕜 E + 1 → (⋂ i ∈ I, F i).Nonempty) (h_card : s.card < finrank 𝕜 E + 1) : (⋂ i ∈ s, F i).Nonempty := sorry

lemma helly_theorem'_tac_3822 {ι : Type*} {𝕜 : Type*} {E : Type*} [LinearOrderedField 𝕜] [AddCommGroup E] [Module 𝕜 E] [FiniteDimensional 𝕜 E] (F : ι → Set E) (s : Finset ι) (h_convex : ∀ i ∈ s, Convex 𝕜 (F i)) (h_inter : ∀ I ⊆ s, I.card ≤ finrank 𝕜 E + 1 → (⋂ i ∈ I, F i).Nonempty) (h_card : s.card < finrank 𝕜 E + 1) : (⋂ i ∈ s, F i).Nonempty := sorry

tactic

null

['Mathlib', 'Analysis', 'Convex', 'Radon']

null

leanprover/lean4:v4.11.0

Mathlib

Real.log_inv_tac_3764

import Init import Mathlib.Analysis.SpecialFunctions.Exp import Mathlib.Data.Nat.Factorization.Defs import Mathlib.Analysis.NormedSpace.Real import Mathlib.Data.Rat.Cast.CharZero import Mathlib.Analysis.SpecialFunctions.Log.Basic open Set Filter Function open Topology

import Init import Mathlib.Analysis.SpecialFunctions.Exp import Mathlib.Data.Nat.Factorization.Defs import Mathlib.Analysis.NormedSpace.Real import Mathlib.Data.Rat.Cast.CharZero import Mathlib.Analysis.SpecialFunctions.Log.Basic

open Set Filter Function open Topology

lemma log_inv_tac_3764 (x : ℝ) (hx : ¬x = 0) : log x⁻¹ = -log x := sorry

[['exp_log_eq_abs'], ['abs_inv'], ['hx'], ['exp_eq_exp'], ['exp_neg'], ['inv_ne_zero']]

tactic

false

['Mathlib', 'Analysis', 'SpecialFunctions', 'Log', 'Basic']

null

leanprover/lean4:v4.11.0

Mathlib

{"sorries": [{"proofState": 0, "pos": {"line": 10, "column": 67}, "goal": "x✝ : Sort u_1\nlog : x✝\nx : ℝ\nhx : ¬x = 0\n⊢ sorryAx ℤ true = -sorryAx ℤ true", "endPos": {"line": 10, "column": 72}}], "messages": [{"severity": "error", "pos": {"line": 10, "column": 47}, "endPos": {"line": 10, "column": 54}, "data": "function expected at\n log\nterm has type\n ?m.51"}, {"severity": "error", "pos": {"line": 10, "column": 58}, "endPos": {"line": 10, "column": 63}, "data": "function expected at\n log\nterm has type\n ?m.51"}], "env": 0}

Ordinal.derivBFamily_eq_enumOrd_tac_14782

import Init import Mathlib.SetTheory.Ordinal.Arithmetic import Mathlib.SetTheory.Ordinal.Exponential import Mathlib.SetTheory.Ordinal.FixedPoint open Function Order

import Init import Mathlib.SetTheory.Ordinal.Arithmetic import Mathlib.SetTheory.Ordinal.Exponential import Mathlib.SetTheory.Ordinal.FixedPoint

open Function Order

lemma derivBFamily_eq_enumOrd_tac_14782 (o : Ordinal.{u}) (f : (b : Ordinal.{u}) → b < o → Ordinal.{max u v} → Ordinal.{max u v}) (H : ∀ (i : Ordinal.{u}) (hi : i < o), IsNormal (f i hi)) (a : Ordinal.{max u v}) (ha : ∀ (i : Ordinal.{u}) (j : i < o), a ∈ fixedPoints (f i j)) : ∃ a_1, o.derivBFamily f a_1 = a := sorry

tactic

false

['Mathlib', 'SetTheory', 'Ordinal', 'FixedPoint']

null

leanprover/lean4:v4.11.0

Mathlib

{"sorries": [{"proofState": 0, "pos": {"line": 7, "column": 313}, "goal": "x✝ : Sort u_1\nIsNormal : x✝\no : Ordinal.{u}\nf : (b : Ordinal.{u}) → b < o → Ordinal.{max u v} → Ordinal.{max u v}\nH : (i : Ordinal.{u}) → i < o → sorryAx (Sort u_2) true\na : Ordinal.{max u v}\nha : ∀ (i : Ordinal.{u}) (j : i < o), a ∈ fixedPoints (f i j)\n⊢ ∃ a_1, o.derivBFamily f a_1 = a", "endPos": {"line": 7, "column": 318}}], "messages": [{"severity": "error", "pos": {"line": 7, "column": 169}, "endPos": {"line": 7, "column": 186}, "data": "function expected at\n IsNormal\nterm has type\n ?m.58"}], "env": 0}

WithOne.map_comp_tac_4195

import Init import Mathlib.Algebra.Group.Equiv.Basic import Mathlib.Algebra.Group.WithOne.Defs import Mathlib.Algebra.Group.WithOne.Basic

lemma map_comp_tac_4195 [Mul α] [Mul β] [Mul γ] (e : α ≃* β) : (map e.toMulHom) ((map e.symm.toMulHom) 1) = 1 := sorry

lemma map_comp_tac_4195 {α : Type*} {β : Type*} {γ : Type*} [Mul α] [Mul β] [Mul γ] (e : α ≃* β) : (map e.toMulHom) ((map e.symm.toMulHom) 1) = 1 := sorry

tactic

false

['Mathlib', 'Algebra', 'Group', 'WithOne', 'Basic']

null

leanprover/lean4:v4.11.0

Mathlib

{"sorries": [{"proofState": 0, "pos": {"line": 7, "column": 113}, "goal": "α : Type u_1\nβ : Type u_2\nγ : Type u_3\nx✝ : Sort u_4\nmap : x✝\ninst✝² : Mul α\ninst✝¹ : Mul β\ninst✝ : Mul γ\ne : α ≃* β\n⊢ sorryAx ℕ true = 1", "endPos": {"line": 7, "column": 118}}], "messages": [{"severity": "error", "pos": {"line": 7, "column": 64}, "endPos": {"line": 7, "column": 78}, "data": "function expected at\n map\nterm has type\n ?m.55"}], "env": 0}

Real.Angle.cos_eq_iff_coe_eq_or_eq_neg_tac_8511

import Init import Mathlib.Analysis.SpecialFunctions.Trigonometric.Basic import Mathlib.Analysis.Normed.Group.AddCircle import Mathlib.Algebra.CharZero.Quotient import Mathlib.Topology.Instances.Sign import Mathlib.Analysis.SpecialFunctions.Trigonometric.Angle open Real

import Init import Mathlib.Analysis.SpecialFunctions.Trigonometric.Basic import Mathlib.Analysis.Normed.Group.AddCircle import Mathlib.Algebra.CharZero.Quotient import Mathlib.Topology.Instances.Sign import Mathlib.Analysis.SpecialFunctions.Trigonometric.Angle

open Real

lemma cos_eq_iff_coe_eq_or_eq_neg_tac_8511 (θ : ℝ) (ψ : ℝ) (n : ℤ) (hn : ↑n * π * 2 + ψ = θ) : ↑ψ = ↑ψ := sorry

tactic

true

['Mathlib', 'Analysis', 'SpecialFunctions', 'Trigonometric', 'Angle']

null

leanprover/lean4:v4.11.0

Mathlib

{"sorries": [{"proofState": 0, "pos": {"line": 9, "column": 106}, "goal": "θ ψ : ℝ\nn : ℤ\nhn : ↑n * π * 2 + ψ = θ\n⊢ ψ = ψ", "endPos": {"line": 9, "column": 111}}], "messages": [{"severity": "warning", "pos": {"line": 9, "column": 6}, "endPos": {"line": 9, "column": 42}, "data": "declaration uses 'sorry'"}], "env": 0}

Matrix.rank_eq_finrank_span_row_tac_11315

import Init import Mathlib.LinearAlgebra.Determinant import Mathlib.LinearAlgebra.FiniteDimensional import Mathlib.LinearAlgebra.Matrix.Diagonal import Mathlib.LinearAlgebra.Matrix.DotProduct import Mathlib.LinearAlgebra.Matrix.Dual import Mathlib.Data.Matrix.Rank open Matrix open FiniteDimensional

import Init import Mathlib.LinearAlgebra.Determinant import Mathlib.LinearAlgebra.FiniteDimensional import Mathlib.LinearAlgebra.Matrix.Diagonal import Mathlib.LinearAlgebra.Matrix.DotProduct import Mathlib.LinearAlgebra.Matrix.Dual import Mathlib.Data.Matrix.Rank

open Matrix open FiniteDimensional

lemma rank_eq_finrank_span_row_tac_11315 [Field R] [Finite m] (A : Matrix m n R) : finrank R ↥(Submodule.span R (Set.range A)) = finrank R ↥(Submodule.span R (Set.range A)) := sorry

lemma rank_eq_finrank_span_row_tac_11315 {m : Type*} {n : Type*} {R : Type*} {inst✝² : Type*} [Field R] [Finite m] (A : Matrix m n R) {val✝ : Type*} : finrank R ↥(Submodule.span R (Set.range A)) = finrank R ↥(Submodule.span R (Set.range A)) := sorry

tactic

true

['Mathlib', 'Data', 'Matrix', 'Rank']

null

leanprover/lean4:v4.11.0

Mathlib

{"sorries": [{"proofState": 0, "pos": {"line": 11, "column": 176}, "goal": "R : Type u_1\nm : Type u_2\nn : Type u_3\ninst✝¹ : Field R\ninst✝ : Finite m\nA : Matrix m n R\n⊢ finrank R ↥(Submodule.span R (Set.range A)) = finrank R ↥(Submodule.span R (Set.range A))", "endPos": {"line": 11, "column": 181}}], "messages": [{"severity": "warning", "pos": {"line": 11, "column": 6}, "endPos": {"line": 11, "column": 40}, "data": "declaration uses 'sorry'"}], "env": 0}

Multiset.one_le_count_iff_mem_tac_82604

import Init import Mathlib.Algebra.Group.Nat import Mathlib.Algebra.Order.Sub.Unbundled.Basic import Mathlib.Data.List.Perm import Mathlib.Data.Set.List import Mathlib.Order.Hom.Basic import Mathlib.Data.Multiset.Basic open List Subtype Nat Function

import Init import Mathlib.Algebra.Group.Nat import Mathlib.Algebra.Order.Sub.Unbundled.Basic import Mathlib.Data.List.Perm import Mathlib.Data.Set.List import Mathlib.Order.Hom.Basic import Mathlib.Data.Multiset.Basic

open List Subtype Nat Function

lemma one_le_count_iff_mem_tac_82604 [DecidableEq α] (a : α) (s : Multiset α) : 1 ≤ count a s ↔ a ∈ s := sorry

lemma one_le_count_iff_mem_tac_82604 {α : Type*} [DecidableEq α] (a : α) (s : Multiset α) : 1 ≤ count a s ↔ a ∈ s := sorry

[['succ_le_iff'], ['count_pos']]

tactic

false

['Mathlib', 'Data', 'Multiset', 'Basic']

null

leanprover/lean4:v4.11.0

Mathlib

{"sorries": [{"proofState": 0, "pos": {"line": 10, "column": 105}, "goal": "α : Type u_1\ninst✝ : DecidableEq α\na : α\ns : Multiset α\n⊢ 1 ≤ count a (sorryAx (List α) true) ↔ a ∈ s", "endPos": {"line": 10, "column": 110}}], "messages": [{"severity": "error", "pos": {"line": 10, "column": 92}, "endPos": {"line": 10, "column": 93}, "data": "application type mismatch\n count a s\nargument\n s\nhas type\n Multiset α : Type ?u.18\nbut is expected to have type\n List α : Type ?u.18"}], "env": 0}

List.get_reverse_aux₁_tac_34266

import Init import Mathlib.Data.Nat.Defs import Mathlib.Data.Option.Basic import Mathlib.Data.List.Defs import Mathlib.Data.List.Monad import Mathlib.Init.Data.List.Lemmas import Mathlib.Logic.Unique import Mathlib.Order.Basic import Mathlib.Tactic.Common import Batteries.Data.List.Perm import Mathlib.Data.List.Basic open Function open Nat hiding one_pos

import Init import Mathlib.Data.Nat.Defs import Mathlib.Data.Option.Basic import Mathlib.Data.List.Defs import Mathlib.Data.List.Monad import Mathlib.Init.Data.List.Lemmas import Mathlib.Logic.Unique import Mathlib.Order.Basic import Mathlib.Tactic.Common import Batteries.Data.List.Perm import Mathlib.Data.List.Basic

open Function open Nat hiding one_pos

lemma get_reverse_aux₁_tac_34266 (a : α) (l : List α) (r : List α) (i : ℕ) : ∀ (h1 : i + (a :: l).length < ((a :: l).reverseAux r).length) (h2 : i < r.length), ((a :: l).reverseAux r).get ⟨i + (a :: l).length, h1⟩ = r.get ⟨i, h2⟩ := sorry

lemma get_reverse_aux₁_tac_34266 {α : Type*} (a : α) (l : List α) (r : List α) (i : ℕ) : ∀ (h1 : i + (a :: l).length < ((a :: l).reverseAux r).length) (h2 : i < r.length), ((a :: l).reverseAux r).get ⟨i + (a :: l).length, h1⟩ = r.get ⟨i, h2⟩ := sorry

[['get_reverse_aux₁'], ['h1'], ['succ_lt_succ'], ['Nat', 'add_right_comm'], ['length'], ['h2'], ['a'], ['r'], ['l'], ['i']]

tactic

true

['Mathlib', 'Data', 'List', 'Basic']

null

leanprover/lean4:v4.11.0

Mathlib

{"sorries": [{"proofState": 0, "pos": {"line": 16, "column": 75}, "goal": "α : Type u_1\na : α\nl r : List α\ni : ℕ\n⊢ ∀ (h1 : i + (a :: l).length < ((a :: l).reverseAux r).length) (h2 : i < r.length),\n ((a :: l).reverseAux r).get ⟨i + (a :: l).length, h1⟩ = r.get ⟨i, h2⟩", "endPos": {"line": 16, "column": 80}}], "messages": [{"severity": "warning", "pos": {"line": 15, "column": 6}, "endPos": {"line": 15, "column": 32}, "data": "declaration uses 'sorry'"}], "env": 0}

jacobiSym.quadratic_reciprocity'_tac_19153

import Init import Mathlib.NumberTheory.LegendreSymbol.QuadraticReciprocity import Mathlib.NumberTheory.LegendreSymbol.JacobiSymbol open Nat ZMod open NumberTheorySymbols open jacobiSym

import Init import Mathlib.NumberTheory.LegendreSymbol.QuadraticReciprocity import Mathlib.NumberTheory.LegendreSymbol.JacobiSymbol

open Nat ZMod open NumberTheorySymbols open jacobiSym

lemma quadratic_reciprocity'_tac_19153 (a : ℕ) (b : ℕ) (ha : Odd a) (hb : Odd b) (rhs : ℕ → ℕ →* ℤ) (rhs_apply : ∀ (a b : ℕ), (rhs a) b = qrSign b a * J(↑b | a)) (p : ℕ) (pp : Nat.Prime p) (hp : p ≠ 2) (hpo : Odd p) : J(↑p | a) = qrSign a p * J(↑a | p) := sorry

tactic

null

['Mathlib', 'NumberTheory', 'LegendreSymbol', 'JacobiSymbol']

null

leanprover/lean4:v4.11.0

Mathlib

List.prev_getLast_cons'_tac_6797

import Init import Mathlib.Data.Fintype.List import Mathlib.Data.List.Cycle

lemma prev_getLast_cons'_tac_6797 [DecidableEq α] (l : List α) (x : α) (y : α) (hxy : x ∈ y :: l) (hx : x = y) : (y :: l).prev x hxy = (y :: l).getLast ⋯ := sorry

lemma prev_getLast_cons'_tac_6797 {α : Type*} [DecidableEq α] (l : List α) (x : α) (y : α) (hxy : x ∈ y :: l) (hx : x = y) : (y :: l).prev x hxy = (y :: l).getLast ⋯ := sorry

tactic

null

['Mathlib', 'Data', 'List', 'Cycle']

null

leanprover/lean4:v4.11.0

Mathlib

Subgroup.subgroupOf_eq_top_tac_50626

import Init import Mathlib.Algebra.Group.Conj import Mathlib.Algebra.Group.Pi.Lemmas import Mathlib.Algebra.Group.Subsemigroup.Operations import Mathlib.Algebra.Group.Submonoid.Operations import Mathlib.Data.Set.Image import Mathlib.Tactic.ApplyFun import Mathlib.Algebra.Group.Subgroup.Basic open Function open scoped Int open Set

import Init import Mathlib.Algebra.Group.Conj import Mathlib.Algebra.Group.Pi.Lemmas import Mathlib.Algebra.Group.Subsemigroup.Operations import Mathlib.Algebra.Group.Submonoid.Operations import Mathlib.Data.Set.Image import Mathlib.Tactic.ApplyFun import Mathlib.Algebra.Group.Subgroup.Basic

open Function open scoped Int open Set

lemma subgroupOf_eq_top_tac_50626 [Group G] (H : Subgroup G) (K : Subgroup G) : H.subgroupOf K = ⊤ ↔ K ≤ H := sorry

lemma subgroupOf_eq_top_tac_50626 {G : Type*} [Group G] (H : Subgroup G) (K : Subgroup G) : H.subgroupOf K = ⊤ ↔ K ≤ H := sorry

[['top_inf_eq'], ['subgroupOf_inj'], ['top_subgroupOf'], ['inf_eq_right']]

tactic

true

['Mathlib', 'Algebra', 'Group', 'Subgroup', 'Basic']

null

leanprover/lean4:v4.11.0

Mathlib

{"sorries": [{"proofState": 0, "pos": {"line": 13, "column": 110}, "goal": "G : Type u_1\ninst✝ : Group G\nH K : Subgroup G\n⊢ H.subgroupOf K = ⊤ ↔ K ≤ H", "endPos": {"line": 13, "column": 115}}], "messages": [{"severity": "warning", "pos": {"line": 13, "column": 6}, "endPos": {"line": 13, "column": 33}, "data": "declaration uses 'sorry'"}], "env": 0}

Fin.cycleRange_zero_tac_7763

import Init import Mathlib.GroupTheory.Perm.Cycle.Type import Mathlib.GroupTheory.Perm.Option import Mathlib.Logic.Equiv.Fin import Mathlib.Logic.Equiv.Fintype import Mathlib.GroupTheory.Perm.Fin open Equiv open Equiv.Perm

import Init import Mathlib.GroupTheory.Perm.Cycle.Type import Mathlib.GroupTheory.Perm.Option import Mathlib.Logic.Equiv.Fin import Mathlib.Logic.Equiv.Fintype import Mathlib.GroupTheory.Perm.Fin

open Equiv open Equiv.Perm

lemma cycleRange_zero_tac_7763 (n : ℕ) (j : Fin n) : ↑((cycleRange 0) j.succ) = ↑(1 j.succ) := sorry

lemma cycleRange_zero_tac_7763 (n : ℕ) (j✝ : Fin n.succ) (j : Fin n) : ↑((cycleRange 0) j.succ) = ↑(1 j.succ) := sorry

[['cycleRange_of_gt'], ['j'], ['one_apply'], ['Fin', 'succ_pos']]

tactic

false

['Mathlib', 'GroupTheory', 'Perm', 'Fin']

null

leanprover/lean4:v4.11.0

Mathlib

{"sorries": [{"proofState": 0, "pos": {"line": 10, "column": 95}, "goal": "x✝ : Sort u_1\ncycleRange : x✝\nn : ℕ\nj : Fin n\n⊢ sorryAx (?m.222 n j) true = sorryAx (?m.222 n j) true", "endPos": {"line": 10, "column": 100}}], "messages": [{"severity": "error", "pos": {"line": 10, "column": 56}, "endPos": {"line": 10, "column": 68}, "data": "function expected at\n cycleRange\nterm has type\n ?m.15"}, {"severity": "error", "pos": {"line": 10, "column": 82}, "endPos": {"line": 10, "column": 90}, "data": "function expected at\n 1\nterm has type\n ?m.161"}], "env": 0}

Commute.geom_sum₂_mul_tac_6245

import Init import Mathlib.Algebra.BigOperators.Intervals import Mathlib.Algebra.BigOperators.Ring import Mathlib.Algebra.Group.NatPowAssoc import Mathlib.Algebra.Order.BigOperators.Ring.Finset import Mathlib.Algebra.Order.Field.Basic import Mathlib.Algebra.Order.Ring.Abs import Mathlib.Algebra.Ring.Opposite import Mathlib.Tactic.Abel import Mathlib.Algebra.Ring.Regular import Mathlib.Algebra.GeomSum open Finset MulOpposite

import Init import Mathlib.Algebra.BigOperators.Intervals import Mathlib.Algebra.BigOperators.Ring import Mathlib.Algebra.Group.NatPowAssoc import Mathlib.Algebra.Order.BigOperators.Ring.Finset import Mathlib.Algebra.Order.Field.Basic import Mathlib.Algebra.Order.Ring.Abs import Mathlib.Algebra.Ring.Opposite import Mathlib.Tactic.Abel import Mathlib.Algebra.Ring.Regular import Mathlib.Algebra.GeomSum

open Finset MulOpposite

lemma geom_sum₂_mul_tac_6245 [Ring α] (x : α) (y : α) (h : Commute x y) (n : ℕ) (this : (∑ i ∈ range n, x ^ i * y ^ (n - 1 - i)) * (x - y) + y ^ n = x ^ n) : (∑ i ∈ range n, x ^ i * y ^ (n - 1 - i)) * (x - y) = x ^ n - y ^ n := sorry

lemma geom_sum₂_mul_tac_6245 {α : Type*} [Ring α] (x : α) (y : α) (h : Commute x y) (n : ℕ) (this : (∑ i ∈ range n, x ^ i * y ^ (n - 1 - i)) * (x - y) + y ^ n = x ^ n) : (∑ i ∈ range n, x ^ i * y ^ (n - 1 - i)) * (x - y) = x ^ n - y ^ n := sorry

tactic

true

['Mathlib', 'Algebra', 'GeomSum']

null

leanprover/lean4:v4.11.0

Mathlib

{"sorries": [{"proofState": 0, "pos": {"line": 14, "column": 228}, "goal": "α : Type u_1\ninst✝ : Ring α\nx y : α\nh : Commute x y\nn : ℕ\nthis : (∑ i ∈ range n, x ^ i * y ^ (n - 1 - i)) * (x - y) + y ^ n = x ^ n\n⊢ (∑ i ∈ range n, x ^ i * y ^ (n - 1 - i)) * (x - y) = x ^ n - y ^ n", "endPos": {"line": 14, "column": 233}}], "messages": [{"severity": "warning", "pos": {"line": 14, "column": 6}, "endPos": {"line": 14, "column": 28}, "data": "declaration uses 'sorry'"}], "env": 0}

Function.OfArity.curryEquiv

import Init import Mathlib.Data.Fin.Tuple.Basic import Mathlib.Logic.Equiv.Fin import Mathlib.Logic.Function.OfArity import Mathlib.Data.Fin.Tuple.Curry open Matrix (vecCons vecHead vecTail vecEmpty)

import Init import Mathlib.Data.Fin.Tuple.Basic import Mathlib.Logic.Equiv.Fin import Mathlib.Logic.Function.OfArity import Mathlib.Data.Fin.Tuple.Curry

open Matrix (vecCons vecHead vecTail vecEmpty)

/-- `Equiv.curry` for n-ary functions. -/ @[simps!] def curryEquiv (n : ℕ) : ((Fin n → α) → β) ≃ OfArity α β n := sorry

def curryEquiv_extracted : {α β : Type u} → (n : ℕ) → ((Fin n → α) → β) ≃ Function.OfArity α β n := sorry

[['Equiv'], ['Function', 'OfArity']]

/-- `Equiv.curry` for n-ary functions. -/ @[simps!] def curryEquiv (n : ℕ) : ((Fin n → α) → β) ≃ OfArity α β n := FromTypes.curryEquiv _

[['Function', 'FromTypes', 'curryEquiv']]

`Equiv.curry` for n-ary functions.

theorem

Syntax(original=True, range=StringRange(start=4623, stop=4773))

false

['Mathlib', 'Data', 'Fin', 'Tuple', 'Curry']

null

leanprover/lean4:v4.11.0

Mathlib

{"sorries": [{"proofState": 0, "pos": {"line": 10, "column": 62}, "goal": "α : Sort u_1\nβ : Sort u_2\nx✝ : Sort u_3\nOfArity : x✝\nn : ℕ\n⊢ ((Fin n → α) → β) ≃ sorryAx (Sort u_4) true", "endPos": {"line": 10, "column": 67}}], "messages": [{"severity": "error", "pos": {"line": 10, "column": 45}, "endPos": {"line": 10, "column": 58}, "data": "function expected at\n OfArity\nterm has type\n ?m.36"}], "env": 0}

Filter.HasBasis.comap_tac_34344

import Init import Mathlib.Data.Prod.PProd import Mathlib.Data.Set.Countable import Mathlib.Order.Filter.Prod import Mathlib.Order.Filter.Ker import Mathlib.Order.Filter.Bases open Set Filter

import Init import Mathlib.Data.Prod.PProd import Mathlib.Data.Set.Countable import Mathlib.Order.Filter.Prod import Mathlib.Order.Filter.Ker import Mathlib.Order.Filter.Bases

open Set Filter

lemma comap_tac_34344 (ι : Sort u_4) (l : Filter α) (p : ι → Prop) (s : ι → Set α) (f : β → α) (hl : l.HasBasis p s) (t : Set β) (i : ι) (h : f ⁻¹' s i ⊆ t) (y : α) (hy : y ∈ s i) (x : β) (hx : f x = y) : x ∈ f ⁻¹' s i := sorry

lemma comap_tac_34344 {α : Type*} {β : Type*} (ι : Sort u_4) (l : Filter α) (p : ι → Prop) (s : ι → Set α) (f : β → α) (hl : l.HasBasis p s) (t : Set β) (i : ι) (h : f ⁻¹' s i ⊆ t) (y : α) (hy : y ∈ s i) (x : β) (hx : f x = y) : x ∈ f ⁻¹' s i := sorry

[['hx'], ['mem_preimage']]

tactic

null

['Mathlib', 'Order', 'Filter', 'Bases']

null

leanprover/lean4:v4.11.0

Mathlib

NNReal.exists_lt_of_strictMono_tac_42480

import Init import Mathlib.Algebra.Algebra.Defs import Mathlib.Algebra.Order.BigOperators.Ring.Finset import Mathlib.Algebra.Order.Field.Canonical.Basic import Mathlib.Algebra.Order.Nonneg.Field import Mathlib.Algebra.Order.Nonneg.Floor import Mathlib.Data.Real.Pointwise import Mathlib.Order.ConditionallyCompleteLattice.Group import Mathlib.Tactic.Bound.Attribute import Mathlib.Tactic.GCongr.Core import Mathlib.Algebra.Ring.Regular import Mathlib.Data.NNReal.Basic open Function open NNReal open Real open Set open NNReal

import Init import Mathlib.Algebra.Algebra.Defs import Mathlib.Algebra.Order.BigOperators.Ring.Finset import Mathlib.Algebra.Order.Field.Canonical.Basic import Mathlib.Algebra.Order.Nonneg.Field import Mathlib.Algebra.Order.Nonneg.Floor import Mathlib.Data.Real.Pointwise import Mathlib.Order.ConditionallyCompleteLattice.Group import Mathlib.Tactic.Bound.Attribute import Mathlib.Tactic.GCongr.Core import Mathlib.Algebra.Ring.Regular import Mathlib.Data.NNReal.Basic

open Function open NNReal open Real open Set open NNReal

lemma exists_lt_of_strictMono_tac_42480 [LinearOrderedCommGroupWithZero Γ₀] (h : Nontrivial Γ₀ˣ) (f : Γ₀ →*₀ ℝ≥0) (hf : StrictMono ⇑f) (r : ℝ≥0) (hr : 0 < r) (g : Γ₀ˣ) (hg1 : g ≠ 1) (u : Γ₀ˣ) (hu : u = if g < 1 then g else g⁻¹) (hfu : f ↑u < 1) (n : ℕ) (hn : f ↑u ^ n < r) : f ↑u ^ n < r := sorry

lemma exists_lt_of_strictMono_tac_42480 {Γ₀ : Type*} [LinearOrderedCommGroupWithZero Γ₀] (h : Nontrivial Γ₀ˣ) (f : Γ₀ →*₀ ℝ≥0) (hf : StrictMono ⇑f) (r : ℝ≥0) (hr : 0 < r) (g : Γ₀ˣ) (hg1 : g ≠ 1) (u : Γ₀ˣ) (hu : u = if g < 1 then g else g⁻¹) (hfu : f ↑u < 1) (n : ℕ) (hn : f ↑u ^ n < r) : f ↑u ^ n < r := sorry

tactic

true

['Mathlib', 'Data', 'NNReal', 'Basic']

null

leanprover/lean4:v4.11.0

Mathlib

{"sorries": [{"proofState": 0, "pos": {"line": 19, "column": 291}, "goal": "Γ₀ : Type u_1\ninst✝ : LinearOrderedCommGroupWithZero Γ₀\nh : Nontrivial Γ₀ˣ\nf : Γ₀ →*₀ ℝ≥0\nhf : StrictMono ⇑f\nr : ℝ≥0\nhr : 0 < r\ng : Γ₀ˣ\nhg1 : g ≠ 1\nu : Γ₀ˣ\nhu : u = if g < 1 then g else g⁻¹\nhfu : f ↑u < 1\nn : ℕ\nhn : f ↑u ^ n < r\n⊢ f ↑u ^ n < r", "endPos": {"line": 19, "column": 296}}], "messages": [{"severity": "warning", "pos": {"line": 19, "column": 6}, "endPos": {"line": 19, "column": 39}, "data": "declaration uses 'sorry'"}], "env": 0}

Behrend.four_zero_nine_six_lt_exp_sixteen_tac_20938

import Init import Mathlib.Analysis.InnerProductSpace.PiL2 import Mathlib.Combinatorics.Additive.AP.Three.Defs import Mathlib.Combinatorics.Pigeonhole import Mathlib.Data.Complex.ExponentialBounds import Mathlib.Combinatorics.Additive.AP.Three.Behrend open Nat hiding log open Finset Metric Real open scoped Pointwise open scoped Filter Topology open Real

import Init import Mathlib.Analysis.InnerProductSpace.PiL2 import Mathlib.Combinatorics.Additive.AP.Three.Defs import Mathlib.Combinatorics.Pigeonhole import Mathlib.Data.Complex.ExponentialBounds import Mathlib.Combinatorics.Additive.AP.Three.Behrend

open Nat hiding log open Finset Metric Real open scoped Pointwise open scoped Filter Topology open Real

lemma four_zero_nine_six_lt_exp_sixteen_tac_20938 : 12 * log 2 < 16 := sorry

tactic

true

['Mathlib', 'Combinatorics', 'Additive', 'AP', 'Three', 'Behrend']

null

leanprover/lean4:v4.11.0

Mathlib

{"sorries": [{"proofState": 0, "pos": {"line": 13, "column": 72}, "goal": "⊢ 12 * log 2 < 16", "endPos": {"line": 13, "column": 77}}], "messages": [{"severity": "warning", "pos": {"line": 13, "column": 6}, "endPos": {"line": 13, "column": 49}, "data": "declaration uses 'sorry'"}], "env": 0}

Units.liftRight_inv_mul_tac_4798

import Init import Mathlib.Algebra.Group.Hom.Defs import Mathlib.Algebra.Group.Units import Mathlib.Algebra.Group.Units.Hom open Function

import Init import Mathlib.Algebra.Group.Hom.Defs import Mathlib.Algebra.Group.Units import Mathlib.Algebra.Group.Units.Hom

open Function

lemma liftRight_inv_mul_tac_4798 [Monoid M] [Monoid N] (f : M →* N) (g : M → Nˣ) (h : ∀ (x : M), ↑(g x) = f x) (x : M) : ↑((liftRight f g h) x)⁻¹ * f x = 1 := sorry

lemma liftRight_inv_mul_tac_4798 {M : Type*} {N : Type*} [Monoid M] [Monoid N] (f : M →* N) (g : M → Nˣ) (h : ∀ (x : M), ↑(g x) = f x) (x : M) : ↑((liftRight f g h) x)⁻¹ * f x = 1 := sorry

[['mul_one'], ['coe_liftRight'], ['Units', 'inv_mul_eq_iff_eq_mul']]

tactic

false

['Mathlib', 'Algebra', 'Group', 'Units', 'Hom']

null

leanprover/lean4:v4.11.0

Mathlib

{"sorries": [{"proofState": 0, "pos": {"line": 7, "column": 159}, "goal": "M : Type u_1\nN : Type u_2\nx✝ : Sort u_3\nliftRight : x✝\ninst✝¹ : Monoid M\ninst✝ : Monoid N\nf : M →* N\ng : M → Nˣ\nh : ∀ (x : M), ↑(g x) = f x\nx : M\n⊢ (sorryAx N true)⁻¹ * f x = 1", "endPos": {"line": 7, "column": 164}}], "messages": [{"severity": "error", "pos": {"line": 7, "column": 122}, "endPos": {"line": 7, "column": 145}, "data": "failed to synthesize\n Inv N\nAdditional diagnostic information may be available using the `set_option diagnostics true` command."}, {"severity": "error", "pos": {"line": 7, "column": 124}, "endPos": {"line": 7, "column": 139}, "data": "function expected at\n liftRight\nterm has type\n ?m.422"}], "env": 0}