name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
Lean.Compiler.LCNF.CompilerM.instInhabitedState | Lean.Compiler.LCNF.CompilerM | Inhabited Lean.Compiler.LCNF.CompilerM.State | true |
Submodule.colon_union | Mathlib.RingTheory.Ideal.Colon | ∀ {R : Type u_1} {M : Type u_2} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] {N : Submodule R M}
{S₁ S₂ : Set M}, N.colon (S₁ ∪ S₂) = N.colon S₁ ⊓ N.colon S₂ | true |
CategoryTheory.Functor.LaxMonoidal.rec | Mathlib.CategoryTheory.Monoidal.Functor | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
[inst_1 : CategoryTheory.MonoidalCategory C] →
{D : Type u₂} →
[inst_2 : CategoryTheory.Category.{v₂, u₂} D] →
[inst_3 : CategoryTheory.MonoidalCategory D] →
{F : CategoryTheory.Functor C D} →
{motive :... | false |
_private.Mathlib.Algebra.Homology.Factorizations.CM5a.0.CochainComplex.Plus.modelCategoryQuillen.cm5a_cof.step₂ | Mathlib.Algebra.Homology.Factorizations.CM5a | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Abelian C]
{K L : CochainComplex C ℤ} (f : K ⟶ L) [CategoryTheory.EnoughInjectives C] [CategoryTheory.Mono f] (n₀ n₁ : ℤ),
(∀ i ≤ n₀, QuasiIsoAt f i) →
∀ [CategoryTheory.Mono (HomologicalComplex.homologyMap f n₁)],
aut... | true |
String.endExclusive_slice | Init.Data.String.Basic | ∀ {s : String} {startInclusive endExclusive : s.Pos} {h : startInclusive ≤ endExclusive},
(s.slice startInclusive endExclusive h).endExclusive = endExclusive | true |
AugmentedSimplexCategory.tensorObj | Mathlib.AlgebraicTopology.SimplexCategory.Augmented.Monoidal | AugmentedSimplexCategory → AugmentedSimplexCategory → AugmentedSimplexCategory | true |
CategoryTheory.ofTypeMonad._proof_4 | Mathlib.CategoryTheory.Monad.Types | ∀ (m : Type u_1 → Type u_1) [inst : Monad m] [inst_1 : LawfulMonad m] (x : Type u_1),
CategoryTheory.CategoryStruct.comp
((CategoryTheory.ofTypeFunctor m).map ({ app := @joinM m inst, naturality := ⋯ }.app x))
({ app := @joinM m inst, naturality := ⋯ }.app x) =
CategoryTheory.CategoryStruct.comp
... | false |
MeasureTheory.LevyProkhorov.edist_measure_def | Mathlib.MeasureTheory.Measure.LevyProkhorovMetric | ∀ {Ω : Type u_1} [inst : MeasurableSpace Ω] [inst_1 : PseudoEMetricSpace Ω] [inst_2 : OpensMeasurableSpace Ω]
(μ ν : MeasureTheory.LevyProkhorov (MeasureTheory.Measure Ω)),
edist μ ν = MeasureTheory.levyProkhorovEDist μ.toMeasure ν.toMeasure | true |
ContMDiffAt.comp₂ | Mathlib.Geometry.Manifold.ContMDiff.Constructions | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {H : Type u_3} [inst_3 : TopologicalSpace H] {I : ModelWithCorners 𝕜 E H} {M : Type u_4}
[inst_4 : TopologicalSpace M] [inst_5 : ChartedSpace H M] {E' : Type u_5} [inst_6 : NormedAddComm... | true |
Lean.Loop.ctorIdx | Init.While | Lean.Loop → ℕ | false |
CategoryTheory.IsSifted.nonempty | Mathlib.CategoryTheory.Limits.Sifted | ∀ {C : Type u} {inst : CategoryTheory.Category.{v, u} C} [self : CategoryTheory.IsSifted C], Nonempty C | true |
UInt32.reduceDiv._regBuiltin.UInt32.reduceDiv.declare_1._@.Lean.Meta.Tactic.Simp.BuiltinSimprocs.UInt.2998934274._hygCtx._hyg.99 | Lean.Meta.Tactic.Simp.BuiltinSimprocs.UInt | IO Unit | false |
Lean.ModuleArtifacts.mk._flat_ctor | Lean.Setup | Option System.FilePath →
Option System.FilePath →
Option System.FilePath →
Option System.FilePath →
Option System.FilePath →
Option System.FilePath → Option System.FilePath → Option System.FilePath → Lean.ModuleArtifacts | false |
Std.DTreeMap.Internal.Impl.Const.get!_union!_of_contains_eq_false_right | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {instOrd : Ord α} {β : Type v} {m₁ m₂ : Std.DTreeMap.Internal.Impl α fun x => β} [Std.TransOrd α]
[inst : Inhabited β],
m₁.WF →
m₂.WF →
∀ {k : α},
Std.DTreeMap.Internal.Impl.contains k m₂ = false →
Std.DTreeMap.Internal.Impl.Const.get! (m₁.union! m₂) k = Std.DTreeMap.Inter... | true |
List.lookup_graph | Mathlib.Data.List.Basic | ∀ {α : Type u} {β : Type v} [inst : BEq α] [LawfulBEq α] (f : α → β) {a : α} {as : List α},
a ∈ as → List.lookup a (List.map (fun x => (x, f x)) as) = some (f a) | true |
LinearMap.equivariantProjection_apply | Mathlib.RepresentationTheory.Maschke | ∀ {k : Type u_1} [inst : CommRing k] (G : Type u_2) [inst_1 : Group G] {V : Type u_3} [inst_2 : AddCommGroup V]
[inst_3 : Module k V] [inst_4 : Module (MonoidAlgebra k G) V] [inst_5 : IsScalarTower k (MonoidAlgebra k G) V]
{W : Type u_4} [inst_6 : AddCommGroup W] [inst_7 : Module k W] [inst_8 : Module (MonoidAlgebr... | true |
_private.Mathlib.GroupTheory.GroupAction.SubMulAction.Pointwise.0.SubMulAction.instMulOneClass._simp_2 | Mathlib.GroupTheory.GroupAction.SubMulAction.Pointwise | ∀ {α : Sort u_1} {β : Sort u_2} {f : α → β} {p : β → Prop}, (∃ b, (∃ a, f a = b) ∧ p b) = ∃ a, p (f a) | false |
_private.Mathlib.Analysis.Calculus.ContDiff.Operations.0.iteratedFDerivWithin_sum_apply._simp_1_2 | Mathlib.Analysis.Calculus.ContDiff.Operations | ∀ {α : Type u_1} {s : Finset α} {a b : α} {h : a ∉ s}, (b ∈ Finset.cons a s h) = (b = a ∨ b ∈ s) | false |
_private.Mathlib.Topology.Covering.Quotient.0.Topology.IsQuotientMap.isQuotientCoveringMap_of_subgroupOp.match_1_1 | Mathlib.Topology.Covering.Quotient | ∀ {E : Type u_1} [inst : Group E] (G : Subgroup E) (e : E) (U : Set E)
(motive : (x : ↥G.op) → ((fun x_1 => x • x_1) '' ({e} * U) ∩ ({e} * U)).Nonempty → Prop) (x : ↥G.op)
(hs : ((fun x_1 => x • x_1) '' ({e} * U) ∩ ({e} * U)).Nonempty),
(∀ (s : E) (hS : { unop' := s } ∈ G.op)
(hs : ((fun x => ⟨{ unop' := s ... | false |
SimpleGraph.indepSetFree_compl | Mathlib.Combinatorics.SimpleGraph.Clique | ∀ {α : Type u_1} (G : SimpleGraph α) {n : ℕ}, Gᶜ.IndepSetFree n ↔ G.CliqueFree n | true |
Rat.ceil_lt | Init.Data.Rat.Lemmas | ∀ {x : ℚ}, ↑x.ceil < x + 1 | true |
Lean.Elab.Term.CollectPatternVars.Context.explicit | Lean.Elab.PatternVar | Lean.Elab.Term.CollectPatternVars.Context → Bool | true |
_private.Lean.Meta.Sym.Simp.App.0.Lean.Meta.Sym.Simp.simpOverApplied.visit._sparseCasesOn_3 | Lean.Meta.Sym.Simp.App | {motive : Lean.Expr → Sort u} →
(t : Lean.Expr) → ((fn arg : Lean.Expr) → motive (fn.app arg)) → (Nat.hasNotBit 32 t.ctorIdx → motive t) → motive t | false |
AlgebraicGeometry.Scheme.Hom.normalizationDiagram._proof_3 | Mathlib.AlgebraicGeometry.Normalization | ∀ {X Y : AlgebraicGeometry.Scheme} (f : X ⟶ Y) (U : Y.Opensᵒᵖ),
CommRingCat.ofHom
((CommRingCat.Hom.hom (X.presheaf.map (CategoryTheory.homOfLE ⋯).op)).restrict
(integralClosure ↑(Y.presheaf.obj (Opposite.op (Opposite.unop U)))
↑(X.presheaf.obj (Opposite.op ((TopologicalSpace.Opens.map f.base)... | false |
Lean.Elab.Tactic.Conv.mkConvGoalFor | Lean.Elab.Tactic.Conv.Basic | Lean.Expr → optParam Lean.Name Lean.Name.anonymous → Lean.MetaM (Lean.Expr × Lean.Expr) | true |
CategoryTheory.SemiadditiveOfBinaryBiproducts.comp_add | Mathlib.CategoryTheory.Preadditive.OfBiproducts | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
[inst_2 : CategoryTheory.Limits.HasBinaryBiproducts C] {X Y Z : C} (f : X ⟶ Y) (g h : Y ⟶ Z),
CategoryTheory.CategoryStruct.comp f (g + h) =
CategoryTheory.CategoryStruct.comp f g + CategoryTheory.Catego... | true |
_private.Mathlib.Data.Sym.Sym2.0.Sym2.disjoint_diagSet_fromRel._simp_1_1 | Mathlib.Data.Sym.Sym2 | ∀ {α : Type u} {s t : Set α}, Disjoint s t = ∀ ⦃a : α⦄, a ∈ s → a ∉ t | false |
associator | Mathlib.Algebra.Ring.Associator | {R : Type u_1} → [NonUnitalNonAssocRing R] → R → R → R → R | true |
Lean.Sym.Int16.eq_eq_true | Init.Sym.Lemmas | ∀ (a b : Int16), decide (a = b) = true → (a = b) = True | true |
hasLineDerivAt_iff_tendsto_slope_zero | Mathlib.Analysis.Calculus.LineDeriv.Basic | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {F : Type u_2} [inst_1 : NormedAddCommGroup F]
[inst_2 : NormedSpace 𝕜 F] {E : Type u_3} [inst_3 : AddCommGroup E] [inst_4 : Module 𝕜 E] {f : E → F} {f' : F}
{x v : E},
HasLineDerivAt 𝕜 f f' x v ↔ Filter.Tendsto (fun t => t⁻¹ • (f (x + t • v) - f x)) (nhdsW... | true |
CategoryTheory.ShortComplex.Homotopy.trans_h₃ | Mathlib.Algebra.Homology.ShortComplex.Preadditive | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Preadditive C]
{S₁ S₂ : CategoryTheory.ShortComplex C} {φ₁ φ₂ φ₃ : S₁ ⟶ S₂} (h₁₂ : CategoryTheory.ShortComplex.Homotopy φ₁ φ₂)
(h₂₃ : CategoryTheory.ShortComplex.Homotopy φ₂ φ₃), (h₁₂.trans h₂₃).h₃ = h₁₂.h₃ + h₂₃.h₃ | true |
Std.Tactic.BVDecide.LRAT.Internal.DefaultFormula.ReducePostconditionInductionMotive | Std.Tactic.BVDecide.LRAT.Internal.Formula.RupAddSound | {n : ℕ} →
Array (Std.Sat.Literal (Std.Tactic.BVDecide.LRAT.Internal.PosFin n)) →
Array Std.Tactic.BVDecide.LRAT.Internal.Assignment →
ℕ → Std.Tactic.BVDecide.LRAT.Internal.ReduceResult (Std.Tactic.BVDecide.LRAT.Internal.PosFin n) → Prop | true |
ConvexCone.IsGenerating | Mathlib.Geometry.Convex.Cone.Basic | {R : Type u_2} →
{M : Type u_4} →
[inst : Semiring R] →
[inst_1 : PartialOrder R] → [inst_2 : AddCommMonoid M] → [inst_3 : Module R M] → ConvexCone R M → Prop | true |
_private.Mathlib.AlgebraicGeometry.StructureSheaf.0.AlgebraicGeometry.StructureSheaf.isIso_toBasicOpenₗ | Mathlib.AlgebraicGeometry.StructureSheaf | ∀ {R M : Type u} [inst : CommRing R] [inst_1 : AddCommGroup M] [inst_2 : Module R M] (f : R),
CategoryTheory.IsIso (ModuleCat.ofHom (AlgebraicGeometry.StructureSheaf.toBasicOpenₗ✝ R M f)) | true |
MultilinearMap.addCommMonoid._proof_5 | Mathlib.LinearAlgebra.Multilinear.Basic | ∀ {R : Type u_1} {ι : Type u_2} {M₁ : ι → Type u_3} {M₂ : Type u_4} [inst : Semiring R]
[inst_1 : (i : ι) → AddCommMonoid (M₁ i)] [inst_2 : AddCommMonoid M₂] [inst_3 : (i : ι) → Module R (M₁ i)]
[inst_4 : Module R M₂],
autoParam (∀ (n : ℕ) (x : MultilinearMap R M₁ M₂), (n + 1) • x = n • x + x) AddMonoid.nsmul_suc... | false |
Std.TreeSet.Equiv.foldl_eq | Std.Data.TreeSet.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t₁ t₂ : Std.TreeSet α cmp} {δ : Type w} [Std.TransCmp cmp] {f : δ → α → δ}
{init : δ}, t₁.Equiv t₂ → Std.TreeSet.foldl f init t₁ = Std.TreeSet.foldl f init t₂ | true |
CategoryTheory.GrothendieckTopology.Point.sheafFiberCompIso_hom_app | Mathlib.CategoryTheory.Sites.Point.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {J : CategoryTheory.GrothendieckTopology C} (Φ : J.Point)
{A : Type u'} [inst_1 : CategoryTheory.Category.{v', u'} A] {B : Type u''}
[inst_2 : CategoryTheory.Category.{v'', u''} B] [inst_3 : CategoryTheory.Limits.HasColimitsOfSize.{w, w, v', u'} A]
[inst_4 ... | true |
Polynomial.logMahlerMeasure_X | Mathlib.Analysis.Polynomial.MahlerMeasure | Polynomial.X.logMahlerMeasure = 0 | true |
AlgebraicGeometry.AffineSpace.homOfVector._proof_1 | Mathlib.AlgebraicGeometry.AffineSpace | ∀ {n : Type u_2} {S X : AlgebraicGeometry.Scheme} (f : X ⟶ S) (v : n → ↑(X.presheaf.obj (Opposite.op ⊤))),
CategoryTheory.CategoryStruct.comp f (CategoryTheory.Limits.terminal.from S) =
CategoryTheory.CategoryStruct.comp ((AlgebraicGeometry.AffineSpace.toSpecMvPolyIntEquiv n).symm v)
(CategoryTheory.Limits.... | false |
IsGaloisGroup.instMulSemiringActionQuotientSubgroupSubtypeMemIntermediateField._proof_3 | Mathlib.FieldTheory.Galois.IsGaloisGroup | ∀ (G : Type u_3) (K : Type u_2) (L : Type u_1) [inst : Group G] [inst_1 : Field K] [inst_2 : Field L]
[inst_3 : Algebra K L] [inst_4 : MulSemiringAction G L] (F : IntermediateField K L) (N : Subgroup G)
[inst_5 : N.Normal] [hF : IsGaloisGroup (↥N) (↥F) L] (x : ↥F) (g g' : G),
↑((Quotient.mk'' g * Quotient.mk'' g'... | false |
_private.Lean.Environment.0.Lean.EnvExtension.mk.noConfusion | Lean.Environment | {σ : Type} →
{P : Sort u} →
{idx : ℕ} →
{mkInitial : IO σ} →
{asyncMode : Lean.EnvExtension.AsyncMode} →
{replay? : Option (Lean.ReplayFn σ)} →
{idx' : ℕ} →
{mkInitial' : IO σ} →
{asyncMode' : Lean.EnvExtension.AsyncMode} →
{repla... | false |
_private.Init.Data.String.Decode.0.ByteArray.utf8DecodeChar?.assemble₄_eq_some_iff_utf8EncodeChar_eq._simp_1_8 | Init.Data.String.Decode | ∀ {c : Char}, (c.utf8Size = 4) = (65535 < c.val) | false |
Std.HashSet.Raw.get?_eq_some_of_contains | Std.Data.HashSet.RawLemmas | ∀ {α : Type u} {m : Std.HashSet.Raw α} [inst : BEq α] [inst_1 : Hashable α] [LawfulBEq α],
m.WF → ∀ {k : α}, m.contains k = true → m.get? k = some k | true |
Finset.card_dvd_card_smul_right | Mathlib.Algebra.Group.Action.Pointwise.Finset | ∀ {α : Type u_2} {β : Type u_3} [inst : DecidableEq β] [inst_1 : Group α] [inst_2 : MulAction α β] {t : Finset β}
{s : Finset α}, ((fun x => x • t) '' ↑s).PairwiseDisjoint id → t.card ∣ (s • t).card | true |
_private.Mathlib.LinearAlgebra.Matrix.Integer.0.Matrix.num_natCast._simp_1_1 | Mathlib.LinearAlgebra.Matrix.Integer | ∀ {n : Type u_3} {α : Type v} [inst : DecidableEq n] [inst_1 : Zero α] [inst_2 : NatCast α] (m : ℕ),
↑m = Matrix.diagonal fun x => ↑m | false |
IsConjRoot.setoid._proof_1 | Mathlib.FieldTheory.Minpoly.IsConjRoot | ∀ (R : Type u_2) (A : Type u_1) [inst : CommRing R] [inst_1 : Ring A] [inst_2 : Algebra R A], Equivalence (IsConjRoot R) | false |
Function.Periodic.cuspFunction_zero_eq_limUnder_nhds_ne | Mathlib.Analysis.Complex.Periodic | ∀ (h : ℝ) (f : ℂ → ℂ),
Function.Periodic.cuspFunction h f 0 = (nhdsWithin 0 {0}ᶜ).limUnder (Function.Periodic.cuspFunction h f) | true |
BoundingSieve.prod_primeFactors_nu | Mathlib.NumberTheory.SelbergSieve | ∀ {s : BoundingSieve} {d : ℕ}, d ∣ s.prodPrimes → ∏ p ∈ d.primeFactors, s.nu p = s.nu d | true |
Lean.Lsp.SymbolKind.rec | Lean.Data.Lsp.LanguageFeatures | {motive : Lean.Lsp.SymbolKind → Sort u} →
motive Lean.Lsp.SymbolKind.file →
motive Lean.Lsp.SymbolKind.module →
motive Lean.Lsp.SymbolKind.namespace →
motive Lean.Lsp.SymbolKind.package →
motive Lean.Lsp.SymbolKind.class →
motive Lean.Lsp.SymbolKind.method →
motiv... | false |
Subgroup.mulSemiringAction | Mathlib.Algebra.Ring.Action.Subobjects | {G : Type u_2} →
{R : Type u_3} →
[inst : Group G] → [inst_1 : Semiring R] → [MulSemiringAction G R] → (H : Subgroup G) → MulSemiringAction (↥H) R | true |
ZMod.valMinAbs_natCast_of_half_lt | Mathlib.Data.ZMod.ValMinAbs | ∀ {n a : ℕ}, n / 2 < a → a < n → (↑a).valMinAbs = ↑a - ↑n | true |
Algebra.TensorProduct.leftComm_symm_tmul | Mathlib.RingTheory.TensorProduct.Maps | ∀ {R : Type uR} {A : Type uA} {B : Type uB} {C : Type uC} [inst : CommSemiring R] [inst_1 : Semiring A]
[inst_2 : Algebra R A] [inst_3 : Semiring B] [inst_4 : Algebra R B] [inst_5 : Semiring C] [inst_6 : Algebra R C]
(m : A) (n : B) (p : C), (Algebra.TensorProduct.leftComm R A B C).symm (n ⊗ₜ[R] (m ⊗ₜ[R] p)) = m ⊗ₜ... | true |
_private.Mathlib.Data.Nat.Squarefree.0.Nat.minSqFacAux_has_prop._proof_1_2 | Mathlib.Data.Nat.Squarefree | ∀ (k i : ℕ), k = 2 * i + 3 → 2 ≤ k | false |
Lean.Lsp.TypeDefinitionParams.noConfusionType | Lean.Data.Lsp.LanguageFeatures | Sort u → Lean.Lsp.TypeDefinitionParams → Lean.Lsp.TypeDefinitionParams → Sort u | false |
_private.Mathlib.AlgebraicGeometry.IdealSheaf.Basic.0.AlgebraicGeometry.Scheme.IdealSheafData.instSemilatticeInf._simp_2 | Mathlib.AlgebraicGeometry.IdealSheaf.Basic | ∀ {M : Type u_1} [inst : Monoid M] (x z : M), (x ∈ Submonoid.powers z) = ∃ n, z ^ n = x | false |
_private.Mathlib.Probability.Distributions.Fernique.0.ProbabilityTheory.measure_le_mul_measure_gt_le_of_map_rotation_eq_self._simp_1_1 | Mathlib.Probability.Distributions.Fernique | ∀ {a b c : Prop}, (a ∧ b → c) = (a → b → c) | false |
Nat.bell.eq_1 | Mathlib.Combinatorics.Enumerative.Bell | Nat.bell 0 = 1 | true |
_private.Mathlib.FieldTheory.Minpoly.IsIntegrallyClosed.0.minpoly.IsIntegrallyClosed.isIntegral_iff_leadingCoeff_dvd._simp_1_8 | Mathlib.FieldTheory.Minpoly.IsIntegrallyClosed | ∀ (R : Type u_1) (A : Type u_2) [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A] [FaithfulSMul R A]
{r : R}, ((algebraMap R A) r = 0) = (r = 0) | false |
Lean.Parser.Command.dumpAsyncEnvState | Lean.Parser.Command | Lean.Parser.Parser | true |
_private.Mathlib.RingTheory.Ideal.Operations.0.Ideal.IsPrime.prod_mem_iff._simp_1_1 | Mathlib.RingTheory.Ideal.Operations | ∀ {α : Type u} [inst : Semiring α] (I : Ideal α) {x : α}, (x ∈ I) = (Ideal.span {x} ≤ I) | false |
Finset.insertNone._proof_1 | Mathlib.Data.Finset.Option | ∀ {α : Type u_1} (s : Finset α), none ∉ Finset.map Function.Embedding.some s | false |
VitaliFamily.aemeasurable_limRatio | Mathlib.MeasureTheory.Covering.Differentiation | ∀ {α : Type u_1} [inst : PseudoMetricSpace α] {m0 : MeasurableSpace α} {μ : MeasureTheory.Measure α}
(v : VitaliFamily μ) [SecondCountableTopology α] [BorelSpace α] [MeasureTheory.IsLocallyFiniteMeasure μ]
{ρ : MeasureTheory.Measure α} [MeasureTheory.IsLocallyFiniteMeasure ρ],
ρ.AbsolutelyContinuous μ → AEMeasura... | true |
DifferentiableAt.fun_inv | Mathlib.Analysis.Calculus.FDeriv.Mul | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {R : Type u_5} [inst_3 : NormedDivisionRing R] [inst_4 : NormedAlgebra 𝕜 R] {h : E → R}
{z : E}, DifferentiableAt 𝕜 h z → h z ≠ 0 → DifferentiableAt 𝕜 (fun i => (h i)⁻¹) z | true |
Std.TreeSet.Raw.min?_eq_getElem?_toArray | Std.Data.TreeSet.Raw.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t : Std.TreeSet.Raw α cmp} [Std.TransCmp cmp], t.WF → t.min? = t.toArray[0]? | true |
_private.Lean.Meta.Tactic.Grind.Arith.Cutsat.DvdCnstr.0.Lean.Meta.Grind.Arith.Cutsat.DvdCnstr.assert.match_3 | Lean.Meta.Tactic.Grind.Arith.Cutsat.DvdCnstr | (motive : Int.Linear.Poly → Sort u_1) →
(x : Int.Linear.Poly) →
((a₂ : ℤ) → (v : Int.Linear.Var) → (p₂ : Int.Linear.Poly) → motive (Int.Linear.Poly.add a₂ v p₂)) →
((x : Int.Linear.Poly) → motive x) → motive x | false |
MonCat.casesOn | Mathlib.Algebra.Category.MonCat.Basic | {motive : MonCat → Sort u_1} →
(t : MonCat) → ((carrier : Type u) → [str : Monoid carrier] → motive { carrier := carrier, str := str }) → motive t | false |
_private.Mathlib.Algebra.Order.Field.Basic.0.Mathlib.Meta.Positivity.evalDiv._proof_1 | Mathlib.Algebra.Order.Field.Basic | ∀ {u : Lean.Level} {α : Q(Type u)} (e : Q(«$α»)) (f : Q(«$α» → «$α» → «$α»)) (a b : Q(«$α»)), «$e» =Q «$f» «$a» «$b» | false |
CategoryTheory.Sheaf.braidedCategory._proof_3 | Mathlib.CategoryTheory.Sites.Monoidal | ∀ {C : Type u_3} [inst : CategoryTheory.Category.{u_1, u_3} C] (J : CategoryTheory.GrothendieckTopology C)
(A : Type u_4) [inst_1 : CategoryTheory.Category.{u_2, u_4} A] [inst_2 : CategoryTheory.MonoidalCategory A]
[inst_3 : J.W.IsMonoidal] [inst_4 : CategoryTheory.HasWeakSheafify J A] [inst_5 : CategoryTheory.Brai... | false |
Lean.Doc.module._regBuiltin.Lean.Doc.module_3 | Lean.Elab.DocString.Builtin | IO Unit | false |
_private.Mathlib.Tactic.NormNum.PowMod.0.Mathlib.Meta.NormNum.evalNatPowMod.go.match_1 | Mathlib.Tactic.NormNum.PowMod | (a m : Q(ℕ)) →
(p : Q(Prop)) →
(hi : Q(ℕ)) →
(motive : (c : Q(ℕ)) × Q(Mathlib.Meta.NormNum.IsNatPowModT «$p» «$a» «$hi» «$m» «$c») → Sort u_1) →
(x : (c : Q(ℕ)) × Q(Mathlib.Meta.NormNum.IsNatPowModT «$p» «$a» «$hi» «$m» «$c»)) →
((c1 : Q(ℕ)) → (p1 : Q(Mathlib.Meta.NormNum.IsNatPowModT «$p»... | false |
Std.DHashMap.Const.getKey!_alter_self | Std.Data.DHashMap.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {β : Type v} {m : Std.DHashMap α fun x => β} [EquivBEq α]
[LawfulHashable α] [inst : Inhabited α] {k : α} {f : Option β → Option β},
(Std.DHashMap.Const.alter m k f).getKey! k = if (f (Std.DHashMap.Const.get? m k)).isSome = true then k else default | true |
Std.Time.Year.twoDigit.sizeOf_spec | Std.Time.Format.Basic | sizeOf Std.Time.Year.twoDigit = 1 | true |
Std.Http.Header.Connection.rec | Std.Internal.Http.Data.Headers.Basic | {motive : Std.Http.Header.Connection → Sort u} →
((tokens : Array String) →
(valid : tokens.all Std.Http.Internal.isToken = true) → motive { tokens := tokens, valid := valid }) →
(t : Std.Http.Header.Connection) → motive t | false |
Function.locallyFinsuppWithin.mk.inj | Mathlib.Topology.LocallyFinsupp | ∀ {X : Type u_1} {inst : TopologicalSpace X} {U : Set X} {Y : Type u_2} {inst_1 : Zero Y} {toFun : X → Y}
{supportWithinDomain' : Function.support toFun ⊆ U}
{supportLocallyFiniteWithinDomain' : ∀ z ∈ U, ∃ t ∈ nhds z, (t ∩ Function.support toFun).Finite} {toFun_1 : X → Y}
{supportWithinDomain'_1 : Function.suppor... | true |
Std.Time.ZonedDateTime.hour | Std.Time.Zoned.ZonedDateTime | Std.Time.ZonedDateTime → Std.Time.Hour.Ordinal | true |
Lean.Lsp.instOrdDiagnosticCode | Lean.Data.Lsp.Diagnostics | Ord Lean.Lsp.DiagnosticCode | true |
Std.DTreeMap.Internal.Impl.Const.foldr_eq_foldr_toList | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {δ : Type w} {β : Type v} {t : Std.DTreeMap.Internal.Impl α fun x => β} {f : α → β → δ → δ} {init : δ},
Std.DTreeMap.Internal.Impl.foldr f init t =
List.foldr (fun a b => f a.1 a.2 b) init (Std.DTreeMap.Internal.Impl.Const.toList t) | true |
HasFDerivWithinAt.of_finite | Mathlib.Analysis.Calculus.FDeriv.Basic | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : AddCommGroup E] [inst_2 : Module 𝕜 E]
[inst_3 : TopologicalSpace E] {F : Type u_3} [inst_4 : AddCommGroup F] [inst_5 : Module 𝕜 F]
[inst_6 : TopologicalSpace F] {f : E → F} {f' : E →L[𝕜] F} {x : E} {s : Set E} [T1Space E],
s.Finite ... | true |
_private.Mathlib.MeasureTheory.Covering.Differentiation.0.VitaliFamily.ae_eventually_measure_pos._simp_1_1 | Mathlib.MeasureTheory.Covering.Differentiation | ∀ {α : Type u_1} [inst : LinearOrder α] {a b : α}, (¬a < b) = (b ≤ a) | false |
Lean.Grind.Fin.neg_mul | Init.GrindInstances.Ring.Fin | ∀ {n : ℕ} [NeZero n] (a b : Fin n), -a * b = -(a * b) | true |
IsLocalizedModule.linearMap_ext | Mathlib.Algebra.Module.LocalizedModule.Basic | ∀ {R : Type u_1} [inst : CommSemiring R] (S : Submonoid R) {M : Type u_2} {M' : Type u_3} [inst_1 : AddCommMonoid M]
[inst_2 : AddCommMonoid M'] [inst_3 : Module R M] [inst_4 : Module R M'] (f : M →ₗ[R] M') [IsLocalizedModule S f]
{N : Type u_6} {N' : Type u_7} [inst_6 : AddCommMonoid N] [inst_7 : Module R N] [inst... | true |
Bicategory.Opposite.bicategory._proof_10 | Mathlib.CategoryTheory.Bicategory.Opposites | ∀ {B : Type u_1} [inst : CategoryTheory.Bicategory B] {a b c : Bᵒᵖ} (f : a ⟶ b) (g : b ⟶ c),
Bicategory.Opposite.op2 (CategoryTheory.Bicategory.whiskerLeft g.unop (CategoryTheory.CategoryStruct.id f).unop2) =
CategoryTheory.CategoryStruct.id (CategoryTheory.CategoryStruct.comp f g) | false |
Lean.Elab.Term.SavedContext.ctorIdx | Lean.Elab.Term.TermElabM | Lean.Elab.Term.SavedContext → ℕ | false |
_private.Init.Data.List.MinMaxIdx.0.List.apply_minOn_lt_apply_getElem_of_lt_minIdxOn._proof_1 | Init.Data.List.MinMaxIdx | ∀ {β : Type u_1} {α : Type u_2} [inst : LE β] [inst_1 : DecidableLE β] {f : α → β} {xs : List α} (h : xs ≠ []) {k : ℕ},
k < List.minIdxOn f xs h → List.minIdxOn f xs h < xs.length → ¬k < xs.length → False | false |
AddSubgroup.map_eq_bot_iff_of_injective | Mathlib.Algebra.Group.Subgroup.Ker | ∀ {G : Type u_1} [inst : AddGroup G] {N : Type u_5} [inst_1 : AddGroup N] (H : AddSubgroup G) {f : G →+ N},
Function.Injective ⇑f → (AddSubgroup.map f H = ⊥ ↔ H = ⊥) | true |
CategoryTheory.Pseudofunctor.DescentData'.pullHom'_eq_pullHom._proof_12 | Mathlib.CategoryTheory.Sites.Descent.DescentDataPrime | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {ι : Type u_3} {S : C} {X : ι → C}
{f : (i : ι) → X i ⟶ S} {sq : (i j : ι) → CategoryTheory.Limits.ChosenPullback (f i) (f j)} ⦃Y : C⦄ (q : Y ⟶ S)
⦃i₁ i₂ : ι⦄ (f₁ : Y ⟶ X i₁) (f₂ : Y ⟶ X i₂) (p : Y ⟶ (sq i₁ i₂).pullback),
autoParam (CategoryTheory.Cat... | false |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.mem_of_mem_erase._simp_1_1 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {x : Ord α} {t : Std.DTreeMap.Internal.Impl α β} {k : α},
(k ∈ t) = (Std.DTreeMap.Internal.Impl.contains k t = true) | false |
Bundle.Trivialization.linearMapAt_def_of_mem | Mathlib.Topology.VectorBundle.Basic | ∀ {R : Type u_1} {B : Type u_2} {F : Type u_3} {E : B → Type u_4} [inst : Semiring R] [inst_1 : TopologicalSpace F]
[inst_2 : TopologicalSpace B] [inst_3 : TopologicalSpace (Bundle.TotalSpace F E)] [inst_4 : AddCommMonoid F]
[inst_5 : Module R F] [inst_6 : (x : B) → AddCommMonoid (E x)] [inst_7 : (x : B) → Module R... | true |
Finsupp.toDFinsupp._proof_1 | Mathlib.Data.Finsupp.ToDFinsupp | ∀ {ι : Type u_1} {M : Type u_2} [inst : Zero M] (f : ι →₀ M) (i : ι), i ∈ f.support.val ∨ f i = 0 | false |
PrincipalSeg.cocone | Mathlib.CategoryTheory.Limits.Shapes.Preorder.PrincipalSeg | {α : Type u_1} →
{β : Type u_2} →
[inst : PartialOrder α] →
[inst_1 : PartialOrder β] →
(f : PrincipalSeg (fun x1 x2 => x1 < x2) fun x1 x2 => x1 < x2) →
{C : Type u_3} →
[inst_2 : CategoryTheory.Category.{v_1, u_3} C] →
(F : CategoryTheory.Functor β C) → CategoryT... | true |
_private.Init.Data.BitVec.Lemmas.0.BitVec.neg_le_intMin_of_msb_eq_true._proof_1_3 | Init.Data.BitVec.Lemmas | ∀ (w' : ℕ) (x : BitVec (w' + 1)), 2 * x.toNat ≥ 2 ^ w' * 2 → ¬2 ^ w' * 2 - x.toNat ≤ 2 ^ w' → False | false |
HShiftRight.recOn | Init.Prelude | {α : Type u} →
{β : Type v} →
{γ : Type w} →
{motive : HShiftRight α β γ → Sort u_1} →
(t : HShiftRight α β γ) → ((hShiftRight : α → β → γ) → motive { hShiftRight := hShiftRight }) → motive t | false |
WithVal.map._proof_1 | Mathlib.Topology.Algebra.Valued.WithVal | ∀ {R : Type u_1} {Γ₀ : Type u_2} [inst : LinearOrderedCommGroupWithZero Γ₀] [inst_1 : Ring R] (v : Valuation R Γ₀),
RingHomClass (WithVal v ≃+* R) (WithVal v) R | false |
Std.Internal.List.getValueCastD_alterKey | Std.Data.Internal.List.Associative | ∀ {α : Type u} {β : α → Type v} [inst : BEq α] [inst_1 : LawfulBEq α] {k k' : α} {fallback : β k'}
{f : Option (β k) → Option (β k)} (l : List ((a : α) × β a)),
Std.Internal.List.DistinctKeys l →
Std.Internal.List.getValueCastD k' (Std.Internal.List.alterKey k f l) fallback =
if heq : (k == k') = true the... | true |
AbstractSimplicialComplex.toPreAbstractSimplicialComplex | Mathlib.AlgebraicTopology.SimplicialComplex.Basic | {ι : Type u_1} → AbstractSimplicialComplex ι → PreAbstractSimplicialComplex ι | true |
MvQPF.mk | Mathlib.Data.QPF.Multivariate.Basic | {n : ℕ} →
{F : TypeVec.{u} n → Type u_1} →
[toMvFunctor : MvFunctor F] →
(P : MvPFunctor.{u} n) →
(abs : {α : TypeVec.{u} n} → ↑P α → F α) →
(repr : {α : TypeVec.{u} n} → F α → ↑P α) →
(∀ {α : TypeVec.{u} n} (x : F α), abs (repr x) = x) →
(∀ {α β : TypeVec.{u} n} ... | true |
MulArchimedeanClass.mk_eq_top_iff | Mathlib.Algebra.Order.Archimedean.Class | ∀ {M : Type u_1} [inst : CommGroup M] [inst_1 : LinearOrder M] [inst_2 : IsOrderedMonoid M] {a : M},
MulArchimedeanClass.mk a = ⊤ ↔ a = 1 | true |
ENNReal.coe_eq_zero._simp_1 | Mathlib.Data.ENNReal.Basic | ∀ {r : NNReal}, (↑r = 0) = (r = 0) | false |
SkewPolynomial.support_add | Mathlib.Algebra.SkewPolynomial.Basic | ∀ {R : Type u_1} [inst : Semiring R] {p q : SkewPolynomial R}, (p + q).support ⊆ p.support ∪ q.support | true |
ChevalleyThm.MvPolynomialC.numBound_mono | Mathlib.RingTheory.Spectrum.Prime.ChevalleyComplexity | ∀ {k₁ k₂ : ℕ} {D₁ D₂ : ℕ → ℕ},
k₁ ≤ k₂ →
∀ (n : ℕ),
(∀ i < n, D₁ i ≤ D₂ i) → ChevalleyThm.MvPolynomialC.numBound k₁ D₁ n ≤ ChevalleyThm.MvPolynomialC.numBound k₂ D₂ n | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.