name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
Equiv.psigmaEquivSigmaPLift._proof_1 | Mathlib.Logic.Equiv.Defs | ∀ {α : Sort u_2} (β : α → Sort u_1),
Function.LeftInverse (fun a => ⟨a.fst.down, a.snd.down⟩) fun a => ⟨{ down := a.fst }, { down := a.snd }⟩ | false |
vadd_set_closure_subset | Mathlib.Topology.Algebra.MulAction | ∀ {M : Type u_1} {X : Type u_2} [inst : TopologicalSpace M] [inst_1 : TopologicalSpace X] [inst_2 : VAdd M X]
[ContinuousVAdd M X] (K : Set M) (L : Set X), closure K +ᵥ closure L ⊆ closure (K +ᵥ L) | true |
CategoryTheory.Monad.beckSplitCoequalizer._proof_2 | Mathlib.CategoryTheory.Monad.Coequalizer | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {T : CategoryTheory.Monad C} (X : T.Algebra),
CategoryTheory.CategoryStruct.comp (T.η.app (T.toFunctor.1 X.A)) (T.map X.a) =
CategoryTheory.CategoryStruct.comp ((CategoryTheory.Functor.id C).map X.a) (T.η.app X.A) | false |
Equiv.image_strictAnti | Mathlib.Logic.Equiv.Set | ∀ {α : Type u_3} {β : Type u_4} [inst : Preorder α] [inst_1 : Preorder β] {e : α ≃ β} (s : Set α),
StrictAnti ⇑e → StrictAnti ⇑(e.image s) | true |
_private.Mathlib.Analysis.Complex.Harmonic.Poisson.0.InnerProductSpace.HarmonicContOnCl.circleAverage_re_herglotzRieszKernel_smul._proof_1_1 | Mathlib.Analysis.Complex.Harmonic.Poisson | ∀ {c w : ℂ} {R : ℝ}, w ∈ Metric.ball c R → {z | ‖z - c‖ ∈ Set.Ioc ‖w - c‖ R} ⊆ closure (Metric.ball c R) | false |
CauSeq.pow_apply | Mathlib.Algebra.Order.CauSeq.Basic | ∀ {α : Type u_1} {β : Type u_2} [inst : Field α] [inst_1 : LinearOrder α] [inst_2 : IsStrictOrderedRing α]
[inst_3 : Ring β] {abv : β → α} [inst_4 : IsAbsoluteValue abv] (f : CauSeq β abv) (n i : ℕ), ↑(f ^ n) i = ↑f i ^ n | true |
Lean.Elab.Tactic.Do.countUsesLCtx | Lean.Elab.Tactic.Do.LetElim | Lean.LocalContext → Lean.Elab.Tactic.Do.FVarUses → Lean.MetaM Lean.LocalContext | true |
isArtinianRing_iff_krullDimLE_zero | Mathlib.RingTheory.HopkinsLevitzki | ∀ {R : Type u_3} [inst : CommRing R] [IsNoetherianRing R], IsArtinianRing R ↔ Ring.KrullDimLE 0 R | true |
IsCyclotomicExtension.isSplittingField_X_pow_sub_one | Mathlib.NumberTheory.Cyclotomic.Basic | ∀ (n : ℕ) [NeZero n] (K : Type w) (L : Type z) [inst : Field K] [inst_1 : Field L] [inst_2 : Algebra K L]
[IsCyclotomicExtension {n} K L], Polynomial.IsSplittingField K L (Polynomial.X ^ n - 1) | true |
CategoryTheory.bifunctorComp₁₂Functor._proof_2 | Mathlib.CategoryTheory.Functor.Trifunctor | ∀ {C₁ : Type u_4} {C₂ : Type u_2} {C₃ : Type u_7} {C₄ : Type u_8} {C₁₂ : Type u_5}
[inst : CategoryTheory.Category.{u_1, u_4} C₁] [inst_1 : CategoryTheory.Category.{u_6, u_2} C₂]
[inst_2 : CategoryTheory.Category.{u_9, u_7} C₃] [inst_3 : CategoryTheory.Category.{u_10, u_8} C₄]
[inst_4 : CategoryTheory.Category.{u... | false |
CategoryTheory.Limits.FormalCoproduct.mk.sizeOf_spec | Mathlib.CategoryTheory.Limits.FormalCoproducts.Basic | ∀ {C : Type u} [inst : SizeOf C] (I : Type w) (obj : I → C), sizeOf { I := I, obj := obj } = 1 + sizeOf I | true |
Lean.Grind.IntModule.OfNatModule.add | Init.Grind.Module.Envelope | {α : Type u} →
[inst : Lean.Grind.NatModule α] →
Lean.Grind.IntModule.OfNatModule.Q α → Lean.Grind.IntModule.OfNatModule.Q α → Lean.Grind.IntModule.OfNatModule.Q α | true |
Polynomial.Monic.map | Mathlib.Algebra.Polynomial.Monic | ∀ {R : Type u} {S : Type v} [inst : Semiring R] {p : Polynomial R} [inst_1 : Semiring S] (f : R →+* S),
p.Monic → (Polynomial.map f p).Monic | true |
_private.Mathlib.Data.Set.Function.0.Set.surjOn_empty_iff._simp_1_2 | Mathlib.Data.Set.Function | ∀ {α : Type u} {s : Set α}, (s ⊆ ∅) = (s = ∅) | false |
Lean.Firefox.FrameTable.Entry.casesOn | Lean.Util.Profiler | {motive : Lean.Firefox.FrameTable.Entry → Sort u} →
(t : Lean.Firefox.FrameTable.Entry) →
((address : ℤ) →
(inlineDepth : ℕ) →
(category subcategory : Option ℕ) →
(func : ℕ) →
(nativeSymbol innerWindowID implementation : Option Lean.Json) →
(line column ... | false |
instDistribLatticePrimeMultiset._aux_3 | Mathlib.Data.PNat.Factors | PrimeMultiset → PrimeMultiset → Prop | false |
HasFTaylorSeriesUpToOn.exists_lipschitzOnWith | Mathlib.Analysis.Calculus.ContDiff.RCLike | ∀ {E : Type u_4} {F : Type u_5} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] [inst_2 : NormedAddCommGroup F]
[inst_3 : NormedSpace ℝ F] {f : E → F} {p : E → FormalMultilinearSeries ℝ E F} {s : Set E} {x : E},
HasFTaylorSeriesUpToOn 1 f p (insert x s) → Convex ℝ s → ∃ K, ∃ t ∈ nhdsWithin x s, LipschitzOn... | true |
EquivLike.inv | Mathlib.Data.FunLike.Equiv | {E : Sort u_1} → {α : outParam (Sort u_2)} → {β : outParam (Sort u_3)} → [self : EquivLike E α β] → E → β → α | true |
Order.Ideal.bot_mem._simp_1 | Mathlib.Order.Ideal | ∀ {P : Type u_1} [inst : LE P] [inst_1 : OrderBot P] (s : Order.Ideal P), (⊥ ∈ s) = True | false |
Lean.getIRPhases | Lean.Compiler.MetaAttr | Lean.Environment → Lean.Name → Lean.IRPhases | true |
WithBot.lt_iff_exists_coe | Mathlib.Order.WithBot | ∀ {α : Type u_1} [inst : LT α] {x y : WithBot α}, x < y ↔ ∃ b, y = ↑b ∧ x < ↑b | true |
MeasureTheory.definition._@.Mathlib.MeasureTheory.Function.ConditionalExpectation.Basic.3112114093._hygCtx._hyg.47 | Mathlib.MeasureTheory.Function.ConditionalExpectation.Basic | {α : Type u_1} →
{E : Type u_3} →
MeasurableSpace α →
{m₀ : MeasurableSpace α} →
[inst : NormedAddCommGroup E] →
[CompleteSpace E] → [NormedSpace ℝ E] → MeasureTheory.Measure α → (α → E) → α → E | false |
AlgebraicGeometry.Scheme.Cover.RelativeGluingData.toBase.eq_1 | Mathlib.AlgebraicGeometry.RelativeGluing | ∀ {S : AlgebraicGeometry.Scheme} {𝒰 : S.OpenCover} [inst : CategoryTheory.Category.{u_2, u_1} 𝒰.I₀]
[inst_1 : AlgebraicGeometry.Scheme.Cover.LocallyDirected 𝒰] (d : AlgebraicGeometry.Scheme.Cover.RelativeGluingData 𝒰)
[inst_2 : Small.{u, u_1} 𝒰.I₀] [inst_3 : Quiver.IsThin 𝒰.I₀],
d.toBase =
CategoryTheor... | true |
StandardBorelSpace.polish | Mathlib.MeasureTheory.Constructions.Polish.Basic | ∀ {α : Type u_1} {inst : MeasurableSpace α} [self : StandardBorelSpace α], ∃ x, BorelSpace α ∧ PolishSpace α | true |
Lean.Ptr.mk | Lean.Util.PtrSet | {α : Type u} → α → Lean.Ptr α | true |
fderiv.log | Mathlib.Analysis.SpecialFunctions.Log.Deriv | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] {f : E → ℝ} {x : E},
DifferentiableAt ℝ f x → f x ≠ 0 → fderiv ℝ (fun x => Real.log (f x)) x = (f x)⁻¹ • fderiv ℝ f x | true |
MeasureTheory.Integrable.mul_bdd | Mathlib.MeasureTheory.Function.L1Space.Integrable | ∀ {α : Type u_1} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} {𝕜 : Type u_8} [inst : NormedRing 𝕜]
{f g : α → 𝕜} {c : ℝ},
MeasureTheory.Integrable f μ →
MeasureTheory.AEStronglyMeasurable g μ →
(∀ᵐ (x : α) ∂μ, ‖g x‖ ≤ c) → MeasureTheory.Integrable (fun x => f x * g x) μ | true |
ConditionallyCompletePartialOrderSup.recOn | Mathlib.Order.ConditionallyCompletePartialOrder.Defs | {α : Type u_3} →
{motive : ConditionallyCompletePartialOrderSup α → Sort u} →
(t : ConditionallyCompletePartialOrderSup α) →
([toPartialOrder : PartialOrder α] →
[toSupSet : SupSet α] →
(isLUB_csSup_of_directed :
∀ (s : Set α), DirectedOn (fun x1 x2 => x1 ≤ x2) s → s.No... | false |
MeromorphicAt.update_iff | Mathlib.Analysis.Meromorphic.Basic | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_3} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] [inst_3 : DecidableEq 𝕜] {f : 𝕜 → E} {z w : 𝕜} {e : E},
MeromorphicAt (Function.update f w e) z ↔ MeromorphicAt f z | true |
norm_pos_iff | Mathlib.Analysis.Normed.Group.Basic | ∀ {E : Type u_5} [inst : NormedAddGroup E] {a : E}, 0 < ‖a‖ ↔ a ≠ 0 | true |
MeasureTheory.instCountableInterFilterAe._proof_1 | Mathlib.MeasureTheory.OuterMeasure.AE | ∀ {α : Type u_1} {F : Type u_2} [inst : FunLike F (Set α) ENNReal] [inst_1 : MeasureTheory.OuterMeasureClass F α]
(μ : F), CountableInterFilter (MeasureTheory.ae μ) | false |
Ideal.Quotient.algebraOfLiesOver._proof_2 | Mathlib.RingTheory.Ideal.Over | ∀ {A : Type u_1} {B : Type u_2} [inst : CommRing A] [inst_1 : CommRing B] [inst_2 : Algebra A B] (P : Ideal B)
(p : Ideal A) [P.LiesOver p], p ≤ Ideal.comap (algebraMap A B) P | false |
CompactlySupportedContinuousMap.integralPositiveLinearMap._proof_8 | Mathlib.MeasureTheory.Integral.CompactlySupported | ∀ {X : Type u_1} [inst : TopologicalSpace X] [inst_1 : MeasurableSpace X] (μ : MeasureTheory.Measure X)
(x : CompactlySupportedContinuousMap X ℝ), 0 ≤ ⇑x → 0 ≤ ∫ (x_1 : X), x x_1 ∂μ | false |
derivationOfSectionOfKerSqZero.congr_simp | Mathlib.RingTheory.Smooth.Kaehler | ∀ {R : Type u_1} {P : Type u_2} {S : Type u_3} [inst : CommRing R] [inst_1 : CommRing P] [inst_2 : CommRing S]
[inst_3 : Algebra R P] [inst_4 : Algebra R S] (f : P →ₐ[R] S) (hf' : RingHom.ker f ^ 2 = ⊥) (g g_1 : S →ₐ[R] P)
(e_g : g = g_1) (hg : f.comp g = AlgHom.id R S),
derivationOfSectionOfKerSqZero f hf' g hg ... | true |
Filter.comap_inv_atBot | Mathlib.Order.Filter.AtTopBot.Group | ∀ {G : Type u_2} [inst : CommGroup G] [inst_1 : PartialOrder G] [IsOrderedMonoid G],
Filter.comap Inv.inv Filter.atBot = Filter.atTop | true |
isCompact_compactCovering | Mathlib.Topology.Compactness.SigmaCompact | ∀ (X : Type u_1) [inst : TopologicalSpace X] [inst_1 : SigmaCompactSpace X] (n : ℕ), IsCompact (compactCovering X n) | true |
Algebra.adjoin.powerBasisAux.eq_1 | Mathlib.RingTheory.Adjoin.PowerBasis | ∀ {K : Type u_1} {S : Type u_2} [inst : Field K] [inst_1 : CommRing S] [inst_2 : Algebra K S] {x : S}
(hx : IsIntegral K x), Algebra.adjoin.powerBasisAux hx = Module.Basis.mk ⋯ ⋯ | true |
_private.Mathlib.Topology.Order.IntermediateValue.0.setOf_isPreconnected_eq_of_ordered._simp_1_1 | Mathlib.Topology.Order.IntermediateValue | ∀ {α : Type u_1} {ι : Sort u_4} {f : ι → α} {p : α → Prop}, (∀ a ∈ Set.range f, p a) = ∀ (i : ι), p (f i) | false |
Matroid.copy._proof_4 | Mathlib.Combinatorics.Matroid.Basic | ∀ {α : Type u_1} (M : Matroid α) (E : Set α) (Indep : Set α → Prop),
E = M.E → (∀ (I : Set α), Indep I ↔ M.Indep I) → ∀ X ⊆ E, Matroid.ExistsMaximalSubsetProperty Indep X | false |
_private.Init.Data.ByteArray.Lemmas.0.ByteArray.extract_add_three._proof_1_2 | Init.Data.ByteArray.Lemmas | ∀ {a : ByteArray} {i : ℕ}, i + 3 ≤ a.size → ¬i + 1 ≤ a.size → False | false |
ModuleCat.FilteredColimits.forget₂AddCommGroup_preservesFilteredColimits | Mathlib.Algebra.Category.ModuleCat.FilteredColimits | ∀ {R : Type u} [inst : Ring R],
CategoryTheory.Limits.PreservesFilteredColimits (CategoryTheory.forget₂ (ModuleCat R) AddCommGrpCat) | true |
AddConstEquiv.ext_iff | Mathlib.Algebra.AddConstMap.Equiv | ∀ {G : Type u_1} {H : Type u_2} [inst : Add G] [inst_1 : Add H] {a : G} {b : H} {e₁ e₂ : AddConstEquiv G H a b},
e₁ = e₂ ↔ ∀ (x : G), e₁ x = e₂ x | true |
SSet.ι₀_comp | Mathlib.AlgebraicTopology.SimplicialSet.Monoidal | ∀ {X Y : SSet} (f : X ⟶ Y),
CategoryTheory.CategoryStruct.comp SSet.ι₀
(CategoryTheory.MonoidalCategoryStruct.whiskerRight f (SSet.stdSimplex.obj (SimplexCategory.mk 1))) =
CategoryTheory.CategoryStruct.comp f SSet.ι₀ | true |
lowerSemicontinuousOn_ciSup | Mathlib.Topology.Semicontinuity.Basic | ∀ {α : Type u_1} [inst : TopologicalSpace α] {s : Set α} {ι : Sort u_4} {δ' : Type u_6}
[inst_1 : ConditionallyCompleteLinearOrder δ'] {f : ι → α → δ'},
(∀ x ∈ s, BddAbove (Set.range fun i => f i x)) →
(∀ (i : ι), LowerSemicontinuousOn (f i) s) → LowerSemicontinuousOn (fun x' => ⨆ i, f i x') s | true |
_private.Mathlib.NumberTheory.LSeries.Basic.0.LSeriesSummable_of_le_const_mul_rpow._simp_1_1 | Mathlib.NumberTheory.LSeries.Basic | ∀ (x y : ℂ), (x ^ y)⁻¹ = x ^ (-y) | false |
AbstractSimplicialComplex.instBot | Mathlib.AlgebraicTopology.SimplicialComplex.Basic | {ι : Type u_1} → Bot (AbstractSimplicialComplex ι) | true |
_private.Lean.Meta.Injective.0.Lean.Meta.mkHInjectiveTheoremValue?.match_1 | Lean.Meta.Injective | (motive : Array Lean.FVarId × Lean.MVarId → Sort u_1) →
(__discr : Array Lean.FVarId × Lean.MVarId) →
((fst : Array Lean.FVarId) → (mvarId : Lean.MVarId) → motive (fst, mvarId)) → motive __discr | false |
_private.Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.NonUnital.0._auto_678 | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.NonUnital | Lean.Syntax | false |
CategoryTheory.ComposableArrows.fourδ₃Toδ₂_app_three | Mathlib.CategoryTheory.ComposableArrows.Four | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {i₀ i₁ i₂ i₃ i₄ : C} (f₁ : i₀ ⟶ i₁) (f₂ : i₁ ⟶ i₂)
(f₃ : i₂ ⟶ i₃) (f₄ : i₃ ⟶ i₄) (f₂₃ : i₁ ⟶ i₃) (f₃₄ : i₂ ⟶ i₄) (h₂₃ : CategoryTheory.CategoryStruct.comp f₂ f₃ = f₂₃)
(h₃₄ : CategoryTheory.CategoryStruct.comp f₃ f₄ = f₃₄),
(CategoryTheory.ComposableA... | true |
not_fermat_42 | Mathlib.NumberTheory.FLT.Four | ∀ {a b c : ℤ}, a ≠ 0 → b ≠ 0 → a ^ 4 + b ^ 4 ≠ c ^ 2 | true |
Equiv.Perm.OnCycleFactors.Subgroup.Centralizer.cycleFactorsFinset_mulAction._proof_3 | Mathlib.GroupTheory.Perm.Centralizer | ∀ {α : Type u_1} [inst : DecidableEq α] [inst_1 : Fintype α] (g : Equiv.Perm α) (c : ↥g.cycleFactorsFinset), 1 • c = c | false |
AbstractCompletion.casesOn | Mathlib.Topology.UniformSpace.AbstractCompletion | {α : Type u} →
[inst : UniformSpace α] →
{motive : AbstractCompletion.{v, u} α → Sort u_1} →
(t : AbstractCompletion.{v, u} α) →
((space : Type v) →
(coe : α → space) →
(uniformStruct : UniformSpace space) →
(complete : CompleteSpace space) →
... | false |
_private.Mathlib.Topology.Bases.0.TopologicalSpace.isTopologicalBasis_of_cover._simp_1_2 | Mathlib.Topology.Bases | ∀ {α : Type u} {β : Type v} (f : α → β) (s : Set α) (y : β), (y ∈ f '' s) = ∃ x ∈ s, f x = y | false |
_private.Mathlib.Topology.MetricSpace.GromovHausdorffRealized.0.GromovHausdorff.HD_lipschitz_aux2 | Mathlib.Topology.MetricSpace.GromovHausdorffRealized | ∀ {X : Type u} {Y : Type v} [inst : MetricSpace X] [inst_1 : MetricSpace Y] [Nonempty X] [Nonempty Y]
(f g : GromovHausdorff.Cb✝ X Y), ⨆ y, ⨅ x, f (Sum.inl x, Sum.inr y) ≤ (⨆ y, ⨅ x, g (Sum.inl x, Sum.inr y)) + dist f g | true |
IntermediateField.coe_map | Mathlib.FieldTheory.IntermediateField.Basic | ∀ {K : Type u_1} {L : Type u_2} {L' : Type u_3} [inst : Field K] [inst_1 : Field L] [inst_2 : Field L']
[inst_3 : Algebra K L] [inst_4 : Algebra K L'] (S : IntermediateField K L) (f : L →ₐ[K] L'),
↑(IntermediateField.map f S) = ⇑f '' ↑S | true |
Manifold.Elab.FindModelResult.noConfusionType | Mathlib.Geometry.Manifold.Notation | Sort u → Manifold.Elab.FindModelResult → Manifold.Elab.FindModelResult → Sort u | false |
CategoryTheory.Limits.prod.pentagon | Mathlib.CategoryTheory.Limits.Shapes.BinaryProducts | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasBinaryProducts C]
(W X Y Z : C),
CategoryTheory.CategoryStruct.comp
(CategoryTheory.Limits.prod.map (CategoryTheory.Limits.prod.associator W X Y).hom
(CategoryTheory.CategoryStruct.id Z))
(CategoryTheory.... | true |
CategoryTheory.Functor.WellOrderInductionData.map_succ | Mathlib.CategoryTheory.SmallObject.WellOrderInductionData | ∀ {J : Type u} [inst : LinearOrder J] [inst_1 : SuccOrder J] {F : CategoryTheory.Functor Jᵒᵖ (Type v)}
(self : F.WellOrderInductionData) (j : J) (hj : ¬IsMax j) (x : F.obj (Opposite.op j)),
F.map (CategoryTheory.homOfLE ⋯).op (self.succ j hj x) = x | true |
AlgebraicGeometry.HasRingHomProperty.containsIdentities | Mathlib.AlgebraicGeometry.Morphisms.RingHomProperties | ∀ {P : CategoryTheory.MorphismProperty AlgebraicGeometry.Scheme}
{Q : {R S : Type u} → [inst : CommRing R] → [inst_1 : CommRing S] → (R →+* S) → Prop}
[AlgebraicGeometry.HasRingHomProperty P Q],
(RingHom.ContainsIdentities fun {R S} [CommRing R] [CommRing S] => Q) → P.ContainsIdentities | true |
_private.Mathlib.Tactic.Linter.PrivateModule.0.Mathlib.Linter.privateModule.match_1 | Mathlib.Tactic.Linter.PrivateModule | (motive : Lean.Name × Lean.ConstantInfo → Sort u_1) →
(x : Lean.Name × Lean.ConstantInfo) → ((decl : Lean.Name) → (snd : Lean.ConstantInfo) → motive (decl, snd)) → motive x | false |
Rep.ofHom_nsmul | Mathlib.RepresentationTheory.Rep.Basic | ∀ {k : Type u} {G : Type v} [inst : Semiring k] [inst_1 : Monoid G] {X Y : Type w} [inst_2 : AddCommGroup X]
[inst_3 : AddCommGroup Y] [inst_4 : Module k X] [inst_5 : Module k Y] {ρ : Representation k G X}
{σ : Representation k G Y} (f : ρ.IntertwiningMap σ) (n : ℕ), Rep.ofHom (n • f) = n • Rep.ofHom f | true |
_private.Lean.Server.Completion.CompletionCollectors.0.Lean.Server.Completion.Context.mk.injEq | Lean.Server.Completion.CompletionCollectors | ∀ (uri : Lean.Lsp.DocumentUri) (pos : Lean.Lsp.Position) (completionInfoPos : ℕ) (uri_1 : Lean.Lsp.DocumentUri)
(pos_1 : Lean.Lsp.Position) (completionInfoPos_1 : ℕ),
({ uri := uri, pos := pos, completionInfoPos := completionInfoPos } =
{ uri := uri_1, pos := pos_1, completionInfoPos := completionInfoPos_1 })... | true |
Setoid.quotientQuotientEquivQuotient._proof_3 | Mathlib.Data.Setoid.Basic | ∀ {α : Type u_1} (r s : Setoid α), r ≤ s → ∀ (x x_1 : α), r x x_1 → ⟦x⟧ = ⟦x_1⟧ | false |
Aesop.Frontend.Parser.«priority_%» | Aesop.Frontend.RuleExpr | Lean.ParserDescr | true |
Matrix.compl_apply_diag | Mathlib.Combinatorics.SimpleGraph.AdjMatrix | ∀ {α : Type u_1} {V : Type u_2} [inst : DecidableEq α] [inst_1 : DecidableEq V] (A : Matrix V V α) [inst_2 : Zero α]
[inst_3 : One α] (i : V), A.compl i i = 0 | true |
LinearMap.GeneralLinearGroup.toLinearEquiv | Mathlib.LinearAlgebra.GeneralLinearGroup.Basic | {R : Type u_1} →
{M : Type u_2} →
[inst : Semiring R] →
[inst_1 : AddCommMonoid M] → [inst_2 : Module R M] → LinearMap.GeneralLinearGroup R M → M ≃ₗ[R] M | true |
instDecidableEqComposition.decEq._proof_3 | Mathlib.Combinatorics.Enumerative.Composition | ∀ {n : ℕ} (a : List ℕ) (a_1 : ∀ {i : ℕ}, i ∈ a → 0 < i) (a_2 : a.sum = n) (b : List ℕ) (b_1 : ∀ {i : ℕ}, i ∈ b → 0 < i)
(b_2 : b.sum = n),
¬a = b →
¬{ blocks := a, blocks_pos := a_1, blocks_sum := a_2 } = { blocks := b, blocks_pos := b_1, blocks_sum := b_2 } | false |
MeasureTheory.L1.SimpleFunc.setToL1SCLM'._proof_3 | Mathlib.MeasureTheory.Integral.SetToL1 | ∀ (α : Type u_1) (E : Type u_2) {F : Type u_3} (𝕜 : Type u_4) [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E]
[inst_2 : NormedAddCommGroup F] [inst_3 : NormedSpace ℝ F] {m : MeasurableSpace α} (μ : MeasureTheory.Measure α)
[inst_4 : NormedRing 𝕜] [inst_5 : Module 𝕜 E] [inst_6 : IsBoundedSMul 𝕜 E] [inst... | false |
Multipliable.prod_mul_tprod_nat_add | Mathlib.Topology.Algebra.InfiniteSum.NatInt | ∀ {G : Type u_2} [inst : CommGroup G] [inst_1 : TopologicalSpace G] [IsTopologicalGroup G] [T2Space G] {f : ℕ → G}
(k : ℕ), Multipliable f → (∏ i ∈ Finset.range k, f i) * ∏' (i : ℕ), f (i + k) = ∏' (i : ℕ), f i | true |
_private.Batteries.Tactic.ShowUnused.0.Batteries.Tactic.ShowUnused.visit.visitExpr._unsafe_rec | Batteries.Tactic.ShowUnused | Lean.Environment → Lean.Expr → StateM Lean.NameSet Unit | false |
Pi.instSemilatticeInf.eq_1 | Mathlib.Order.Lattice | ∀ {ι : Type u_1} {α' : ι → Type u_2} [inst : (i : ι) → SemilatticeInf (α' i)],
Pi.instSemilatticeInf =
{ toPartialOrder := Pi.partialOrder, inf := fun x y i => x i ⊓ y i, inf_le_left := ⋯, inf_le_right := ⋯,
le_inf := ⋯ } | true |
Complex.differentiable_exp._simp_1 | Mathlib.Analysis.SpecialFunctions.ExpDeriv | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] [inst_1 : NormedAlgebra 𝕜 ℂ], Differentiable 𝕜 Complex.exp = True | false |
CategoryTheory.Limits.pullbackConeEquivBinaryFan._proof_1 | Mathlib.CategoryTheory.Limits.Constructions.Over.Products | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {X Y Z : C} {f : Y ⟶ X} {g : Z ⟶ X}
(c : CategoryTheory.Limits.PullbackCone f g),
CategoryTheory.CategoryStruct.comp c.fst (CategoryTheory.Over.mk f).hom =
CategoryTheory.CategoryStruct.comp c.fst (CategoryTheory.Over.mk f).hom | false |
Array.range_eq_range' | Init.Data.Array.Range | ∀ {n : ℕ}, Array.range n = Array.range' 0 n | true |
Array.countP_reverse | Init.Data.Array.Count | ∀ {α : Type u_1} {p : α → Bool} {xs : Array α}, Array.countP p xs.reverse = Array.countP p xs | true |
_private.Mathlib.Combinatorics.Matroid.Rank.Finite.0.Matroid.isRkFinite_iff_exists_isBasis'.match_1_1 | Mathlib.Combinatorics.Matroid.Rank.Finite | ∀ {α : Type u_1} {M : Matroid α} {X : Set α} (motive : (∃ I, M.IsBasis' I X ∧ I.Finite) → Prop)
(x : ∃ I, M.IsBasis' I X ∧ I.Finite), (∀ (w : Set α) (hIX : M.IsBasis' w X) (hI : w.Finite), motive ⋯) → motive x | false |
HahnSeries.SummableFamily.pow_finite_co_support | Mathlib.RingTheory.HahnSeries.Summable | ∀ {Γ : Type u_1} {R : Type u_3} [inst : AddCommMonoid Γ] [inst_1 : LinearOrder Γ] [inst_2 : IsOrderedCancelAddMonoid Γ]
[inst_3 : CommRing R] {x : HahnSeries Γ R}, 0 < x.orderTop → ∀ (g : Γ), {a | ((fun n => x ^ n) a).coeff g ≠ 0}.Finite | true |
Besicovitch.TauPackage.noConfusion | Mathlib.MeasureTheory.Covering.Besicovitch | {P : Sort u} →
{β : Type u_1} →
{α : Type u_2} →
{t : Besicovitch.TauPackage β α} →
{β' : Type u_1} →
{α' : Type u_2} →
{t' : Besicovitch.TauPackage β' α'} →
β = β' → α = α' → t ≍ t' → Besicovitch.TauPackage.noConfusionType P t t' | false |
GaloisConnection.l_unique | Mathlib.Order.GaloisConnection.Defs | ∀ {α : Type u} {β : Type v} [inst : PartialOrder α] [inst_1 : Preorder β] {u : α → β} {l : β → α},
GaloisConnection l u →
∀ {u' : α → β} {l' : β → α}, GaloisConnection l' u' → (∀ (a : α), u a = u' a) → ∀ {b : β}, l b = l' b | true |
Std.Time.FormatType.match_1 | Std.Time.Format.Basic | (motive : Std.Time.FormatString → Sort u_1) →
(x : Std.Time.FormatString) →
((entry : Std.Time.Modifier) →
(xs : List Std.Time.FormatPart) → motive (Std.Time.FormatPart.modifier entry :: xs)) →
((val : String) → (xs : List Std.Time.FormatPart) → motive (Std.Time.FormatPart.string val :: xs)) →
... | false |
Ordering.isLE_gt | Init.Data.Ord.Basic | Ordering.gt.isLE = false | true |
CategoryTheory.Limits.pushoutCoconeOfRightIso | Mathlib.CategoryTheory.Limits.Shapes.Pullback.Iso | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{X Y Z : C} → (f : X ⟶ Y) → (g : X ⟶ Z) → [CategoryTheory.IsIso g] → CategoryTheory.Limits.PushoutCocone f g | true |
AlgebraicGeometry.IsFinite.casesOn | Mathlib.AlgebraicGeometry.Morphisms.Finite | {X Y : AlgebraicGeometry.Scheme} →
{f : X ⟶ Y} →
{motive : AlgebraicGeometry.IsFinite f → Sort u} →
(t : AlgebraicGeometry.IsFinite f) →
([toIsAffineHom : AlgebraicGeometry.IsAffineHom f] →
(finite_app :
∀ (U : Y.Opens),
AlgebraicGeometry.IsAffineOpen U ... | false |
PNat.factorMultiset_gcd | Mathlib.Data.PNat.Factors | ∀ (m n : ℕ+), (m.gcd n).factorMultiset = m.factorMultiset ⊓ n.factorMultiset | true |
FirstOrder.Language.ElementarySubstructure.recOn | Mathlib.ModelTheory.ElementarySubstructures | {L : FirstOrder.Language} →
{M : Type u_1} →
[inst : L.Structure M] →
{motive : L.ElementarySubstructure M → Sort u} →
(t : L.ElementarySubstructure M) →
((toSubstructure : L.Substructure M) →
(isElementary' : toSubstructure.IsElementary) →
motive { toSubstruc... | false |
Lean.Meta.matchHEq? | Lean.Meta.MatchUtil | Lean.Expr → Lean.MetaM (Option (Lean.Expr × Lean.Expr × Lean.Expr × Lean.Expr)) | true |
Int.add_lt_add_of_lt_of_le | Init.Data.Int.Order | ∀ {a b c d : ℤ}, a < b → c ≤ d → a + c < b + d | true |
UInt8.toUInt32_ofFin | Init.Data.UInt.Lemmas | ∀ {n : Fin UInt8.size}, (UInt8.ofFin n).toUInt32 = UInt32.ofNatLT ↑n ⋯ | true |
Real.Lp_add_le_tsum_of_nonneg | Mathlib.Analysis.MeanInequalities | ∀ {ι : Type u} {f g : ι → ℝ} {p : ℝ},
1 ≤ p →
(∀ (i : ι), 0 ≤ f i) →
(∀ (i : ι), 0 ≤ g i) →
(Summable fun i => f i ^ p) →
(Summable fun i => g i ^ p) →
(Summable fun i => (f i + g i) ^ p) ∧
(∑' (i : ι), (f i + g i) ^ p) ^ (1 / p) ≤
(∑' (i : ι), f i... | true |
Finset.empty | Mathlib.Data.Finset.Empty | {α : Type u_1} → Finset α | true |
ContinuousMap.instCommMonoidWithZeroOfContinuousMul | Mathlib.Topology.ContinuousMap.Algebra | {α : Type u_1} →
{β : Type u_2} →
[inst : TopologicalSpace α] →
[inst_1 : TopologicalSpace β] → [inst_2 : CommMonoidWithZero β] → [ContinuousMul β] → CommMonoidWithZero C(α, β) | true |
Submonoid.closure_singleton_eq | Mathlib.Algebra.Group.Submonoid.Membership | ∀ {M : Type u_1} [inst : Monoid M] (x : M), Submonoid.closure {x} = MonoidHom.mrange ((powersHom M) x) | true |
Metric.eball_top | Mathlib.Topology.MetricSpace.Pseudo.Defs | ∀ {α : Type u} [inst : PseudoMetricSpace α] (x : α), Metric.eball x ⊤ = Set.univ | true |
CategoryTheory.Pseudofunctor.DescentData'.pullHom'.congr_simp | Mathlib.CategoryTheory.Sites.Descent.DescentDataPrime | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C]
{F : CategoryTheory.Pseudofunctor (CategoryTheory.LocallyDiscrete Cᵒᵖ) CategoryTheory.Cat} {ι : Type t} {S : C}
{X : ι → C} {f : (i : ι) → X i ⟶ S} {sq : (i j : ι) → CategoryTheory.Limits.ChosenPullback (f i) (f j)}
{obj obj' : (i : ι) → ↑(F.obj { as := Opp... | true |
_private.Mathlib.Tactic.TacticAnalysis.Declarations.0.Mathlib.TacticAnalysis.TerminalReplacementOutcome.ctorIdx | Mathlib.Tactic.TacticAnalysis.Declarations | Mathlib.TacticAnalysis.TerminalReplacementOutcome✝ → ℕ | false |
_private.Mathlib.Probability.Process.Filtration.0.MeasureTheory.Filtration.filtrationOfSet_eq_natural._simp_1_3 | Mathlib.Probability.Process.Filtration | ∀ {b a : Prop}, (∃ (_ : a), b) = (a ∧ b) | false |
Path._sizeOf_inst | Mathlib.Topology.Path | {X : Type u_1} → {inst : TopologicalSpace X} → (x y : X) → [SizeOf X] → SizeOf (Path x y) | false |
Pi.Lex.lt_iff_of_unique | Mathlib.Order.PiLex | ∀ {ι : Type u_1} {β : ι → Type u_2} [inst : Unique ι] [inst_1 : (i : ι) → LT (β i)] [inst_2 : Preorder ι]
{x y : Lex ((i : ι) → β i)}, x < y ↔ x default < y default | true |
_private.Mathlib.Algebra.GCDMonoid.Basic.0.lcm_dvd_iff._simp_1_3 | Mathlib.Algebra.GCDMonoid.Basic | ∀ {α : Type u_1} [inst : SemigroupWithZero α] (a : α), (a ∣ 0) = True | false |
_private.Mathlib.Analysis.Calculus.FDeriv.Add.0.differentiableWithinAt_comp_add_left._simp_1_1 | Mathlib.Analysis.Calculus.FDeriv.Add | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {F : Type u_3} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {f : E → F}
{f' : E →L[𝕜] F} {x : E} {s : Set E} (a : E),
HasFDerivWithinAt (fun x => f (a + x)) f' s x = Has... | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.