name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
Frame.copy._proof_1 | Mathlib.Order.Copy | ∀ {α : Type u_1} (c : Order.Frame α) (le : α → α → Prop) (eq_le : le = LE.le) (top : α) (eq_top : top = ⊤) (bot : α)
(eq_bot : bot = ⊥) (sup : α → α → α) (eq_sup : sup = max) (inf : α → α → α) (eq_inf : inf = min) (himp : α → α → α)
(eq_himp : himp = HImp.himp) (compl : α → α) (eq_compl : compl = Compl.compl) (a b ... | null | false |
Subsemiring.topologicalClosure._proof_2 | Mathlib.Topology.Algebra.Ring.Basic | ∀ {R : Type u_1} [inst : TopologicalSpace R] [inst_1 : Semiring R] [IsSemitopologicalSemiring R],
SeparatelyContinuousAdd R | null | false |
RingHom.isStandardSmoothOfRelativeDimension_stableUnderCompositionWithLocalizationAway | Mathlib.RingTheory.RingHom.StandardSmooth | ∀ (n : ℕ),
RingHom.StableUnderCompositionWithLocalizationAway fun {R S} [CommRing R] [CommRing S] =>
RingHom.IsStandardSmoothOfRelativeDimension n | null | true |
OpenPartialHomeomorph.map_extend_nhdsWithin | Mathlib.Geometry.Manifold.IsManifold.ExtChartAt | ∀ {𝕜 : Type u_1} {E : Type u_2} {M : Type u_3} {H : Type u_4} [inst : NontriviallyNormedField 𝕜]
[inst_1 : NormedAddCommGroup E] [inst_2 : NormedSpace 𝕜 E] [inst_3 : TopologicalSpace H] [inst_4 : TopologicalSpace M]
(f : OpenPartialHomeomorph M H) {I : ModelWithCorners 𝕜 E H} {s : Set M} {y : M},
y ∈ f.source... | null | true |
MeasurableSpace.separatesPoints_def | Mathlib.MeasureTheory.MeasurableSpace.CountablyGenerated | ∀ {α : Type u_1} [inst : MeasurableSpace α] [hs : MeasurableSpace.SeparatesPoints α] {x y : α},
(∀ (s : Set α), MeasurableSet s → x ∈ s → y ∈ s) → x = y | null | true |
iSup_or | Mathlib.Order.CompleteLattice.Basic | ∀ {α : Type u_1} [inst : CompleteLattice α] {p q : Prop} {s : p ∨ q → α},
⨆ (x : p ∨ q), s x = (⨆ (i : p), s ⋯) ⊔ ⨆ (j : q), s ⋯ | null | true |
Lean.Widget.instInhabitedEmbedFmt.default | Lean.Widget.InteractiveDiagnostic | Lean.Widget.EmbedFmt✝ | null | true |
LowerSet.Iic_ne_bot | Mathlib.Order.UpperLower.Principal | ∀ {α : Type u_1} [inst : Preorder α] {a : α}, LowerSet.Iic a ≠ ⊥ | null | true |
FormalMultilinearSeries.ofScalars_norm_eq_mul | Mathlib.Analysis.Analytic.OfScalars | ∀ {𝕜 : Type u_1} (E : Type u_2) [inst : NontriviallyNormedField 𝕜] [inst_1 : SeminormedRing E]
[inst_2 : NormedAlgebra 𝕜 E] (c : ℕ → 𝕜) (n : ℕ),
‖FormalMultilinearSeries.ofScalars E c n‖ = ‖c n‖ * ‖ContinuousMultilinearMap.mkPiAlgebraFin 𝕜 n E‖ | null | true |
Rat.HeightOneSpectrum.adicCompletion.padicEquiv._proof_2 | Mathlib.NumberTheory.Padics.HeightOneSpectrum | ∀ {R : Type u_1} [inst : CommRing R] [inst_1 : Algebra R ℚ] [inst_2 : IsIntegralClosure R ℤ ℚ]
[inst_3 : IsDedekindDomain R] [inst_4 : IsFractionRing R ℚ] (v : IsDedekindDomain.HeightOneSpectrum R) (r : ℚ),
((IsDedekindDomain.HeightOneSpectrum.adicCompletion.equiv ℚ v).trans
((UniformSpace.Completion.mapR... | null | false |
ModelWithCorners.Boundaryless.recOn | Mathlib.Geometry.Manifold.IsManifold.Basic | {𝕜 : 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} →
{motive : I.Boundaryless → Sor... | null | false |
IndepMatroid._sizeOf_1 | Mathlib.Combinatorics.Matroid.IndepAxioms | {α : Type u_2} → [SizeOf α] → IndepMatroid α → ℕ | null | false |
Lean.mkErrorStringWithPos | Lean.Message | String →
Lean.Position →
String →
optParam (Option Lean.Position) none → optParam (Option String) none → optParam (Option Lean.Name) none → String | Creates a string describing an error message `msg` produced at `pos`, optionally ending at `endPos`,
in `fileName`.
Additional optional arguments can be used to prepend a label `kind` describing the severity of
the error (e.g., `"warning"` or `"error"`) and a bracketed `name` label displaying the name of the
error if ... | true |
AlgebraicGeometry.Scheme.instOverCoverOfIsIsoOfIsOver._aux_1 | Mathlib.AlgebraicGeometry.Cover.Over | {P : CategoryTheory.MorphismProperty AlgebraicGeometry.Scheme} →
(S : AlgebraicGeometry.Scheme) →
[inst : P.ContainsIdentities] →
[inst_1 : P.RespectsIso] →
{X Y : AlgebraicGeometry.Scheme} →
(f : X ⟶ Y) →
[X.Over S] →
[inst_3 : CategoryTheory.IsIso f] →
... | null | false |
instEuclideanDomainSubtypeMemSubalgebraAdjoinSingletonSetOfFactTranscendental | Mathlib.RingTheory.Adjoin.Polynomial.Transcendental | {S : Type u_2} →
[inst : Ring S] →
{s : S} →
{F : Type u_3} →
[inst_1 : Field F] → [inst_2 : Algebra F S] → [h : Fact (Transcendental F s)] → EuclideanDomain ↥F[s] | null | true |
CategoryTheory.Limits.biprod.braiding_map_braiding | Mathlib.CategoryTheory.Limits.Shapes.BinaryBiproducts | ∀ {C : Type uC} [inst : CategoryTheory.Category.{uC', uC} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
[inst_2 : CategoryTheory.Limits.HasBinaryBiproducts C] {W X Y Z : C} (f : W ⟶ Y) (g : X ⟶ Z),
CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.biprod.braiding X W).hom
(CategoryTheory.Cate... | null | true |
_private.Mathlib.Data.List.Interleave.0.List.interleaves_ofFn_odd._proof_1_9 | Mathlib.Data.List.Interleave | ∀ {n : ℕ} (i : ℕ) (hi : i + 1 < 2 * n + 1), (i + 1) % 2 = 0 → ↑⟨i + 1, hi⟩ / 2 < n + 1 | null | false |
CategoryTheory.ShortComplex.RightHomologyData.ofIsLimitKernelFork_p | Mathlib.Algebra.Homology.ShortComplex.RightHomology | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
(S : CategoryTheory.ShortComplex C) (hf : S.f = 0) (c : CategoryTheory.Limits.KernelFork S.g)
(hc : CategoryTheory.Limits.IsLimit c),
(CategoryTheory.ShortComplex.RightHomologyData.ofIsLimitKernelFor... | null | true |
SimpleGraph.Coloring.comap | Mathlib.Combinatorics.SimpleGraph.Coloring.Vertex | {V : Type u} →
{G : SimpleGraph V} →
{V' : Type u_4} → {G' : SimpleGraph V'} → {α : Type u_5} → G'.Coloring α → G →g G' → G.Coloring α | Coloring induced from a homomorphism to a colored graph. | true |
_private.Lean.Elab.MutualInductive.0.Lean.Elab.Command.computeFixedIndexBitMask.go._f | Lean.Elab.MutualInductive | ℕ →
Array Lean.Expr →
ℕ → IO.Ref (Array Bool) → (ctors : List Lean.Constructor) → List.below ctors → Lean.MetaM (Array Bool) | null | false |
Simps.ProjectionRule.casesOn | Mathlib.Tactic.Simps.Basic | {motive : Simps.ProjectionRule → Sort u} →
(t : Simps.ProjectionRule) →
((oldName : Lean.Name) →
(oldStx : Lean.Syntax) →
(newName : Lean.Name) →
(newStx : Lean.Syntax) → motive (Simps.ProjectionRule.rename oldName oldStx newName newStx)) →
((a : Lean.Name) → (a_1 : Lean.Syntax... | null | false |
CategoryTheory.Limits.IsLimit.liftConeMorphism_hom | Mathlib.CategoryTheory.Limits.IsLimit | ∀ {J : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} J] {C : Type u₃} [inst_1 : CategoryTheory.Category.{v₃, u₃} C]
{F : CategoryTheory.Functor J C} {t : CategoryTheory.Limits.Cone F} (h : CategoryTheory.Limits.IsLimit t)
(s : CategoryTheory.Limits.Cone F), (h.liftConeMorphism s).hom = h.lift s | null | true |
AlgebraicGeometry.morphismRestrict_id | Mathlib.AlgebraicGeometry.Restrict | ∀ {X : AlgebraicGeometry.Scheme} (U : X.Opens),
CategoryTheory.CategoryStruct.id X ∣_ U =
CategoryTheory.CategoryStruct.id ↑((TopologicalSpace.Opens.map (CategoryTheory.CategoryStruct.id X).base).obj U) | null | true |
_private.Mathlib.Analysis.Calculus.DerivativeTest.0.continuousOn_Iic | Mathlib.Analysis.Calculus.DerivativeTest | ∀ {f : ℝ → ℝ} {b : ℝ}, ContinuousAt f b → DifferentiableOn ℝ f (Set.Iio b) → ContinuousOn f (Set.Iic b) | If `f` is continuous at `b` and differentiable on `Iio b`, then `f` is continuous on
`Iic b`. | true |
CategoryTheory.PreGaloisCategory.evaluation_aut_bijective_of_isGalois | Mathlib.CategoryTheory.Galois.GaloisObjects | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{u₂, u₁} C] [inst_1 : CategoryTheory.GaloisCategory C]
(F : CategoryTheory.Functor C FintypeCat) [CategoryTheory.PreGaloisCategory.FiberFunctor F] (A : C)
[CategoryTheory.PreGaloisCategory.IsGalois A] (a : (F.obj A).obj),
Function.Bijective fun f => (CategoryTheory.... | null | true |
String.Slice.Pos.prev.congr_simp | Init.Data.String.Lemmas.FindPos | ∀ {s : String.Slice} (pos pos_1 : s.Pos) (e_pos : pos = pos_1) (h : pos ≠ s.startPos), pos.prev h = pos_1.prev ⋯ | null | true |
_private.Init.Data.String.Decode.0.ByteArray.utf8DecodeChar?.parseFirstByte_eq_done_iff | Init.Data.String.Decode | ∀ {b : UInt8}, ByteArray.utf8DecodeChar?.parseFirstByte b = ByteArray.utf8DecodeChar?.FirstByte.done ↔ b &&& 128 = 0 | null | true |
_private.Mathlib.Data.BitVec.0.BitVec.toFin_injective.match_1_1 | Mathlib.Data.BitVec | ∀ {n : ℕ} (motive : (x x_1 : BitVec n) → x.toFin = x_1.toFin → Prop) (x x_1 : BitVec n) (x_2 : x.toFin = x_1.toFin),
(∀ (val : ℕ) (isLt isLt_1 : val < 2 ^ n), motive { toFin := ⟨val, isLt⟩ } { toFin := ⟨val, isLt_1⟩ } ⋯) →
motive x x_1 x_2 | null | false |
DirectedOn.fst | Mathlib.Order.Directed | ∀ {α : Type u_1} {β : Type u_2} {r : α → α → Prop} {r₂ : β → β → Prop} {d : Set (α × β)},
DirectedOn (fun p q => r p.1 q.1 ∧ r₂ p.2 q.2) d → DirectedOn (fun x1 x2 => r x1 x2) (Prod.fst '' d) | null | true |
IsTopologicalAddGroup.toHSpace | Mathlib.Topology.Homotopy.HSpaces | (M : Type u) → [inst : AddZeroClass M] → [inst_1 : TopologicalSpace M] → [ContinuousAdd M] → HSpace M | The definition `toHSpace` is not an instance because it comes together with a
multiplicative version which would lead to a diamond since a topological field would inherit
two `HSpace` structures, one from the `MulOneClass` and one from the `AddZeroClass`.
In the case of an additive group, we make `IsTopologicalAddGroup... | true |
Set.Finite.iInf_biSup_of_antitone | Mathlib.Data.Set.Finite.Lattice | ∀ {ι : Type u_1} {ι' : Type u_2} {α : Type u_3} [inst : Preorder ι'] [Nonempty ι'] [IsDirectedOrder ι']
[inst_3 : Order.Coframe α] {s : Set ι},
s.Finite → ∀ {f : ι → ι' → α}, (∀ i ∈ s, Antitone (f i)) → ⨅ j, ⨆ i ∈ s, f i j = ⨆ i ∈ s, ⨅ j, f i j | null | true |
CategoryTheory.Limits.coneRightOpOfCoconeEquiv._proof_2 | Mathlib.CategoryTheory.Limits.Cones | ∀ {J : Type u_2} [inst : CategoryTheory.Category.{u_4, u_2} J] {C : Type u_1}
[inst_1 : CategoryTheory.Category.{u_3, u_1} C] {F : CategoryTheory.Functor Jᵒᵖ C}
{X Y Z : (CategoryTheory.Limits.Cocone F)ᵒᵖ} (f : Y ⟶ X) (g : Z ⟶ Y),
{ hom := (CategoryTheory.CategoryStruct.comp g f).unop.hom.op, w := ⋯ } =
Categ... | null | false |
_private.Lean.Meta.WrapInstance.0.Lean.Meta.wrapInstance.go._sparseCasesOn_10 | Lean.Meta.WrapInstance | {motive : Lean.ConstantInfo → Sort u} →
(t : Lean.ConstantInfo) →
((val : Lean.ConstructorVal) → motive (Lean.ConstantInfo.ctorInfo val)) →
(Nat.hasNotBit 64 t.ctorIdx → motive t) → motive t | null | false |
Lean.instBEqMessageSeverity | Lean.Message | BEq Lean.MessageSeverity | null | true |
CategoryTheory.ShortComplex.FunctorEquivalence.functor | Mathlib.Algebra.Homology.ShortComplex.FunctorEquivalence | (J : Type u_1) →
(C : Type u_2) →
[inst : CategoryTheory.Category.{v_1, u_1} J] →
[inst_1 : CategoryTheory.Category.{v_2, u_2} C] →
[inst_2 : CategoryTheory.Limits.HasZeroMorphisms C] →
CategoryTheory.Functor (CategoryTheory.ShortComplex (CategoryTheory.Functor J C))
(CategoryT... | The obvious functor `ShortComplex (J ⥤ C) ⥤ J ⥤ ShortComplex C`. | true |
ConcaveOn | Mathlib.Analysis.Convex.Function | (𝕜 : Type u_1) →
{E : Type u_2} →
{β : Type u_5} →
[Semiring 𝕜] →
[PartialOrder 𝕜] →
[AddCommMonoid E] → [AddCommMonoid β] → [PartialOrder β] → [SMul 𝕜 E] → [SMul 𝕜 β] → Set E → (E → β) → Prop | Concavity of functions | true |
ContMDiffCovariantDerivativeOn.affine_combination | Mathlib.Geometry.Manifold.VectorBundle.CovariantDerivative.Basic | ∀ {𝕜 : 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_5} [inst_6 : NormedAddCommG... | An affine combination of two `C^k` connections is a `C^k` connection. | true |
MvPolynomial.instAddCommGroupR._proof_23 | Mathlib.FieldTheory.Finite.Polynomial | ∀ (σ K : Type u_1) [inst : Fintype K] [inst_1 : CommRing K] (a b : MvPolynomial.R σ K), a + b = b + a | null | false |
PreLp.ring._proof_10 | Mathlib.Analysis.Normed.Lp.lpSpace | ∀ {I : Type u_1} {B : I → Type u_2} [inst : (i : I) → NormedRing (B i)],
autoParam (∀ (x : PreLp B), x ^ 0 = 1) Monoid.npow_zero._autoParam | null | false |
Ideal.depth_eq_of_iso | Mathlib.RingTheory.Depth.Basic | ∀ {R : Type u} [inst : CommRing R] [inst_1 : Small.{v, u} R] (I : Ideal R) {M M' : ModuleCat R} (e : M ≅ M'),
I.depth M = I.depth M' | null | true |
Lean.Meta.Grind.instNonemptyState | Lean.Meta.Tactic.Grind.Types | Nonempty Lean.Meta.Grind.State | null | true |
Std.DTreeMap.instSliceableRcoSlice._auto_1 | Std.Data.DTreeMap.Slice | Lean.Syntax | null | false |
CategoryTheory.Adjunction.IsTriangulated.commShift._autoParam | Mathlib.CategoryTheory.Triangulated.Adjunction | Lean.Syntax | null | false |
_private.Mathlib.CategoryTheory.Limits.FilteredColimitCommutesProduct.0.CategoryTheory.Limits.pointwiseProductCompEvaluation._simp_1 | Mathlib.CategoryTheory.Limits.FilteredColimitCommutesProduct | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
{F G H : CategoryTheory.Functor C D} (α : F ⟶ G) (β : G ⟶ H) (X : C),
CategoryTheory.CategoryStruct.comp (α.app X) (β.app X) = (CategoryTheory.CategoryStruct.comp α β).app X | null | false |
_private.Mathlib.RingTheory.MvPowerSeries.Substitution.0.MvPowerSeries.rescale_zero._simp_1_3 | Mathlib.RingTheory.MvPowerSeries.Substitution | ∀ {F : Sort u_1} {α : Sort u_2} {β : α → Sort u_3} [i : DFunLike F α β] {f g : F}, (f = g) = ∀ (x : α), f x = g x | null | false |
CategoryTheory.Functor.isLeftDerivedFunctor_iff_of_iso | Mathlib.CategoryTheory.Functor.Derived.LeftDerived | ∀ {C : Type u_1} {D : Type u_3} {H : Type u_2} [inst : CategoryTheory.Category.{v_1, u_1} C]
[inst_1 : CategoryTheory.Category.{v_2, u_3} D] [inst_2 : CategoryTheory.Category.{v_3, u_2} H]
{LF' LF : CategoryTheory.Functor D H} {F : CategoryTheory.Functor C H} {L : CategoryTheory.Functor C D}
(α : L.comp LF ⟶ F) (... | null | true |
Aesop.InstMap.mk.injEq | Aesop.Forward.State | ∀ (map map_1 : Lean.PHashMap Aesop.SlotIndex (Aesop.EMap (Lean.PHashSet Aesop.Match × Lean.PHashSet Aesop.Hyp))),
({ map := map } = { map := map_1 }) = (map = map_1) | null | true |
_private.Std.Data.DTreeMap.Internal.Balancing.0.Std.DTreeMap.Internal.Impl.balance!_eq_balanceₘ._proof_1_21 | Std.Data.DTreeMap.Internal.Balancing | ∀ {α : Type u_1} {β : α → Type u_2} (ls size : ℕ) (l r : Std.DTreeMap.Internal.Impl α β),
(l.Balanced ∧
r.Balanced ∧ (l.size + r.size ≤ 1 ∨ l.size ≤ 3 * r.size ∧ r.size ≤ 3 * l.size) ∧ size = l.size + 1 + r.size) ∧
(size + 0 ≤ 1 ∨ size ≤ 3 * 0 ∧ 0 ≤ 3 * size) ∧ ls = size + 1 + 0 →
0 > 3 * (l.size + ... | null | false |
AlgebraicGeometry.StructureSheaf.openAlgebra._aux_1 | Mathlib.AlgebraicGeometry.StructureSheaf | (R : Type u_1) →
[inst : CommRing R] →
(U : (TopologicalSpace.Opens (PrimeSpectrum R))ᵒᵖ) →
R →
↑((AlgebraicGeometry.Spec.structureSheaf R).obj.obj U) → ↑((AlgebraicGeometry.Spec.structureSheaf R).obj.obj U) | null | false |
CategoryTheory.CommGrp.toMon | Mathlib.CategoryTheory.Monoidal.CommGrp_ | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
[inst_1 : CategoryTheory.CartesianMonoidalCategory C] →
[inst_2 : CategoryTheory.BraidedCategory C] → CategoryTheory.CommGrp C → CategoryTheory.Mon C | A commutative group object is a monoid object. | true |
_private.Init.Data.SInt.Lemmas.0.ISize.lt_of_le_of_ne._simp_1_3 | Init.Data.SInt.Lemmas | ∀ {x y : ISize}, (x = y) = (x.toInt = y.toInt) | null | false |
_private.Mathlib.NumberTheory.Harmonic.ZetaAsymp.0.deriv_riemannZeta_zero._simp_1_1 | Mathlib.NumberTheory.Harmonic.ZetaAsymp | (0 < Real.pi) = True | null | false |
_private.Mathlib.Analysis.Real.Hyperreal.0.Hyperreal.tendsto_iff_forall._simp_1_3 | Mathlib.Analysis.Real.Hyperreal | ∀ {α : Type u} {p q : α → Prop} {f : Filter α},
(∀ᶠ (x : α) in f, p x ∧ q x) = ((∀ᶠ (x : α) in f, p x) ∧ ∀ᶠ (x : α) in f, q x) | null | false |
Array.isEqvAux.congr_simp | Init.Data.Array.DecidableEq | ∀ {α : Type u} (xs xs_1 : Array α) (e_xs : xs = xs_1) (ys ys_1 : Array α) (e_ys : ys = ys_1) (hsz : xs.size = ys.size)
(p p_1 : α → α → Bool),
p = p_1 → ∀ (i i_1 : ℕ) (e_i : i = i_1) (x : i ≤ xs.size), xs.isEqvAux ys hsz p i x = xs_1.isEqvAux ys_1 ⋯ p_1 i_1 ⋯ | null | true |
Ideal.Quotient.stabilizerQuotientInertiaEquiv | Mathlib.RingTheory.Invariant.Basic | {A : Type u_1} →
{B : Type u_2} →
[inst : CommRing A] →
[inst_1 : CommRing B] →
[inst_2 : Algebra A B] →
(G : Type u_3) →
[inst_3 : Group G] →
[Finite G] →
[inst_5 : MulSemiringAction G B] →
[SMulCommClass G A B] →
... | The isomorphism between `stabilizer G Q ⧸ inertia G Q` and the Galois group of the residue fields
extension `B ⧸ Q` over `A ⧸ P`.
| true |
TopologicalSpace.Opens.mem_map | Mathlib.Topology.Category.TopCat.Opens | ∀ {X Y : TopCat} {f : X ⟶ Y} {U : TopologicalSpace.Opens ↑Y} {x : ↑X},
x ∈ (TopologicalSpace.Opens.map f).obj U ↔ (TopCat.Hom.hom f) x ∈ U | null | true |
LieSubmodule.iInf_toSubmodule | Mathlib.Algebra.Lie.Submodule | ∀ {R : Type u} {L : Type v} {M : Type w} [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : AddCommGroup M]
[inst_3 : Module R M] [inst_4 : LieRingModule L M] {ι : Sort u_1} (p : ι → LieSubmodule R L M),
↑(⨅ i, p i) = ⨅ i, ↑(p i) | null | true |
_private.Lean.Elab.Match.0.Lean.Elab.Term.ToDepElimPattern.normalize.processInaccessible | Lean.Elab.Match | Lean.Expr → Lean.Elab.Term.ToDepElimPattern.M Lean.Expr | null | true |
tsupport_smul_subset_right | Mathlib.Topology.Algebra.Support | ∀ {X : Type u_1} [inst : TopologicalSpace X] {M : Type u_9} {α : Type u_10} [inst_1 : Zero α]
[inst_2 : SMulZeroClass M α] (f : X → M) (g : X → α), (tsupport fun x => f x • g x) ⊆ tsupport g | null | true |
NonemptyInterval.coe_subset_coe | Mathlib.Order.Interval.Basic | ∀ {α : Type u_1} [inst : PartialOrder α] {s t : NonemptyInterval α}, ↑s ⊆ ↑t ↔ s ≤ t | null | true |
_private.Mathlib.Order.KonigLemma.0.exists_seq_forall_proj_of_forall_finite.match_1_17 | Mathlib.Order.KonigLemma | ∀ {α : ℕ → Type u_1},
let αs := (i : ℕ) × α i;
∀ (motive : αs → Prop) (x : αs), (∀ (i : ℕ) (a : α i), motive ⟨i, a⟩) → motive x | null | false |
Std.TreeMap.Raw.maxKeyD_eq_fallback | Std.Data.TreeMap.Raw.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.TreeMap.Raw α β cmp} [Std.TransCmp cmp],
t.WF → t.isEmpty = true → ∀ {fallback : α}, t.maxKeyD fallback = fallback | null | true |
_private.Init.Data.String.Pattern.String.0.String.Slice.Pattern.ForwardSliceSearcher.buildTable.computeDistance._unary._proof_1 | Init.Data.String.Pattern.String | ∀ (pat : String.Slice) (table : Array ℕ),
table.size ≤ pat.utf8ByteSize → ∀ guess < table.size, { byteIdx := guess } < pat.rawEndPos | null | false |
Lean.Server.instToJsonGoToKind | Lean.Server.GoTo | Lean.ToJson Lean.Server.GoToKind | null | true |
Array.mapFinIdx_push | Init.Data.Array.MapIdx | ∀ {α : Type u_1} {β : Type u_2} {xs : Array α} {a : α} {f : (i : ℕ) → α → i < (xs.push a).size → β},
(xs.push a).mapFinIdx f = (xs.mapFinIdx fun i a_1 h => f i a_1 ⋯).push (f xs.size a ⋯) | null | true |
Classical.propDecidable.match_1 | Init.Classical | ∀ (a : Prop) (motive : a ∨ ¬a → Prop) (x : a ∨ ¬a), (∀ (h : a), motive ⋯) → (∀ (h : ¬a), motive ⋯) → motive x | null | false |
_private.Init.Data.Vector.Lemmas.0.Vector.mapM.go.eq_def | Init.Data.Vector.Lemmas | ∀ {m : Type u_1 → Type u_2} {α : Type u_3} {β : Type u_1} {n : ℕ} [inst : Monad m] (f : α → m β) (xs : Vector α n)
(k : ℕ) (h : k ≤ n) (acc : Vector β k),
Vector.mapM.go✝ f xs k h acc =
if h' : k < n then do
let __do_lift ← f xs[k]
Vector.mapM.go✝ f xs (k + 1) ⋯ (acc.push __do_lift)
else pure (V... | null | true |
Preorder.continuous_restrictLe | Mathlib.Topology.PreorderRestrict | ∀ {α : Type u_1} [inst : Preorder α] {X : α → Type u_2} [inst_1 : (i : α) → TopologicalSpace (X i)] (a : α),
Continuous (Preorder.restrictLe a) | null | true |
_private.Mathlib.NumberTheory.Divisors.0.Nat.divisorsAntidiagonal_eq_prod_filter_of_le._proof_1_9 | Mathlib.NumberTheory.Divisors | ∀ (n1 n2 : ℕ), ¬n1 * n2 = 0 → 0 < n2 | null | false |
Lean.Meta.Grind.CongrTheoremCacheKey.mk.inj | Lean.Meta.Tactic.Grind.Types | ∀ {f : Lean.Expr} {numArgs : ℕ} {f_1 : Lean.Expr} {numArgs_1 : ℕ},
{ f := f, numArgs := numArgs } = { f := f_1, numArgs := numArgs_1 } → f = f_1 ∧ numArgs = numArgs_1 | null | true |
_private.Lean.Meta.SynthInstance.0.Lean.Meta.preprocess.norm.match_1 | Lean.Meta.SynthInstance | (motive : Lean.Expr → Sort u_1) →
(e : Lean.Expr) → ((f a : Lean.Expr) → motive (f.app a)) → ((x : Lean.Expr) → motive x) → motive e | null | false |
Polynomial.coeff_X_mul_zero | Mathlib.Algebra.Polynomial.Coeff | ∀ {R : Type u} [inst : Semiring R] (p : Polynomial R), (Polynomial.X * p).coeff 0 = 0 | null | true |
Subgroup.val_finsetProd | Mathlib.Algebra.Group.Subgroup.Finite | ∀ {ι : Type u_2} {G : Type u_3} [inst : CommGroup G] (H : Subgroup G) (f : ι → ↥H) (s : Finset ι),
↑(∏ i ∈ s, f i) = ∏ i ∈ s, ↑(f i) | null | true |
QuadraticMap.associated_isOrtho._simp_1 | Mathlib.LinearAlgebra.QuadraticForm.Basic | ∀ {R : Type u_3} {M : Type u_4} {N : Type u_5} [inst : CommRing R] [inst_1 : AddCommGroup M] [inst_2 : Module R M]
[inst_3 : AddCommGroup N] [inst_4 : Module R N] {Q : QuadraticMap R M N} [inst_5 : Invertible 2] {x y : M},
(((QuadraticMap.associated Q) x) y = 0) = Q.IsOrtho x y | null | false |
disjoint_inf_sdiff | Mathlib.Order.BooleanAlgebra.Basic | ∀ {α : Type u} {x y : α} [inst : GeneralizedBooleanAlgebra α], Disjoint (x ⊓ y) (x \ y) | null | true |
Lean.Meta.Simp.ignoreEquations | Lean.Meta.Tactic.Simp.SimpTheorems | Lean.Name → Lean.CoreM Bool | Reducible functions and projection functions should always be put in `toUnfold`, instead
of trying to use equational theorems.
The simplifiers has special support for structure and class projections, and gets
confused when they suddenly rewrite, so ignore equations for them
| true |
String.Legacy.Iterator.mk | Init.Data.String.Iterator | String → String.Pos.Raw → String.Legacy.Iterator | null | true |
CentroidHom.centerStarEmbedding._proof_2 | Mathlib.Algebra.Star.CentroidHom | ∀ {α : Type u_1} [inst : NonUnitalNonAssocSemiring α] [inst_1 : StarRing α] (x : ↥(Subsemiring.center (CentroidHom α))),
(SubsemiringClass.subtype (Subsemiring.center (CentroidHom α))).toNonUnitalRingHom.toFun (star x) =
(SubsemiringClass.subtype (Subsemiring.center (CentroidHom α))).toNonUnitalRingHom.toFun (sta... | null | false |
_private.Init.Data.SInt.Bitwise.0.Int8.xor_left_inj._simp_1_1 | Init.Data.SInt.Bitwise | ∀ {a b : Int8}, (a = b) = (a.toBitVec = b.toBitVec) | null | false |
Option.instDecidableEq._proof_1 | Init.Data.Option.Basic | ∀ {α : Type u_1}, none = none | null | false |
_private.Init.Data.Iterators.Lemmas.Combinators.Monadic.Take.0.Std.IterM.step_take.match_3.eq_2 | Init.Data.Iterators.Lemmas.Combinators.Monadic.Take | ∀ (motive : ℕ → Sort u_1) (k : ℕ) (h_1 : Unit → motive 0) (h_2 : (k : ℕ) → motive k.succ),
(match k.succ with
| 0 => h_1 ()
| k.succ => h_2 k) =
h_2 k | null | true |
OpenPartialHomeomorph.isManifold_singleton | Mathlib.Geometry.Manifold.IsManifold.Basic | ∀ {𝕜 : 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} {n : WithTop ℕ∞}
{M : Type u_4} [inst_4 : TopologicalSpace M] (e : OpenPartialHomeomorph M H) (h : e.source = Se... | null | true |
ImportGraph.Widget.CopyDisplay._sizeOf_1 | ImportGraph.Widget.Copy | ImportGraph.Widget.CopyDisplay → ℕ | null | false |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.Const.getD_erase_self._simp_1_2 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {instOrd : Ord α} {a b : α}, (compare a b ≠ Ordering.eq) = ((a == b) = false) | null | false |
GroupTopology.instCompleteLattice._proof_3 | Mathlib.Topology.Algebra.Group.GroupTopology | ∀ {α : Type u_1} [inst : Group α] (a b c : GroupTopology α), a ≤ c → b ≤ c → SemilatticeSup.sup a b ≤ c | null | false |
Subalgebra.algebraicClosure_eq_integralClosure | Mathlib.RingTheory.Algebraic.Integral | ∀ (S : Type u_2) [inst : CommRing S] {K : Type u_4} [inst_1 : Field K] [inst_2 : Algebra K S],
Subalgebra.algebraicClosure K S = integralClosure K S | null | true |
_private.Mathlib.MeasureTheory.VectorMeasure.Decomposition.Hahn.0.MeasureTheory.SignedMeasure.existsNatOneDivLTMeasure_of_not_negative | Mathlib.MeasureTheory.VectorMeasure.Decomposition.Hahn | ∀ {α : Type u_1} [inst : MeasurableSpace α] {s : MeasureTheory.SignedMeasure α} {i : Set α},
¬MeasureTheory.VectorMeasure.restrict s i ≤ MeasureTheory.VectorMeasure.restrict 0 i →
∃ n, MeasureTheory.SignedMeasure.ExistsOneDivLT✝ s i n | null | true |
IO.FS.Handle.putStrLn | Init.System.IO | IO.FS.Handle → String → IO Unit | Writes the contents of the string to the handle, followed by a newline. Uses UTF-8.
| true |
Std.HashMap.getElem!_filterMap | Std.Data.HashMap.Lemmas | ∀ {α : Type u} {β : Type v} {γ : Type w} {x : BEq α} {x_1 : Hashable α} {m : Std.HashMap α β} [inst : EquivBEq α]
[inst_1 : LawfulHashable α] [inst_2 : Inhabited γ] {f : α → β → Option γ} {k : α},
(Std.HashMap.filterMap f m)[k]! = (m[k]?.pbind fun x_2 h' => f (m.getKey k ⋯) x_2).get! | null | true |
CategoryTheory.ShortComplex.LeftHomologyMapData.quasiIso_iff | Mathlib.Algebra.Homology.ShortComplex.QuasiIso | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{S₁ S₂ : CategoryTheory.ShortComplex C} [inst_2 : S₁.HasHomology] [inst_3 : S₂.HasHomology] {φ : S₁ ⟶ S₂}
{h₁ : S₁.LeftHomologyData} {h₂ : S₂.LeftHomologyData} (γ : CategoryTheory.ShortComplex.LeftHomo... | null | true |
Mathlib.Tactic.DeprecateTo.mkDeprecationStx | Mathlib.Tactic.DeprecateTo | Lean.TSyntax `ident → Lean.Name → optParam (Option String) none → Lean.Elab.Command.CommandElabM (Lean.TSyntax `command) | Produce the syntax for the command `@[deprecated (since := "YYYY-MM-DD")] alias n := id`. | true |
ClassGroup.mulEquiv_symm_apply | Mathlib.RingTheory.ClassGroup.ExtendedHom | ∀ {A : Type u_1} {B : Type u_2} [inst : CommRing A] [inst_1 : IsDomain A] [inst_2 : CommRing B] [inst_3 : IsDomain B]
(g : A ≃+* B) (a : ClassGroup B), (ClassGroup.mulEquiv g).symm a = (ClassGroup.map ↑g.symm ⋯) a | null | true |
Pell.exists_iff_not_isSquare | Mathlib.NumberTheory.Pell | ∀ {d : ℤ}, 0 < d → ((∃ x y, x ^ 2 - d * y ^ 2 = 1 ∧ y ≠ 0) ↔ ¬IsSquare d) | If `d` is a positive integer, then there is a nontrivial solution
to the Pell equation `x^2 - d*y^2 = 1` if and only if `d` is not a square. | true |
_private.Init.Data.Int.Linear.0.Int.Internal.Linear.cooper_dvd_right_core.match_1_1 | Init.Data.Int.Linear | ∀ {a b c d s p q : ℤ}
(motive :
(∃ k,
0 ≤ k ∧
k < ↑(b.lcm (b * d / ↑((b * d).gcd c))) ∧
-a * k + b * p ≤ -a * -q ∧ b ∣ k - -q ∧ b * d ∣ -c * k + c * -q + b * s) →
Prop)
(x :
∃ k,
0 ≤ k ∧
k < ↑(b.lcm (b * d / ↑((b * d).gcd c))) ∧
-a * k + b * p ≤ -a... | null | false |
Subgroup.FG.pi | Mathlib.GroupTheory.Finiteness | ∀ {ι : Type u_5} [Finite ι] {G : ι → Type u_6} [inst : (i : ι) → Group (G i)] {P : (i : ι) → Subgroup (G i)},
(∀ (i : ι), (P i).FG) → (Subgroup.pi Set.univ P).FG | Finite product of finitely generated subgroups is finitely generated. | true |
AddSubgroup.equivOp | Mathlib.Algebra.Group.Subgroup.MulOpposite | {G : Type u_1} → [inst : AddGroup G] → (H : AddSubgroup G) → ↥H ≃ ↥H.op | Bijection between an additive subgroup `H` and its opposite. | true |
CategoryTheory.Bicategory.prod_Hom | Mathlib.CategoryTheory.Bicategory.Product | ∀ (B : Type u₁) [inst : CategoryTheory.Bicategory B] (C : Type u₂) [inst_1 : CategoryTheory.Bicategory C] (X Y : B × C),
(X ⟶ Y) = ((X.1 ⟶ Y.1) × (X.2 ⟶ Y.2)) | null | true |
SkewMonoidAlgebra.support_single_mul_subset | Mathlib.Algebra.SkewMonoidAlgebra.Support | ∀ {k : Type u_1} {G : Type u_2} [inst : Monoid G] [inst_1 : Semiring k] [inst_2 : MulSemiringAction G k]
(f : SkewMonoidAlgebra k G) [inst_3 : DecidableEq G] (r : k) (a : G),
(SkewMonoidAlgebra.single a r * f).support ⊆ Finset.image (fun x => a * x) f.support | null | true |
InnerProductSpace.HarmonicOnNhd.continuousOn | Mathlib.Analysis.InnerProductSpace.Harmonic.Basic | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : InnerProductSpace ℝ E] [inst_2 : FiniteDimensional ℝ E]
{F : Type u_2} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace ℝ F] {f : E → F} {s : Set E},
InnerProductSpace.HarmonicOnNhd f s → ContinuousOn f s | Harmonic functions are continuous.
| true |
PolynomialModule.smul_single_apply | Mathlib.Algebra.Polynomial.Module.Basic | ∀ {R : Type u_2} {M : Type u_3} [inst : CommRing R] [inst_1 : AddCommGroup M] [inst_2 : Module R M] (i : ℕ)
(f : Polynomial R) (m : M) (n : ℕ),
(f • PolynomialModule.single R i m).coeff n = if i ≤ n then f.coeff (n - i) • m else 0 | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.