name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M |
|---|---|---|
instDecidableEqProd._proof_2 | Init.Core | ∀ {α : Type u_2} {β : Type u_1} (a : α) (b : β) (a' : α) (b' : β), ¬b = b' → (a, b) = (a', b') → False |
Std.ExtDTreeMap.maxKeyD_insertIfNew | Std.Data.ExtDTreeMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t : Std.ExtDTreeMap α β cmp} [inst : Std.TransCmp cmp] {k : α}
{v : β k} {fallback : α},
(t.insertIfNew k v).maxKeyD fallback = t.maxKey?.elim k fun k' => if cmp k' k = Ordering.lt then k else k' |
NormedAddGroupHom.Equalizer.lift.congr_simp | Mathlib.Analysis.Normed.Group.Hom | ∀ {V : Type u_1} {W : Type u_2} {V₁ : Type u_3} [inst : SeminormedAddCommGroup V] [inst_1 : SeminormedAddCommGroup W]
[inst_2 : SeminormedAddCommGroup V₁] {f g : NormedAddGroupHom V W} (φ φ_1 : NormedAddGroupHom V₁ V) (e_φ : φ = φ_1)
(h : f.comp φ = g.comp φ), NormedAddGroupHom.Equalizer.lift φ h = NormedAddGroupHom.Equalizer.lift φ_1 ⋯ |
_private.Mathlib.RingTheory.IntegralClosure.Algebra.Ideal.0.Polynomial.exists_monic_aeval_eq_zero_forall_mem_of_mem_map._proof_1_2 | Mathlib.RingTheory.IntegralClosure.Algebra.Ideal | ∀ {R : Type u_1} [inst : CommRing R] (p : Polynomial R), ∀ i < p.natDegree, ¬p.natDegree - i = 0 |
Lean.Meta.Grind.AttrKind.cases.sizeOf_spec | Lean.Meta.Tactic.Grind.Attr | ∀ (eager : Bool), sizeOf (Lean.Meta.Grind.AttrKind.cases eager) = 1 + sizeOf eager |
Convex.uniformContinuous_gauge | Mathlib.Analysis.Convex.Gauge | ∀ {E : Type u_2} [inst : SeminormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] {s : Set E},
Convex ℝ s → s ∈ nhds 0 → UniformContinuous (gauge s) |
DFinsupp.subset_support_tsub | Mathlib.Data.DFinsupp.Order | ∀ {ι : Type u_1} {α : ι → Type u_2} [inst : (i : ι) → AddCommMonoid (α i)] [inst_1 : (i : ι) → PartialOrder (α i)]
[inst_2 : ∀ (i : ι), CanonicallyOrderedAdd (α i)] [inst_3 : (i : ι) → Sub (α i)]
[inst_4 : ∀ (i : ι), OrderedSub (α i)] {f g : Π₀ (i : ι), α i} [inst_5 : DecidableEq ι]
[inst_6 : (i : ι) → (x : α i) → Decidable (x ≠ 0)], f.support \ g.support ⊆ (f - g).support |
IsLocallyConstant.iff_is_const | Mathlib.Topology.LocallyConstant.Basic | ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] [PreconnectedSpace X] {f : X → Y},
IsLocallyConstant f ↔ ∀ (x y : X), f x = f y |
_private.Mathlib.Data.List.Basic.0.List.foldr_ext._simp_1_4 | Mathlib.Data.List.Basic | ∀ {α : Sort u_1} {p : α → Prop} {a' : α}, (∀ (a : α), a = a' → p a) = p a' |
Lean.Lsp.FileChangeType.ctorIdx | Lean.Data.Lsp.Workspace | Lean.Lsp.FileChangeType → ℕ |
Std.Sat.AIG.Decl.rec | Std.Sat.AIG.Basic | {α : Type} →
{motive : Std.Sat.AIG.Decl α → Sort u} →
motive Std.Sat.AIG.Decl.false →
((idx : α) → motive (Std.Sat.AIG.Decl.atom idx)) →
((l r : Std.Sat.AIG.Fanin) → motive (Std.Sat.AIG.Decl.gate l r)) → (t : Std.Sat.AIG.Decl α) → motive t |
_private.Lean.Server.Completion.CompletionInfoSelection.0.Lean.Server.Completion.findCompletionInfosAt.containsHoverPos | Lean.Server.Completion.CompletionInfoSelection | String.Pos.Raw → Lean.Elab.CompletionInfo → Bool |
SeparationQuotient.instNormedAlgebra._proof_2 | Mathlib.Analysis.Normed.Module.Basic | ∀ (𝕜 : Type u_1) {E : Type u_2} [inst : NormedField 𝕜] [inst_1 : SeminormedRing E] [inst_2 : NormedAlgebra 𝕜 E],
ContinuousConstSMul 𝕜 E |
Equiv.funSplitAt_apply | Mathlib.Logic.Equiv.Prod | ∀ {α : Type u_9} [inst : DecidableEq α] (i : α) (β : Type u_10) (f : (j : α) → (fun a => β) j),
(Equiv.funSplitAt i β) f = (f i, fun j => f ↑j) |
HurwitzZeta.completedHurwitzZetaEven_zero | Mathlib.NumberTheory.LSeries.RiemannZeta | ∀ (s : ℂ), HurwitzZeta.completedHurwitzZetaEven 0 s = completedRiemannZeta s |
Submodule.localized'_inf | Mathlib.Algebra.Module.LocalizedModule.Submodule | ∀ {R : Type u_1} (S : Type u_2) {M : Type u_3} {N : Type u_4} [inst : CommSemiring R] [inst_1 : CommSemiring S]
[inst_2 : AddCommMonoid M] [inst_3 : AddCommMonoid N] [inst_4 : Module R M] [inst_5 : Module R N]
[inst_6 : Algebra R S] [inst_7 : Module S N] [inst_8 : IsScalarTower R S N] (p : Submonoid R)
[inst_9 : IsLocalization p S] (f : M →ₗ[R] N) [inst_10 : IsLocalizedModule p f] (M' M'' : Submodule R M),
Submodule.localized' S p f (M' ⊓ M'') = Submodule.localized' S p f M' ⊓ Submodule.localized' S p f M'' |
Turing.PartrecToTM2.K'.elim_update_aux | Mathlib.Computability.TMToPartrec | ∀ {a b c d c' : List Turing.PartrecToTM2.Γ'},
Function.update (Turing.PartrecToTM2.K'.elim a b c d) Turing.PartrecToTM2.K'.aux c' =
Turing.PartrecToTM2.K'.elim a b c' d |
PolynormableSpace.withSeminorms | Mathlib.Analysis.LocallyConvex.WithSeminorms | ∀ (𝕜 : Type u_2) (E : Type u_6) [inst : NormedField 𝕜] [inst_1 : AddCommGroup E] [inst_2 : Module 𝕜 E]
[inst_3 : TopologicalSpace E] [PolynormableSpace 𝕜 E], WithSeminorms fun p => ↑p |
MeasureTheory.exp_llr | Mathlib.MeasureTheory.Measure.LogLikelihoodRatio | ∀ {α : Type u_1} {mα : MeasurableSpace α} (μ ν : MeasureTheory.Measure α) [MeasureTheory.SigmaFinite μ],
(fun x => Real.exp (MeasureTheory.llr μ ν x)) =ᵐ[ν] fun x => if μ.rnDeriv ν x = 0 then 1 else (μ.rnDeriv ν x).toReal |
Lean.Elab.Deriving.mkInhabitedInstanceHandler | Lean.Elab.Deriving.Inhabited | Array Lean.Name → Lean.Elab.Command.CommandElabM Bool |
ProbabilityTheory.mgf_sum_of_identDistrib₀ | Mathlib.Probability.Moments.Basic | ∀ {Ω : Type u_1} {ι : Type u_2} {m : MeasurableSpace Ω} {μ : MeasureTheory.Measure Ω} {X : ι → Ω → ℝ} {s : Finset ι}
{j : ι},
(∀ (i : ι), AEMeasurable (X i) μ) →
ProbabilityTheory.iIndepFun X μ →
(∀ i ∈ s, ∀ j ∈ s, ProbabilityTheory.IdentDistrib (X i) (X j) μ μ) →
j ∈ s → ∀ (t : ℝ), ProbabilityTheory.mgf (∑ i ∈ s, X i) μ t = ProbabilityTheory.mgf (X j) μ t ^ s.card |
Finset.singleton_subset_coe._simp_1 | Mathlib.Data.Finset.Insert | ∀ {α : Type u_1} {s : Finset α} {a : α}, ({a} ⊆ ↑s) = ({a} ⊆ s) |
Lean.Meta.Match.Overlaps.mk.sizeOf_spec | Lean.Meta.Match.MatcherInfo | ∀ (map : Std.HashMap ℕ (Std.TreeSet ℕ compare)), sizeOf { map := map } = 1 + sizeOf map |
CategoryTheory.Limits.BinaryBicone.inlCokernelCofork_π | Mathlib.CategoryTheory.Limits.Shapes.BinaryBiproducts | ∀ {C : Type uC} [inst : CategoryTheory.Category.{uC', uC} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{X Y : C} (c : CategoryTheory.Limits.BinaryBicone X Y), CategoryTheory.Limits.Cofork.π c.inlCokernelCofork = c.snd |
CategoryTheory.Presheaf.IsSheaf.amalgamate_map_assoc | Mathlib.CategoryTheory.Sites.Sheaf | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {J : CategoryTheory.GrothendieckTopology C} {A : Type u₂}
[inst_1 : CategoryTheory.Category.{v₂, u₂} A] {E : A} {X : C} {P : CategoryTheory.Functor Cᵒᵖ A}
(hP : CategoryTheory.Presheaf.IsSheaf J P) (S : J.Cover X) (x : (I : S.Arrow) → E ⟶ P.obj (Opposite.op I.Y))
(hx :
∀ ⦃I₁ I₂ : S.Arrow⦄ (r : I₁.Relation I₂),
CategoryTheory.CategoryStruct.comp (x I₁) (P.map r.g₁.op) =
CategoryTheory.CategoryStruct.comp (x I₂) (P.map r.g₂.op))
(I : S.Arrow) {Z : A} (h : P.obj (Opposite.op I.Y) ⟶ Z),
CategoryTheory.CategoryStruct.comp (hP.amalgamate S x hx) (CategoryTheory.CategoryStruct.comp (P.map I.f.op) h) =
CategoryTheory.CategoryStruct.comp (x I) h |
_private.Init.Data.Range.Polymorphic.UInt.0.UInt64.instLawfulUpwardEnumerableLE._simp_1 | Init.Data.Range.Polymorphic.UInt | ∀ {x y : BitVec 64},
Std.PRange.UpwardEnumerable.LE { toBitVec := x } { toBitVec := y } = Std.PRange.UpwardEnumerable.LE x y |
Aesop.BuilderName.forward | Aesop.Rule.Name | Aesop.BuilderName |
Lean.Parser.Term.doContinue | Lean.Parser.Do | Lean.Parser.Parser |
_private.Lean.Elab.Term.TermElabM.0.Lean.Elab.Term.useImplicitLambda | Lean.Elab.Term.TermElabM | Lean.Syntax → Option Lean.Expr → Lean.Elab.TermElabM Lean.Elab.Term.UseImplicitLambdaResult |
CategoryTheory.Monad.ForgetCreatesColimits.coconePoint._proof_1 | Mathlib.CategoryTheory.Monad.Limits | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {T : CategoryTheory.Monad C} {J : Type u_4}
[inst_1 : CategoryTheory.Category.{u_3, u_4} J] {D : CategoryTheory.Functor J T.Algebra}
(c : CategoryTheory.Limits.Cocone (D.comp T.forget)) (t : CategoryTheory.Limits.IsColimit c)
[inst_2 : CategoryTheory.Limits.PreservesColimit (D.comp T.forget) T.toFunctor],
CategoryTheory.CategoryStruct.comp (T.η.app c.pt) (CategoryTheory.Monad.ForgetCreatesColimits.lambda c t) =
CategoryTheory.CategoryStruct.id c.pt |
_private.Mathlib.Algebra.Group.Subsemigroup.Membership.0.AddSubsemigroup.mem_biSup_of_directedOn.match_1_1 | Mathlib.Algebra.Group.Subsemigroup.Membership | ∀ {M : Type u_2} [inst : Add M] {ι : Type u_1} {p : ι → Prop} {K : ι → AddSubsemigroup M} {x : M}
(motive : (∃ i, p i ∧ x ∈ K i) → Prop) (x_1 : ∃ i, p i ∧ x ∈ K i),
(∀ (i : ι) (hi' : p i) (hi : x ∈ K i), motive ⋯) → motive x_1 |
Lean.Meta.CaseValuesSubgoal.noConfusion | Lean.Meta.Match.CaseValues | {P : Sort u} → {t t' : Lean.Meta.CaseValuesSubgoal} → t = t' → Lean.Meta.CaseValuesSubgoal.noConfusionType P t t' |
TensorPower.gmonoid._proof_1 | Mathlib.LinearAlgebra.TensorPower.Basic | ∀ {R : Type u_1} {M : Type u_2} [inst : CommSemiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
(a : GradedMonoid fun i => TensorPower R i M), GradedMonoid.mk (0 • a.fst) (GradedMonoid.GMonoid.gnpowRec 0 a.snd) = 1 |
AlgebraicGeometry.ProjIsoSpecTopComponent.ToSpec.carrier._proof_2 | Mathlib.AlgebraicGeometry.ProjectiveSpectrum.Scheme | ∀ {A : Type u_1} {σ : Type u_2} [inst : CommRing A] [inst_1 : SetLike σ A] [inst_2 : AddSubgroupClass σ A] {𝒜 : ℕ → σ}
[inst_3 : GradedRing 𝒜] {f : A},
Topology.IsOpenEmbedding ⇑(CategoryTheory.ConcreteCategory.hom (ProjectiveSpectrum.basicOpen 𝒜 f).inclusion') |
Ordinal.ToType.mk._proof_3 | Mathlib.SetTheory.Ordinal.Basic | ∀ {o : Ordinal.{u_1}} (x : ↑(Set.Iio o)), ↑x ∈ Set.Iio (Ordinal.type fun x1 x2 => x1 < x2) |
List.hasDecEq.match_1 | Init.Prelude | {α : Type u_1} →
(as bs : List α) →
(motive : Decidable (as = bs) → Sort u_2) →
(x : Decidable (as = bs)) →
((habs : as = bs) → motive (isTrue habs)) → ((nabs : ¬as = bs) → motive (isFalse nabs)) → motive x |
Mathlib.Linter.DupNamespaceLinter.initFn._@.Mathlib.Tactic.Linter.Lint.3996576634._hygCtx._hyg.2 | Mathlib.Tactic.Linter.Lint | IO Unit |
Finset.fold_const | Mathlib.Data.Finset.Fold | ∀ {α : Type u_1} {β : Type u_2} {op : β → β → β} [hc : Std.Commutative op] [ha : Std.Associative op] {b : β}
{s : Finset α} [hd : Decidable (s = ∅)] (c : β),
op c (op b c) = op b c → Finset.fold op b (fun x => c) s = if s = ∅ then b else op b c |
MonadStateOf.casesOn | Init.Prelude | {σ : Type u} →
{m : Type u → Type v} →
{motive : MonadStateOf σ m → Sort u_1} →
(t : MonadStateOf σ m) →
((get : m σ) →
(set : σ → m PUnit.{u + 1}) →
(modifyGet : {α : Type u} → (σ → α × σ) → m α) →
motive { get := get, set := set, modifyGet := modifyGet }) →
motive t |
SemimoduleCat.hom_ext_iff | Mathlib.Algebra.Category.ModuleCat.Semi | ∀ {R : Type u} [inst : Semiring R] {M N : SemimoduleCat R} {f g : M ⟶ N},
f = g ↔ SemimoduleCat.Hom.hom f = SemimoduleCat.Hom.hom g |
Real.pow_mul_norm_iteratedFDeriv_fourier_le | Mathlib.Analysis.Fourier.FourierTransformDeriv | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℂ E] {V : Type u_2} [inst_2 : NormedAddCommGroup V]
[inst_3 : InnerProductSpace ℝ V] [inst_4 : FiniteDimensional ℝ V] [inst_5 : MeasurableSpace V] [inst_6 : BorelSpace V]
{f : V → E} {K N : ℕ∞},
ContDiff ℝ (↑N) f →
(∀ (k n : ℕ),
↑k ≤ K → ↑n ≤ N → MeasureTheory.Integrable (fun v => ‖v‖ ^ k * ‖iteratedFDeriv ℝ n f v‖) MeasureTheory.volume) →
∀ {k n : ℕ},
↑k ≤ K →
↑n ≤ N →
∀ (w : V),
‖w‖ ^ n * ‖iteratedFDeriv ℝ k (FourierTransform.fourier f) w‖ ≤
(2 * Real.pi) ^ k * (2 * ↑k + 2) ^ n *
∑ p ∈ Finset.range (k + 1) ×ˢ Finset.range (n + 1), ∫ (v : V), ‖v‖ ^ p.1 * ‖iteratedFDeriv ℝ p.2 f v‖ |
ContinuousMap.toAEEqFunAddHom._proof_1 | Mathlib.MeasureTheory.Function.AEEqFun | ∀ {α : Type u_1} {β : Type u_2} [inst : MeasurableSpace α] (μ : MeasureTheory.Measure α) [inst_1 : TopologicalSpace α]
[inst_2 : BorelSpace α] [inst_3 : TopologicalSpace β] [inst_4 : SecondCountableTopologyEither α β]
[inst_5 : TopologicalSpace.PseudoMetrizableSpace β] [inst_6 : AddGroup β] [inst_7 : IsTopologicalAddGroup β],
ContinuousMap.toAEEqFun μ 0 = ContinuousMap.toAEEqFun μ 0 |
_private.Std.Data.Iterators.Lemmas.Consumers.Monadic.Collect.0.Std.IterM.Equiv.toList_eq._simp_1_1 | Std.Data.Iterators.Lemmas.Consumers.Monadic.Collect | ∀ {α β : Type w} {m : Type w → Type w'} [inst : Monad m] [LawfulMonad m] [inst_2 : Std.Iterator α m β]
[Std.Iterators.Finite α m] {it : Std.IterM m β}, it.toList = List.reverse <$> it.toListRev |
SzemerediRegularity.increment.congr_simp | Mathlib.Combinatorics.SimpleGraph.Regularity.Increment | ∀ {α : Type u_1} [inst : Fintype α] [inst_1 : DecidableEq α] {P P_1 : Finpartition Finset.univ} (e_P : P = P_1)
(hP : P.IsEquipartition) (G G_1 : SimpleGraph α),
G = G_1 →
∀ {inst_2 : DecidableRel G.Adj} [inst_3 : DecidableRel G_1.Adj] (ε ε_1 : ℝ),
ε = ε_1 → SzemerediRegularity.increment hP G ε = SzemerediRegularity.increment ⋯ G_1 ε_1 |
SkewMonoidAlgebra.equivMapDomain._proof_1 | Mathlib.Algebra.SkewMonoidAlgebra.Lift | ∀ {k : Type u_3} {G : Type u_2} {H : Type u_1} [inst : AddCommMonoid k] (f : G ≃ H) (l : SkewMonoidAlgebra k G) (a : H),
a ∈ Finset.map f.toEmbedding l.support ↔ (fun a => l.coeff (f.symm a)) a ≠ 0 |
ArchimedeanClass.FiniteElement._proof_1 | Mathlib.Algebra.Order.Ring.StandardPart | ∀ (K : Type u_1) [inst : LinearOrder K] [inst_1 : Field K] [IsOrderedRing K], IsOrderedAddMonoid K |
Int.getElem?_toArray_roo_eq_none | Init.Data.Range.Polymorphic.IntLemmas | ∀ {m n : ℤ} {i : ℕ}, (n - (m + 1)).toNat ≤ i → (m<...n).toArray[i]? = none |
Lean.Widget.WidgetSource.mk.noConfusion | Lean.Widget.UserWidget | {P : Sort u} →
{sourcetext sourcetext' : String} →
{ sourcetext := sourcetext } = { sourcetext := sourcetext' } → (sourcetext = sourcetext' → P) → P |
Lean.Grind.IntModule.OfNatModule.mk_le_mk | Init.Grind.Module.Envelope | ∀ {α : Type u} [inst : Lean.Grind.NatModule α] [inst_1 : LE α] [inst_2 : Std.IsPreorder α]
[inst_3 : Lean.Grind.OrderedAdd α] {a₁ a₂ b₁ b₂ : α},
Lean.Grind.IntModule.OfNatModule.Q.mk (a₁, a₂) ≤ Lean.Grind.IntModule.OfNatModule.Q.mk (b₁, b₂) ↔ a₁ + b₂ ≤ a₂ + b₁ |
StructureGroupoid.id_mem_maximalAtlas | Mathlib.Geometry.Manifold.HasGroupoid | ∀ {H : Type u} [inst : TopologicalSpace H] (G : StructureGroupoid H),
OpenPartialHomeomorph.refl H ∈ StructureGroupoid.maximalAtlas H G |
Array.mapIdx_mapIdx | Init.Data.Array.MapIdx | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} {xs : Array α} {f : ℕ → α → β} {g : ℕ → β → γ},
Array.mapIdx g (Array.mapIdx f xs) = Array.mapIdx (fun i => g i ∘ f i) xs |
_private.Mathlib.Algebra.Star.Module.0.selfAdjointPart_comp_subtype_skewAdjoint.match_1_1 | Mathlib.Algebra.Star.Module | ∀ (R : Type u_2) {A : Type u_1} [inst : Semiring R] [inst_1 : StarMul R] [inst_2 : TrivialStar R]
[inst_3 : AddCommGroup A] [inst_4 : Module R A] [inst_5 : StarAddMonoid A] [inst_6 : StarModule R A]
(motive : ↥(skewAdjoint.submodule R A) → Prop) (x : ↥(skewAdjoint.submodule R A)),
(∀ (x : A) (hx : star x = -x), motive ⟨x, hx⟩) → motive x |
CategoryTheory.Sheaf.instPreservesFiniteLimitsFunctorOppositeSheafToPresheafOfHasFiniteLimits | Mathlib.CategoryTheory.Sites.Limits | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {J : CategoryTheory.GrothendieckTopology C} {D : Type w}
[inst_1 : CategoryTheory.Category.{w', w} D] [CategoryTheory.Limits.HasFiniteLimits D],
CategoryTheory.Limits.PreservesFiniteLimits (CategoryTheory.sheafToPresheaf J D) |
AddCon.addSubgroup_quotientAddGroupCon | Mathlib.GroupTheory.QuotientGroup.Defs | ∀ {G : Type u_1} [inst : AddGroup G] (H : AddSubgroup G) [inst_1 : H.Normal], (QuotientAddGroup.con H).addSubgroup = H |
ContinuousMultilinearMap.uniformContinuous_restrictScalars | Mathlib.Topology.Algebra.Module.Multilinear.Topology | ∀ {𝕜 : Type u_1} {ι : Type u_2} {E : ι → Type u_3} {F : Type u_4} [inst : NormedField 𝕜]
[inst_1 : (i : ι) → TopologicalSpace (E i)] [inst_2 : (i : ι) → AddCommGroup (E i)]
[inst_3 : (i : ι) → Module 𝕜 (E i)] [inst_4 : AddCommGroup F] [inst_5 : Module 𝕜 F] [inst_6 : UniformSpace F]
[inst_7 : IsUniformAddGroup F] (𝕜' : Type u_5) [inst_8 : NontriviallyNormedField 𝕜'] [inst_9 : NormedAlgebra 𝕜' 𝕜]
[inst_10 : (i : ι) → Module 𝕜' (E i)] [inst_11 : ∀ (i : ι), IsScalarTower 𝕜' 𝕜 (E i)] [inst_12 : Module 𝕜' F]
[inst_13 : IsScalarTower 𝕜' 𝕜 F] [∀ (i : ι), ContinuousSMul 𝕜 (E i)],
UniformContinuous (ContinuousMultilinearMap.restrictScalars 𝕜') |
BoxIntegral.unitPartition.prepartition_isHenstock | Mathlib.Analysis.BoxIntegral.UnitPartition | ∀ {ι : Type u_1} (n : ℕ) [inst : NeZero n] [inst_1 : Fintype ι] (B : BoxIntegral.Box ι),
(BoxIntegral.unitPartition.prepartition n B).IsHenstock |
LowerSet.notMem_bot._simp_1 | Mathlib.Order.UpperLower.CompleteLattice | ∀ {α : Type u_1} [inst : LE α] {a : α}, (a ∈ ⊥) = False |
Std.DHashMap.Equiv.constGet_eq | Std.Data.DHashMap.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {β : Type v} {m₁ m₂ : Std.DHashMap α fun x => β} [inst : EquivBEq α]
[inst_1 : LawfulHashable α] {k : α} (hk : k ∈ m₁) (h : m₁.Equiv m₂),
Std.DHashMap.Const.get m₁ k hk = Std.DHashMap.Const.get m₂ k ⋯ |
CategoryTheory.NatTrans.removeOp._proof_2 | Mathlib.CategoryTheory.Opposites | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {D : Type u_4}
[inst_1 : CategoryTheory.Category.{u_3, u_4} D] {F G : CategoryTheory.Functor C D} (α : F.op ⟶ G.op) (X Y : C)
(f : X ⟶ Y),
CategoryTheory.CategoryStruct.comp (G.map f) (α.app (Opposite.op Y)).unop =
CategoryTheory.CategoryStruct.comp (α.app (Opposite.op X)).unop (F.map f) |
Lean.Widget.RpcEncodablePacket.msg._@.Lean.Server.FileWorker.WidgetRequests.1923616455._hygCtx._hyg.1 | Lean.Server.FileWorker.WidgetRequests | Lean.Widget.RpcEncodablePacket✝ → Lean.Json |
_private.Init.Data.String.Basic.0.String.Slice.utf8ByteSize_slice._proof_1_2 | Init.Data.String.Basic | ∀ {s : String.Slice} {newStart newEnd : s.Pos},
¬s.startInclusive.offset.byteIdx + newEnd.offset.byteIdx -
(s.startInclusive.offset.byteIdx + newStart.offset.byteIdx) =
newEnd.offset.byteIdx - newStart.offset.byteIdx →
False |
_private.Lean.Elab.DeclNameGen.0.Lean.Elab.Command.NameGen.mkBaseNameCore.visit'.eq_def | Lean.Elab.DeclNameGen | ∀ (e : Lean.Expr) (omitTopForall : Bool),
Lean.Elab.Command.NameGen.mkBaseNameCore.visit'✝ e omitTopForall =
match e with
| Lean.Expr.const name us => do
modify fun st =>
{ seen := Lean.Elab.Command.NameGen.MkNameState.seen✝ st,
consts := (Lean.Elab.Command.NameGen.MkNameState.consts✝ st).insert name }
pure
(match name.eraseMacroScopes with
| pre.str str => str.capitalize
| x => "")
| f.app x =>
(fun x1 x2 => x1 ++ x2) <$> Lean.Elab.Command.NameGen.mkBaseNameCore.visit✝ f <*>
Lean.Elab.Command.NameGen.mkBaseNameCore.visit✝¹ x
| Lean.Expr.forallE binderName ty body binderInfo => do
let sty ← Lean.Elab.Command.NameGen.mkBaseNameCore.visit✝² ty
if (omitTopForall && sty == "") = true then Lean.Elab.Command.NameGen.mkBaseNameCore.visit✝³ body true
else (fun x => "Forall" ++ sty ++ x) <$> Lean.Elab.Command.NameGen.mkBaseNameCore.visit✝⁴ body
| Lean.Expr.sort Lean.Level.zero => pure "Prop"
| Lean.Expr.sort a.succ => pure "Type"
| Lean.Expr.sort u => pure "Sort"
| x => pure "" |
CategoryTheory.rightExactFunctor | Mathlib.CategoryTheory.Limits.ExactFunctor | (C : Type u₁) →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
(D : Type u₂) →
[inst_1 : CategoryTheory.Category.{v₂, u₂} D] → CategoryTheory.ObjectProperty (CategoryTheory.Functor C D) |
DilationEquiv.coe_one | Mathlib.Topology.MetricSpace.DilationEquiv | ∀ {X : Type u_1} [inst : PseudoEMetricSpace X], ⇑1 = id |
OrderType.instOfNat | Mathlib.Order.Types.Arithmetic | (n : ℕ) → OfNat OrderType.{0} n |
CategoryTheory.Subfunctor.Subpresheaf.range_id | Mathlib.CategoryTheory.Subfunctor.Image | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (F : CategoryTheory.Functor C (Type w)),
CategoryTheory.Subfunctor.range (CategoryTheory.CategoryStruct.id F) = ⊤ |
Std.TreeSet.getD_diff_of_mem_right | Std.Data.TreeSet.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t₁ t₂ : Std.TreeSet α cmp} [Std.TransCmp cmp] {k fallback : α},
k ∈ t₂ → (t₁ \ t₂).getD k fallback = fallback |
IsCyclotomicExtension.adjoin_roots_cyclotomic_eq_adjoin_nth_roots | Mathlib.NumberTheory.Cyclotomic.Basic | ∀ {A : Type u} {B : Type v} [inst : CommRing A] [inst_1 : CommRing B] [inst_2 : Algebra A B] [inst_3 : IsDomain B]
{ζ : B} {n : ℕ} [NeZero n],
IsPrimitiveRoot ζ n →
Algebra.adjoin A ((Polynomial.cyclotomic n A).rootSet B) = Algebra.adjoin A {b | ∃ a ∈ {n}, a ≠ 0 ∧ b ^ a = 1} |
NumberField.IsCMField.complexConj_eq_self_iff | Mathlib.NumberTheory.NumberField.CMField | ∀ (K : Type u_1) [inst : Field K] [inst_1 : CharZero K] [inst_2 : NumberField.IsCMField K]
[inst_3 : Algebra.IsIntegral ℚ K] (x : K),
(NumberField.IsCMField.complexConj K) x = x ↔ x ∈ NumberField.maximalRealSubfield K |
LieAlgebra.IsKilling.disjoint_ker_weight_corootSpace | Mathlib.Algebra.Lie.Weights.Killing | ∀ {K : Type u_2} {L : Type u_3} [inst : LieRing L] [inst_1 : Field K] [inst_2 : LieAlgebra K L]
[inst_3 : FiniteDimensional K L] {H : LieSubalgebra K L} [inst_4 : H.IsCartanSubalgebra] [LieAlgebra.IsKilling K L]
[LieModule.IsTriangularizable K (↥H) L] [inst_7 : CharZero K] (α : LieModule.Weight K (↥H) L),
Disjoint LieModule.Weight.ker (LieIdeal.toLieSubalgebra K (↥H) (LieAlgebra.corootSpace ⇑α)).toSubmodule |
List.forM_nil | Init.Data.List.Control | ∀ {m : Type u_1 → Type u_2} {α : Type u_3} [inst : Monad m] {f : α → m PUnit.{u_1 + 1}}, forM [] f = pure PUnit.unit |
CategoryTheory.CostructuredArrow.ofCostructuredArrowProjEquivalence.inverse._proof_2 | Mathlib.CategoryTheory.Comma.Over.Basic | ∀ {T : Type u_4} [inst : CategoryTheory.Category.{u_3, u_4} T] {D : Type u_2}
[inst_1 : CategoryTheory.Category.{u_1, u_2} D] (F : CategoryTheory.Functor T D) (Y : D) (X : T)
{Y_1 Z : CategoryTheory.CostructuredArrow ((CategoryTheory.Over.forget X).comp F) Y} (m : Y_1 ⟶ Z),
CategoryTheory.CategoryStruct.comp
(F.map
(((CategoryTheory.CostructuredArrow.proj ((CategoryTheory.Over.forget X).comp F) Y).comp
(CategoryTheory.Over.forget X)).map
m))
((fun g => g.hom) Z) =
(fun g => g.hom) Y_1 |
Representation.invariants.eq_1 | Mathlib.RepresentationTheory.Invariants | ∀ {k : Type u_1} {G : Type u_2} {V : Type u_3} [inst : CommSemiring k] [inst_1 : Group G] [inst_2 : AddCommMonoid V]
[inst_3 : Module k V] (ρ : Representation k G V),
ρ.invariants = { carrier := {v | ∀ (g : G), (ρ g) v = v}, add_mem' := ⋯, zero_mem' := ⋯, smul_mem' := ⋯ } |
PNat.XgcdType.mk.sizeOf_spec | Mathlib.Data.PNat.Xgcd | ∀ (wp x y zp ap bp : ℕ),
sizeOf { wp := wp, x := x, y := y, zp := zp, ap := ap, bp := bp } =
1 + sizeOf wp + sizeOf x + sizeOf y + sizeOf zp + sizeOf ap + sizeOf bp |
CategoryTheory.ProjectiveResolution.quasiIso._autoParam | Mathlib.CategoryTheory.Preadditive.Projective.Resolution | Lean.Syntax |
bihimp_comm | Mathlib.Order.SymmDiff | ∀ {α : Type u_2} [inst : GeneralizedHeytingAlgebra α] (a b : α), bihimp a b = bihimp b a |
mul_le_mul_of_nonpos_of_nonneg' | Mathlib.Algebra.Order.Ring.Unbundled.Basic | ∀ {R : Type u} [inst : Semiring R] [inst_1 : Preorder R] {a b c d : R} [ExistsAddOfLE R] [PosMulMono R] [MulPosMono R]
[AddRightMono R] [AddRightReflectLE R], c ≤ a → b ≤ d → 0 ≤ a → d ≤ 0 → a * b ≤ c * d |
CategoryTheory.ShortComplex.Exact.isIso_imageToKernel | Mathlib.CategoryTheory.Abelian.Exact | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.Abelian C]
(S : CategoryTheory.ShortComplex C), S.Exact → CategoryTheory.IsIso (imageToKernel S.f S.g ⋯) |
Lean.KeyedDeclsAttribute.ExtensionState.declNames | Lean.KeyedDeclsAttribute | {γ : Type} → Lean.KeyedDeclsAttribute.ExtensionState γ → Lean.PHashSet Lean.Name |
LinearMap.mem_submoduleImage._simp_1 | Mathlib.Algebra.Module.Submodule.Range | ∀ {R : Type u_1} {M : Type u_5} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] {M' : Type u_10}
[inst_3 : AddCommMonoid M'] [inst_4 : Module R M'] {O : Submodule R M} {ϕ : ↥O →ₗ[R] M'} {N : Submodule R M} {x : M'},
(x ∈ ϕ.submoduleImage N) = ∃ y, ∃ (yO : y ∈ O), y ∈ N ∧ ϕ ⟨y, yO⟩ = x |
Lean.Meta.Grind.Arith.Cutsat.SymbolicIntInterval.isFinite | Lean.Meta.Tactic.Grind.Arith.Cutsat.ToIntInfo | Lean.Meta.Grind.Arith.Cutsat.SymbolicIntInterval → Bool |
Lean.Server.Test.Runner.Client.InteractiveGoals.mk | Lean.Server.Test.Runner | Array Lean.Server.Test.Runner.Client.InteractiveGoal → Lean.Server.Test.Runner.Client.InteractiveGoals |
SimpleGraph.Walk.support_toPath_subset | Mathlib.Combinatorics.SimpleGraph.Paths | ∀ {V : Type u} {G : SimpleGraph V} [inst : DecidableEq V] {u v : V} (p : G.Walk u v), (↑p.toPath).support ⊆ p.support |
_private.Mathlib.LinearAlgebra.Pi.0.LinearMap.pi_eq_zero._simp_1_2 | Mathlib.LinearAlgebra.Pi | ∀ {α : Sort u} {β : α → Sort v} {f g : (x : α) → β x}, (f = g) = ∀ (x : α), f x = g x |
IdealFilter.isTorsion_def | Mathlib.RingTheory.IdealFilter.Basic | ∀ {A : Type u_1} [inst : Ring A] (F : IdealFilter A) (M : Type u_2) [inst_1 : AddCommMonoid M] [inst_2 : Module A M],
F.IsTorsion M ↔ ∀ (m : M), F.IsTorsionElem m |
_private.Mathlib.Algebra.Homology.HomotopyCategory.HomComplex.0.CochainComplex.HomComplex.Cocycle.homOf._simp_1 | Mathlib.Algebra.Homology.HomotopyCategory.HomComplex | ∀ {G : Type u_3} [inst : AddGroup G] {a b : G}, (a - b = 0) = (a = b) |
_private.Init.Data.String.Decode.0.ByteArray.utf8DecodeChar?.val_assemble₁_le._proof_1_1 | Init.Data.String.Decode | ∀ {w : UInt8}, w.toNat < 128 → ¬w.toNat ≤ 127 → False |
Concept.instPartialOrder | Mathlib.Order.Concept | {α : Type u_2} → {β : Type u_3} → {r : α → β → Prop} → PartialOrder (Concept α β r) |
_private.Init.Data.List.Lemmas.0.List.length_pos_iff_exists_mem.match_1_1 | Init.Data.List.Lemmas | ∀ {α : Type u_1} {l : List α} (motive : (∃ a, a ∈ l) → Prop) (x : ∃ a, a ∈ l),
(∀ (w : α) (h : w ∈ l), motive ⋯) → motive x |
_private.Mathlib.GroupTheory.GroupAction.SubMulAction.OfFixingSubgroup.0.SubMulAction.fixingSubgroup_map_conj_eq._simp_1_2 | Mathlib.GroupTheory.GroupAction.SubMulAction.OfFixingSubgroup | ∀ {G : Type u_1} [inst : DivInvMonoid G] (x : G), x⁻¹ = x ^ (-1) |
Fin.dfoldrM.loop._unsafe_rec | Batteries.Data.Fin.Basic | {m : Type u_1 → Type u_2} →
[Monad m] →
(n : ℕ) →
(α : Fin (n + 1) → Type u_1) →
((i : Fin n) → α i.succ → m (α i.castSucc)) → (i : ℕ) → (h : i < n + 1) → α ⟨i, h⟩ → m (α 0) |
MeasureTheory.aecover_closedBall | Mathlib.MeasureTheory.Integral.IntegralEqImproper | ∀ {α : Type u_1} {ι : Type u_2} [inst : MeasurableSpace α] {μ : MeasureTheory.Measure α} {l : Filter ι}
[inst_1 : PseudoMetricSpace α] [OpensMeasurableSpace α] {x : α} {r : ι → ℝ},
Filter.Tendsto r l Filter.atTop → MeasureTheory.AECover μ l fun i => Metric.closedBall x (r i) |
CartanMatrix.isSimplyLaced_D | Mathlib.Data.Matrix.Cartan | ∀ (n : ℕ), (CartanMatrix.D n).IsSimplyLaced |
BitVec.twoPow | Init.Data.BitVec.Basic | (w : ℕ) → ℕ → BitVec w |
_private.Init.Data.Array.Monadic.0.Array.foldlM_filterMap.match_1.eq_1 | Init.Data.Array.Monadic | ∀ {β : Type u_1} (motive : Option β → Sort u_2) (b : β) (h_1 : (b : β) → motive (some b)) (h_2 : Unit → motive none),
(match some b with
| some b => h_1 b
| none => h_2 ()) =
h_1 b |
LocalSubring.noConfusion | Mathlib.RingTheory.LocalRing.LocalSubring | {P : Sort u} →
{R : Type u_1} →
{inst : CommRing R} →
{t : LocalSubring R} →
{R' : Type u_1} →
{inst' : CommRing R'} →
{t' : LocalSubring R'} → R = R' → inst ≍ inst' → t ≍ t' → LocalSubring.noConfusionType P t t' |
_private.Batteries.Data.String.Legacy.0.String.Legacy.posOfAux._proof_1 | Batteries.Data.String.Legacy | ∀ (s : String) (stopPos pos : String.Pos.Raw),
pos < stopPos → stopPos.byteIdx - (String.Pos.Raw.next s pos).byteIdx < stopPos.byteIdx - pos.byteIdx |
_private.Mathlib.MeasureTheory.Function.SimpleFunc.0.MeasureTheory.SimpleFunc.support_eq._simp_1_1 | Mathlib.MeasureTheory.Function.SimpleFunc | ∀ {ι : Type u_1} {M : Type u_3} [inst : Zero M] {f : ι → M} {x : ι}, (x ∈ Function.support f) = (f x ≠ 0) |
List.pop_toArray | Init.Data.List.ToArray | ∀ {α : Type u_1} (l : List α), l.toArray.pop = l.dropLast.toArray |
_private.Lean.Util.Diff.0.Lean.Diff.diff.match_3 | Lean.Util.Diff | {α : Type} →
(motive : MProd ℕ (MProd ℕ (Array (Lean.Diff.Action × α))) → Sort u_1) →
(r : MProd ℕ (MProd ℕ (Array (Lean.Diff.Action × α)))) →
((i j : ℕ) → (out : Array (Lean.Diff.Action × α)) → motive ⟨i, j, out⟩) → motive r |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.