name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
Lean.Grind.AC.SubsetResult.rec | Lean.Meta.Tactic.Grind.AC.Seq | {motive : Lean.Grind.AC.SubsetResult → Sort u} →
motive Lean.Grind.AC.SubsetResult.false →
motive Lean.Grind.AC.SubsetResult.exact →
((s : Lean.Grind.AC.Seq) → motive (Lean.Grind.AC.SubsetResult.strict s)) →
(t : Lean.Grind.AC.SubsetResult) → motive t | false |
Lean.Meta.Grind.Arith.Cutsat.ToIntTermInfo.mk.inj | Lean.Meta.Tactic.Grind.Arith.Cutsat.ToIntInfo | ∀ {eToInt α he eToInt_1 α_1 he_1 : Lean.Expr},
{ eToInt := eToInt, α := α, he := he } = { eToInt := eToInt_1, α := α_1, he := he_1 } →
eToInt = eToInt_1 ∧ α = α_1 ∧ he = he_1 | true |
_private.Mathlib.RingTheory.Etale.QuasiFinite.0.Algebra.exists_etale_isIdempotentElem_forall_liesOver_eq_aux._proof_1_3 | Mathlib.RingTheory.Etale.QuasiFinite | ∀ {R : Type u_1} {S : Type u_2} [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S] (p : Ideal R)
[inst_3 : p.IsPrime] (q : Ideal S) [inst_4 : q.IsPrime] [inst_5 : q.LiesOver p] (R' : Type u_1) (w : CommRing R')
(w_1 : Algebra R R') (P : Ideal R') (w_2 : P.IsPrime) (w_3 : P.LiesOver p)
(hP : Function... | false |
_private.Lean.Linter.UnusedVariables.0.Lean.Linter.UnusedVariables.visitAssignments.visitExpr | Lean.Linter.UnusedVariables | IO.Ref (Std.HashSet USize) → IO.Ref (Std.HashSet Lean.FVarId) → Lean.Expr → Lean.MonadCacheT Lean.Expr Unit IO Unit | true |
Lean.Elab.Term.withSynthesize | Lean.Elab.SyntheticMVars | {m : Type → Type u_1} →
{α : Type} →
[MonadFunctorT Lean.Elab.TermElabM m] →
m α → optParam Lean.Elab.Term.PostponeBehavior Lean.Elab.Term.PostponeBehavior.no → m α | true |
Lean.PersistentArrayNode.node.elim | Lean.Data.PersistentArray | {α : Type u} →
{motive_1 : Lean.PersistentArrayNode α → Sort u_1} →
(t : Lean.PersistentArrayNode α) →
t.ctorIdx = 0 →
((cs : Array (Lean.PersistentArrayNode α)) → motive_1 (Lean.PersistentArrayNode.node cs)) → motive_1 t | false |
ContinuousWithinAt.eval_const | Mathlib.Topology.Hom.ContinuousEvalConst | ∀ {F : Type u_1} {α : Type u_2} {X : Type u_3} {Z : Type u_4} [inst : FunLike F α X] [inst_1 : TopologicalSpace F]
[inst_2 : TopologicalSpace X] [ContinuousEvalConst F α X] [inst_4 : TopologicalSpace Z] {f : Z → F} {s : Set Z}
{z : Z}, ContinuousWithinAt f s z → ∀ (x : α), ContinuousWithinAt (fun x_1 => (f x_1) x) ... | true |
Setoid.eq_iff_rel_eq | Mathlib.Data.Setoid.Basic | ∀ {α : Type u_1} {r₁ r₂ : Setoid α}, r₁ = r₂ ↔ ⇑r₁ = ⇑r₂ | true |
FreeGroup.Red.Step.lift | Mathlib.GroupTheory.FreeGroup.Basic | ∀ {α : Type u} {L₁ L₂ : List (α × Bool)} {β : Type v} [inst : Group β] {f : α → β},
FreeGroup.Red.Step L₁ L₂ → FreeGroup.Lift.aux f L₁ = FreeGroup.Lift.aux f L₂ | true |
Function.Injective.mem_range_iff_existsUnique | Mathlib.Data.Set.Image | ∀ {α : Type u_1} {β : Type u_2} {f : α → β}, Function.Injective f → ∀ {b : β}, b ∈ Set.range f ↔ ∃! a, f a = b | true |
Lean.Server.Test.Runner.Client.InteractiveGoalCore.noConfusionType | Lean.Server.Test.Runner | Sort u →
Lean.Server.Test.Runner.Client.InteractiveGoalCore → Lean.Server.Test.Runner.Client.InteractiveGoalCore → Sort u | false |
pow_le_pow | Mathlib.Algebra.Order.Monoid.Unbundled.Pow | ∀ {M : Type u_3} [inst : Monoid M] [inst_1 : Preorder M] [MulLeftMono M] [MulRightMono M] {a b : M},
a ≤ b → 1 ≤ b → ∀ {m n : ℕ}, m ≤ n → a ^ m ≤ b ^ n | true |
Std.TreeSet.isSome_max?_eq_not_isEmpty | Std.Data.TreeSet.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t : Std.TreeSet α cmp} [Std.TransCmp cmp], t.max?.isSome = !t.isEmpty | true |
CategoryTheory.LocalizerMorphism.LeftResolution.comp_f_assoc | Mathlib.CategoryTheory.Localization.Resolution | ∀ {C₁ : Type u_1} {C₂ : Type u_2} [inst : CategoryTheory.Category.{v_1, u_1} C₁]
[inst_1 : CategoryTheory.Category.{v_2, u_2} C₂] {W₁ : CategoryTheory.MorphismProperty C₁}
{W₂ : CategoryTheory.MorphismProperty C₂} {Φ : CategoryTheory.LocalizerMorphism W₁ W₂} {X₂ : C₂}
{L L' L'' : Φ.LeftResolution X₂} (φ : L ⟶ L')... | true |
Function.locallyFinsuppWithin.restrictMonoidHom._proof_2 | Mathlib.Topology.LocallyFinsupp | ∀ {X : Type u_1} [inst : TopologicalSpace X] {U : Set X} {Y : Type u_2} [inst_1 : AddCommGroup Y] {V : Set X}
(h : V ⊆ U), Function.locallyFinsuppWithin.restrict 0 h = 0 | false |
LinearEquiv.algEquivOfRing._proof_1 | Mathlib.Algebra.Algebra.Equiv | ∀ {R : Type u_1} {A : Type u_2} [inst : CommSemiring R] [inst_1 : CommSemiring A] [inst_2 : Algebra R A] (e : R ≃ₗ[R] A)
(x : R), e.symm (e 1 * (algebraMap R A) x) = e.symm (x • e 1) | false |
mdifferentiableAt_prod_module_iff | Mathlib.Geometry.Manifold.MFDeriv.SpecificFunctions | ∀ {𝕜 : 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] {F₁ : Type u_17} [inst_6 : NormedAddCom... | true |
Associates.mk_surjective | Mathlib.Algebra.GroupWithZero.Associated | ∀ {M : Type u_1} [inst : Monoid M], Function.Surjective Associates.mk | true |
List.sbtw_iff_triplewise_and_ne_pair | Mathlib.Analysis.Convex.BetweenList | ∀ {R : Type u_1} {V : Type u_2} {P : Type u_4} [inst : Ring R] [inst_1 : PartialOrder R] [inst_2 : AddCommGroup V]
[inst_3 : Module R V] [inst_4 : AddTorsor V P] [IsOrderedRing R] {l : List P},
List.Sbtw R l ↔ List.Triplewise (Sbtw R) l ∧ ∀ (a : P), l ≠ [a, a] | true |
MeasureTheory.JordanDecomposition.exists_compl_positive_negative | Mathlib.MeasureTheory.VectorMeasure.Decomposition.Jordan | ∀ {α : Type u_1} [inst : MeasurableSpace α] (j : MeasureTheory.JordanDecomposition α),
∃ S,
MeasurableSet S ∧
MeasureTheory.VectorMeasure.restrict j.toSignedMeasure S ≤ MeasureTheory.VectorMeasure.restrict 0 S ∧
MeasureTheory.VectorMeasure.restrict 0 Sᶜ ≤ MeasureTheory.VectorMeasure.restrict j.toSig... | true |
alexDiscEquivPreord_inverse_map | Mathlib.Topology.Order.Category.AlexDisc | ∀ {X Y : Preord} (f : X ⟶ Y),
alexDiscEquivPreord.inverse.map f =
CategoryTheory.ConcreteCategory.ofHom (Topology.WithUpperSet.map (Preord.Hom.hom f)) | true |
TopologicalSpace.isSeparable_iUnion._simp_1 | Mathlib.Topology.Bases | ∀ {α : Type u} [t : TopologicalSpace α] {ι : Sort u_2} [Countable ι] {s : ι → Set α},
TopologicalSpace.IsSeparable (⋃ i, s i) = ∀ (i : ι), TopologicalSpace.IsSeparable (s i) | false |
CategoryTheory.Over.postAdjunctionLeft_counit_app_left | Mathlib.CategoryTheory.Comma.Over.Pullback | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
[inst_2 : CategoryTheory.Limits.HasPullbacks C] {X : C} {F : CategoryTheory.Functor C D}
{G : CategoryTheory.Functor D C} (a : F ⊣ G)
(X_1 : CategoryTheory.Over ((CategoryTheory.Functor.id D).obj (... | true |
List.Pairwise.destutter_eq_dedup | Mathlib.Data.List.Destutter | ∀ {α : Type u_1} [inst : DecidableEq α] {r : α → α → Prop} [Std.Antisymm r] {l : List α},
List.Pairwise r l → List.destutter (fun x1 x2 => x1 ≠ x2) l = l.dedup | true |
LinearIsometryEquiv.norm_iteratedFDeriv_comp_left | Mathlib.Analysis.Calculus.ContDiff.Basic | ∀ {𝕜 : Type u_1} {E : Type u_2} {F : Type u_3} {G : Type u_4} [inst : NontriviallyNormedField 𝕜]
[inst_1 : NormedAddCommGroup E] [inst_2 : NormedSpace 𝕜 E] [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F]
[inst_5 : NormedAddCommGroup G] [inst_6 : NormedSpace 𝕜 G] (g : F ≃ₗᵢ[𝕜] G) (f : E → F) (x : E)... | true |
CategoryTheory.Abelian.Ext.comp_zero | Mathlib.Algebra.Homology.DerivedCategory.Ext.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Abelian C]
[inst_2 : CategoryTheory.HasExt C] {X Y : C} {n : ℕ} (α : CategoryTheory.Abelian.Ext X Y n) (Z : C) (m p : ℕ)
(h : n + m = p), α.comp 0 h = 0 | true |
ProbabilityTheory.measurePreserving_restrict₂_multivariateGaussian | Mathlib.Probability.Distributions.Gaussian.Multivariate | ∀ {ι : Type u_2} [inst : DecidableEq ι] {I J : Finset ι} {μ : EuclideanSpace ℝ ↥I} {S : Matrix ↥I ↥I ℝ},
S.PosSemidef →
∀ (hJI : J ⊆ I),
MeasureTheory.MeasurePreserving (⇑(EuclideanSpace.restrict₂ hJI)) (ProbabilityTheory.multivariateGaussian μ S)
(ProbabilityTheory.multivariateGaussian ((EuclideanS... | true |
Int.Linear.Poly.divCoeffs.eq_2 | Init.Data.Int.Linear | ∀ (k k_1 : ℤ) (v : Int.Linear.Var) (p_1 : Int.Linear.Poly),
Int.Linear.Poly.divCoeffs k (Int.Linear.Poly.add k_1 v p_1) = (k_1 % k == 0 && Int.Linear.Poly.divCoeffs k p_1) | true |
Order.IsPredPrelimit.eq_1 | Mathlib.Order.SuccPred.Limit | ∀ {α : Type u_1} [inst : LT α] (a : α), Order.IsPredPrelimit a = ∀ (b : α), ¬a ⋖ b | true |
NormedSpace.invertibleExpOfMemBall | Mathlib.Analysis.Normed.Algebra.Exponential | {𝕂 : Type u_1} →
{𝔸 : Type u_2} →
[inst : NontriviallyNormedField 𝕂] →
[inst_1 : NormedRing 𝔸] →
[inst_2 : NormedAlgebra 𝕂 𝔸] →
[CompleteSpace 𝔸] →
[CharZero 𝕂] →
{x : 𝔸} → x ∈ Metric.eball 0 (NormedSpace.expSeries 𝕂 𝔸).radius → Invertible (NormedSpace.... | true |
HurwitzZeta.evenKernel._proof_1 | Mathlib.NumberTheory.LSeries.HurwitzZetaEven | ∀ (x : ℝ),
Function.Periodic
(fun ξ => Real.exp (-Real.pi * ξ ^ 2 * x) * (jacobiTheta₂ (↑ξ * Complex.I * ↑x) (Complex.I * ↑x)).re) 1 | false |
_private.Init.Data.Range.Polymorphic.NatLemmas.0.Nat.toList_roc_eq_if._proof_1_2 | Init.Data.Range.Polymorphic.NatLemmas | ∀ {m n : ℕ}, ¬m + 1 < n + 1 → ¬n < m + 1 → False | false |
CategoryTheory.MorphismProperty.RightFraction.ofHom_f | Mathlib.CategoryTheory.Localization.CalculusOfFractions | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] (W : CategoryTheory.MorphismProperty C) {X Y : C}
(f : X ⟶ Y) [inst_1 : W.ContainsIdentities], (CategoryTheory.MorphismProperty.RightFraction.ofHom W f).f = f | true |
AlgebraicGeometry.ext_of_isDominant | Mathlib.AlgebraicGeometry.Morphisms.Separated | ∀ {W X Y : AlgebraicGeometry.Scheme} [AlgebraicGeometry.IsReduced X] {f g : X ⟶ Y} [Y.IsSeparated] (ι : W ⟶ X)
[AlgebraicGeometry.IsDominant ι],
CategoryTheory.CategoryStruct.comp ι f = CategoryTheory.CategoryStruct.comp ι g → f = g | true |
_private.Mathlib.Algebra.Homology.Embedding.CochainComplex.0.CochainComplex.exists_iso_single._proof_1_4 | Mathlib.Algebra.Homology.Embedding.CochainComplex | ∀ (n i : ℤ), n < i → n < i | false |
Std.DHashMap.Internal.mkIdx._proof_2 | Std.Data.DHashMap.Internal.Index | ∀ (sz : ℕ),
0 < sz → ∀ (hash : UInt64), ((Std.DHashMap.Internal.scrambleHash hash).toUSize &&& USize.ofNat sz - 1).toNat < sz | false |
IsLocalization.Away.mvPolynomialQuotientEquiv.congr_simp | Mathlib.RingTheory.Extension.Presentation.Basic | ∀ {R : Type u_2} [inst : CommRing R] (S : Type u_3) [inst_1 : CommRing S] [inst_2 : Algebra R S] (r : R)
[inst_3 : IsLocalization.Away r S],
IsLocalization.Away.mvPolynomialQuotientEquiv S r = IsLocalization.Away.mvPolynomialQuotientEquiv S r | true |
Hindman.FP.below.casesOn | Mathlib.Combinatorics.Hindman | ∀ {M : Type u_1} [inst : Semigroup M] {motive : (a : Stream' M) → (a_1 : M) → Hindman.FP a a_1 → Prop}
{motive_1 : {a : Stream' M} → {a_1 : M} → (t : Hindman.FP a a_1) → Hindman.FP.below t → Prop} {a : Stream' M}
{a_1 : M} {t : Hindman.FP a a_1} (t_1 : Hindman.FP.below t),
(∀ (a : Stream' M), motive_1 ⋯ ⋯) →
... | false |
Std.HashMap.Raw.size_filter_le_size | Std.Data.HashMap.RawLemmas | ∀ {α : Type u} {β : Type v} [inst : BEq α] [inst_1 : Hashable α] {m : Std.HashMap.Raw α β} [EquivBEq α]
[LawfulHashable α] {f : α → β → Bool}, m.WF → (Std.HashMap.Raw.filter f m).size ≤ m.size | true |
_private.Init.Data.UInt.Bitwise.0.UInt32.xor_right_inj._simp_1_1 | Init.Data.UInt.Bitwise | ∀ {a b : UInt32}, (a = b) = (a.toBitVec = b.toBitVec) | false |
Lean.Lsp.CallHierarchyItem._sizeOf_inst | Lean.Data.Lsp.LanguageFeatures | SizeOf Lean.Lsp.CallHierarchyItem | false |
Batteries.RBNode.Path.Zoomed._unsafe_rec | Batteries.Data.RBMap.Alter | {α : Type u_1} → (α → Ordering) → Batteries.RBNode.Path α → Prop | false |
Associates.normalize_out | Mathlib.Algebra.GCDMonoid.Basic | ∀ {α : Type u_1} [inst : CommMonoidWithZero α] [inst_1 : IsCancelMulZero α] [inst_2 : NormalizationMonoid α]
(a : Associates α), normalize a.out = a.out | true |
Locale.pt | Mathlib.Topology.Order.Category.FrameAdjunction | CategoryTheory.Functor Locale TopCat | true |
CategoryTheory.Lax.OplaxTrans.associator | Mathlib.CategoryTheory.Bicategory.FunctorBicategory.Lax | {B : Type u₁} →
[inst : CategoryTheory.Bicategory B] →
{C : Type u₂} →
[inst_1 : CategoryTheory.Bicategory C] →
{F G H I : CategoryTheory.LaxFunctor B C} →
(η : F ⟶ G) →
(θ : G ⟶ H) →
(ι : H ⟶ I) →
CategoryTheory.CategoryStruct.comp (CategoryTheory... | true |
_private.Mathlib.Algebra.Order.GroupWithZero.Unbundled.Basic.0.zpow_left_strictMonoOn₀._proof_1_1 | Mathlib.Algebra.Order.GroupWithZero.Unbundled.Basic | ∀ (n : ℕ), 0 < ↑n → ¬n = 0 | false |
Class.coe_empty | Mathlib.SetTheory.ZFC.Class | ↑∅ = ∅ | true |
nnnorm_apply_le_nnnorm_cfcₙ._auto_3 | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Isometric | Lean.Syntax | false |
AlgHom.tensorEqualizerEquiv_apply | Mathlib.RingTheory.Flat.Equalizer | ∀ {R : Type u_1} (S : Type u_2) [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S] (T : Type u_3)
[inst_3 : CommRing T] [inst_4 : Algebra R T] [inst_5 : Algebra S T] [inst_6 : IsScalarTower R S T] {A : Type u_4}
{B : Type u_5} [inst_7 : CommRing A] [inst_8 : CommRing B] [inst_9 : Algebra R A] [inst_10... | true |
Set.Finite.iSup_biInf_of_antitone | Mathlib.Data.Set.Finite.Lattice | ∀ {ι : Type u_1} {ι' : Type u_2} {α : Type u_3} [inst : Preorder ι'] [Nonempty ι'] [IsCodirectedOrder ι']
[inst_3 : Order.Frame α] {s : Set ι},
s.Finite → ∀ {f : ι → ι' → α}, (∀ i ∈ s, Antitone (f i)) → ⨆ j, ⨅ i ∈ s, f i j = ⨅ i ∈ s, ⨆ j, f i j | true |
Std.Time.GenericFormat.ctorIdx | Std.Time.Format.Basic | {awareness : Std.Time.Awareness} → Std.Time.GenericFormat awareness → ℕ | false |
Lean.PrettyPrinter.Parenthesizer.many1NoAntiquot.parenthesizer | Lean.PrettyPrinter.Parenthesizer | Lean.PrettyPrinter.Parenthesizer → Lean.PrettyPrinter.Parenthesizer | true |
Set.pi_univ_Ici | Mathlib.Order.Interval.Set.Pi | ∀ {ι : Type u_1} {α : ι → Type u_2} [inst : (i : ι) → Preorder (α i)] (x : (i : ι) → α i),
(Set.univ.pi fun i => Set.Ici (x i)) = Set.Ici x | true |
Sym2.diagSet_compl_eq_fromRel_ne | Mathlib.Data.Sym.Sym2 | ∀ {α : Type u_1}, Sym2.diagSetᶜ = Sym2.fromRel ⋯ | true |
Nat.Linear.Poly.cancelAux.eq_def | Init.Data.Nat.Linear | ∀ (fuel : ℕ) (m₁ m₂ r₁ r₂ : Nat.Linear.Poly),
Nat.Linear.Poly.cancelAux fuel m₁ m₂ r₁ r₂ =
match fuel with
| 0 => (List.reverse r₁ ++ m₁, List.reverse r₂ ++ m₂)
| fuel.succ =>
match m₁, m₂ with
| m₁, [] => (List.reverse r₁ ++ m₁, List.reverse r₂)
| [], m₂ => (List.reverse r₁, List.revers... | true |
BoxIntegral.IntegrationParams.RCond.eq_1 | Mathlib.Analysis.BoxIntegral.Partition.Filter | ∀ {ι : Type u_2} (l : BoxIntegral.IntegrationParams) (r : (ι → ℝ) → ↑(Set.Ioi 0)),
l.RCond r = (l.bRiemann = true → ∀ (x : ι → ℝ), r x = r 0) | true |
instFintypeWithTop._aux_1 | Mathlib.Data.Fintype.WithTopBot | {α : Type u_1} → [Fintype α] → Finset (WithTop α) | false |
FirstOrder.Language.LHom.IsExpansionOn.map_onFunction._autoParam | Mathlib.ModelTheory.LanguageMap | Lean.Syntax | false |
Lean.Elab.Command.addInheritDocDefault | Lean.Elab.Notation | Lean.Term →
Option (Lean.Syntax.TSepArray `Lean.Parser.Term.attrInstance ",") →
Option (Lean.Syntax.TSepArray `Lean.Parser.Term.attrInstance ",") | true |
Lean.Elab.Term.Quotation.HeadCheck.slice.elim | Lean.Elab.Quotation | {motive : Lean.Elab.Term.Quotation.HeadCheck → Sort u} →
(t : Lean.Elab.Term.Quotation.HeadCheck) →
t.ctorIdx = 2 →
((numPrefix numSuffix : ℕ) → motive (Lean.Elab.Term.Quotation.HeadCheck.slice numPrefix numSuffix)) → motive t | false |
LinearMap.prodMapRingHom_apply | Mathlib.LinearAlgebra.Prod | ∀ (R : Type u) (M : Type v) (M₂ : Type w) [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : AddCommMonoid M₂]
[inst_3 : Module R M] [inst_4 : Module R M₂] (f : (M →ₗ[R] M) × (M₂ →ₗ[R] M₂)),
(LinearMap.prodMapRingHom R M M₂) f = f.1.prodMap f.2 | true |
_private.Lean.Meta.Tactic.Grind.Arith.Cutsat.ToInt.0.Lean.Meta.Grind.Arith.Cutsat.expandIfWrap.match_1 | Lean.Meta.Tactic.Grind.Arith.Cutsat.ToInt | (motive : Option Lean.Expr → Sort u_1) →
(x : Option Lean.Expr) → (Unit → motive none) → ((b : Lean.Expr) → motive (some b)) → motive x | false |
LinearEquiv.mk.congr_simp | Mathlib.Algebra.Module.Equiv.Basic | ∀ {R : Type u_14} {S : Type u_15} [inst : Semiring R] [inst_1 : Semiring S] {σ : R →+* S} {σ' : S →+* R}
[inst_2 : RingHomInvPair σ σ'] [inst_3 : RingHomInvPair σ' σ] {M : Type u_16} {M₂ : Type u_17}
[inst_4 : AddCommMonoid M] [inst_5 : AddCommMonoid M₂] [inst_6 : Module R M] [inst_7 : Module S M₂]
(toLinearMap t... | true |
SchwartzMap.fourier_inversion_inv | Mathlib.Analysis.Distribution.SchwartzSpace.Fourier | ∀ {E : Type u_5} {F : Type u_6} {inst : FourierTransform F E} {inst_1 : FourierTransformInv E F}
[self : FourierInvPair E F] (f : E), FourierTransform.fourier (FourierTransformInv.fourierInv f) = f | true |
SNum.instNeg | Mathlib.Data.Num.Bitwise | Neg SNum | true |
AddUnits.addAction'._proof_3 | Mathlib.Algebra.Group.Action.Units | ∀ {G : Type u_2} {M : Type u_1} [inst : AddGroup G] [inst_1 : AddMonoid M] [inst_2 : AddAction G M]
[inst_3 : VAddCommClass G M M] [inst_4 : VAddAssocClass G M M] (x x_1 : G) (x_2 : AddUnits M),
(x + x_1) +ᵥ x_2 = x +ᵥ x_1 +ᵥ x_2 | false |
NNRat.divNat._proof_1 | Mathlib.Data.NNRat.Defs | ∀ (n d : ℕ), 0 ≤ Rat.divInt ↑n ↑d | false |
Filter.tendsto_sup | Mathlib.Order.Filter.Tendsto | ∀ {α : Type u_1} {β : Type u_2} {f : α → β} {x₁ x₂ : Filter α} {y : Filter β},
Filter.Tendsto f (x₁ ⊔ x₂) y ↔ Filter.Tendsto f x₁ y ∧ Filter.Tendsto f x₂ y | true |
jacobiSym.mod_right | Mathlib.NumberTheory.LegendreSymbol.JacobiSymbol | ∀ (a : ℤ) {b : ℕ}, Odd b → jacobiSym a b = jacobiSym a (b % (4 * a.natAbs)) | true |
Finset.single_le_sum_of_canonicallyOrdered | Mathlib.Algebra.Order.BigOperators.Group.Finset | ∀ {ι : Type u_1} {M : Type u_4} [inst : AddCommMonoid M] [inst_1 : Preorder M] [CanonicallyOrderedAdd M] {f : ι → M}
{s : Finset ι} {i : ι}, i ∈ s → f i ≤ ∑ j ∈ s, f j | true |
CategoryTheory.FreeBicategory.liftHom.match_1 | Mathlib.CategoryTheory.Bicategory.Free | {B : Type u_1} →
[inst : Quiver B] →
(motive : (x x_1 : CategoryTheory.FreeBicategory B) → (x ⟶ x_1) → Sort u_3) →
(x x_1 : CategoryTheory.FreeBicategory B) →
(x_2 : x ⟶ x_1) →
((x x_3 : B) → (f : x ⟶ x_3) → motive x x_3 (CategoryTheory.FreeBicategory.Hom.of f)) →
((a : B) → mo... | false |
summable_of_sum_range_le | Mathlib.Topology.Algebra.InfiniteSum.Real | ∀ {f : ℕ → ℝ} {c : ℝ}, (∀ (n : ℕ), 0 ≤ f n) → (∀ (n : ℕ), ∑ i ∈ Finset.range n, f i ≤ c) → Summable f | true |
Mathlib.StacksTag.Tag.noConfusion | Mathlib.Tactic.StacksAttribute | {P : Sort u} → {t t' : Mathlib.StacksTag.Tag} → t = t' → Mathlib.StacksTag.Tag.noConfusionType P t t' | false |
Bimod.TensorBimod.actRight._proof_4 | Mathlib.CategoryTheory.Monoidal.Bimod | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.MonoidalCategory C]
{R S T : CategoryTheory.Mon C} (P : Bimod R S) (Q : Bimod S T)
[∀ (X : C),
CategoryTheory.Limits.PreservesColimitsOfSize.{0, 0, u_1, u_1, u_2, u_2}
(CategoryTheory.MonoidalCategory.tensorRight X... | false |
CategoryTheory.ShortComplex.HomologyData.ofEpiMonoFactorisation.f'_eq | Mathlib.Algebra.Homology.ShortComplex.Abelian | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Abelian C]
(S : CategoryTheory.ShortComplex C) {kf : CategoryTheory.Limits.KernelFork S.g}
(hkf : CategoryTheory.Limits.IsLimit kf),
hkf.lift (CategoryTheory.Limits.KernelFork.ofι S.f ⋯) =
CategoryTheory.CategoryStruct.comp S.to... | true |
Finset.expect | Mathlib.Algebra.BigOperators.Expect | {ι : Type u_1} → {M : Type u_3} → [inst : AddCommMonoid M] → [Module ℚ≥0 M] → Finset ι → (ι → M) → M | true |
_private.Mathlib.Topology.ContinuousOn.0.continuousOn_singleton._simp_1_2 | Mathlib.Topology.ContinuousOn | ∀ {α : Type u_1} {β : Type u_2} {f : α → β} {a : α} {l : Filter β}, Filter.Tendsto f (pure a) l = ∀ s ∈ l, f a ∈ s | false |
CategoryTheory.GradedObject.isInitialSingleObjApply._proof_1 | Mathlib.CategoryTheory.GradedObject.Single | ∀ {J : Type u_3} {C : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} C]
[inst_1 : CategoryTheory.Limits.HasInitial C] [inst_2 : DecidableEq J] (j : J) (X : C) (i : J),
i ≠ j → CategoryTheory.Limits.IsInitial (if i = j then X else ⊥_ C) = CategoryTheory.Limits.IsInitial (⊥_ C) | false |
iInf_singleton | Mathlib.Order.CompleteLattice.Basic | ∀ {α : Type u_1} {β : Type u_2} [inst : CompleteLattice α] {f : β → α} {b : β}, ⨅ x ∈ {b}, f x = f b | true |
_private.Mathlib.AlgebraicGeometry.EllipticCurve.DivisionPolynomial.Basic.0.WeierstrassCurve.Φ_neg._simp_1_5 | Mathlib.AlgebraicGeometry.EllipticCurve.DivisionPolynomial.Basic | ∀ {α : Type u_2} [inst : SubtractionMonoid α] {a : α}, Even (-a) = Even a | false |
instFintypeWithTop | Mathlib.Data.Fintype.WithTopBot | {α : Type u_1} → [Fintype α] → Fintype (WithTop α) | true |
_private.Mathlib.CategoryTheory.Generator.Basic.0.CategoryTheory.ObjectProperty.IsCoseparating.isCodetecting._simp_1_2 | Mathlib.CategoryTheory.Generator.Basic | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] (P : CategoryTheory.ObjectProperty C),
P.IsCoseparating = P.op.IsSeparating | false |
Finite.card_eq_zero_of_surjective | Mathlib.Data.Finite.Card | ∀ {α : Type u_1} {β : Type u_2} {f : α → β}, Function.Surjective f → Nat.card β = 0 → Nat.card α = 0 | true |
Std.ExtDHashMap.Const.get?_filterMap | Std.Data.ExtDHashMap.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {β : Type v} {γ : Type w} {m : Std.ExtDHashMap α fun x => β}
[inst : EquivBEq α] [inst_1 : LawfulHashable α] {f : α → β → Option γ} {k : α},
Std.ExtDHashMap.Const.get? (Std.ExtDHashMap.filterMap f m) k =
(Std.ExtDHashMap.Const.get? m k).pbind fun x_2 h' => f (m.getK... | true |
Vector.toList_map | Init.Data.Vector.Lemmas | ∀ {α : Type u_1} {β : Type u_2} {n : ℕ} {f : α → β} {xs : Vector α n}, (Vector.map f xs).toList = List.map f xs.toList | true |
Option.min_eq_some_iff._simp_1 | Init.Data.Option.Lemmas | ∀ {α : Type u_1} [inst : Min α] {o o' : Option α} {a : α},
(o ⊓ o' = some a) = ∃ b c, o = some b ∧ o' = some c ∧ b ⊓ c = a | false |
fourierSubalgebra_coe | Mathlib.Analysis.Fourier.AddCircle | ∀ {T : ℝ}, Subalgebra.toSubmodule fourierSubalgebra.toSubalgebra = Submodule.span ℂ (Set.range fourier) | true |
AlgebraicGeometry.Spec.map_surjective | Mathlib.AlgebraicGeometry.GammaSpecAdjunction | ∀ {R S : CommRingCat}, Function.Surjective AlgebraicGeometry.Spec.map | true |
FreeMonoid.map._proof_2 | Mathlib.Algebra.FreeMonoid.Basic | ∀ {α : Type u_1} {β : Type u_2} (f : α → β) (x x_1 : FreeMonoid α),
List.map f (FreeMonoid.toList x ++ FreeMonoid.toList x_1) =
List.map f (FreeMonoid.toList x) ++ List.map f (FreeMonoid.toList x_1) | false |
Std.CloseableChannel.Error.alreadyClosed | Std.Sync.Channel | Std.CloseableChannel.Error | true |
_private.Mathlib.Analysis.Analytic.Within.0.hasFPowerSeriesWithinAt_iff_exists_hasFPowerSeriesAt._simp_1_10 | Mathlib.Analysis.Analytic.Within | ∀ {α : Type u} [inst : LinearOrder α] {a b c : α}, (a < min b c) = (a < b ∧ a < c) | false |
MeasureTheory.Lp.coe_posPart._simp_1 | Mathlib.MeasureTheory.Function.LpSpace.Basic | ∀ {α : Type u_1} {m : MeasurableSpace α} {p : ENNReal} {μ : MeasureTheory.Measure α} (f : ↥(MeasureTheory.Lp ℝ p μ)),
(↑f).posPart = ↑(MeasureTheory.Lp.posPart f) | false |
CategoryTheory.mono_iff_injective | Mathlib.CategoryTheory.Types.Basic | ∀ {X Y : Type u} (f : X ⟶ Y), CategoryTheory.Mono f ↔ Function.Injective f | true |
ENNReal.tendsto_nat_tsum | Mathlib.Topology.Algebra.InfiniteSum.ENNReal | ∀ (f : ℕ → ENNReal), Filter.Tendsto (fun n => ∑ i ∈ Finset.range n, f i) Filter.atTop (nhds (∑' (n : ℕ), f n)) | true |
Std.DTreeMap.Internal.Impl.getKey_insertMany!_list_of_mem | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Std.DTreeMap.Internal.Impl α β} [Std.TransOrd α],
t.WF →
∀ {l : List ((a : α) × β a)} {k k' : α},
compare k k' = Ordering.eq →
List.Pairwise (fun a b => ¬compare a.fst b.fst = Ordering.eq) l →
k ∈ List.map Sigma.fst l →
∀ {... | true |
Std.Do.Spec.seq' | Std.Do.Triple.SpecLemmas | ∀ {m : Type u → Type v} {ps : Std.Do.PostShape} {P : Std.Do.Assertion ps} [inst : Monad m]
[inst_1 : Std.Do.WPMonad m ps] {α β : Type u} {x : m (α → β)} {y : m α} {Q : Std.Do.PostCond β ps},
⦃P⦄ x ⦃(fun f => (Std.Do.wp y).apply (fun a => Q.1 (f a), Q.2), Q.2)⦄ → ⦃P⦄ (x <*> y) ⦃Q⦄ | true |
Lean.MetavarContext.getDelayedMVarAssignmentCore? | Lean.MetavarContext | Lean.MetavarContext → Lean.MVarId → Option Lean.DelayedMetavarAssignment | true |
Std.DTreeMap.mem_of_mem_insert | Std.Data.DTreeMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t : Std.DTreeMap α β cmp} [Std.TransCmp cmp] {k a : α}
{v : β k}, a ∈ t.insert k v → cmp k a ≠ Ordering.eq → a ∈ t | true |
MvPowerSeries.rescaleMonoidHom._proof_1 | Mathlib.RingTheory.MvPowerSeries.Substitution | ∀ {σ : Type u_1} {R : Type u_2} [inst : CommSemiring R] (a b : σ → R),
MvPowerSeries.rescale (a * b) = MvPowerSeries.rescale a * MvPowerSeries.rescale b | false |
_private.Init.Data.Int.Linear.0.Int.Linear.poly_eq_zero_eq_false | Init.Data.Int.Linear | ∀ (ctx : Int.Linear.Context) {p : Int.Linear.Poly} {k : ℤ},
Int.Linear.Poly.divCoeffs k p = true →
k > 0 → Int.Linear.cmod p.getConst k < 0 → (Int.Linear.Poly.denote ctx p = 0) = False | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.