name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
Std.DHashMap.Raw.getKey?_eq_some | Std.Data.DHashMap.RawLemmas | ∀ {α : Type u} {β : α → Type v} {m : Std.DHashMap.Raw α β} [inst : BEq α] [inst_1 : Hashable α] [LawfulBEq α],
m.WF → ∀ {k : α}, k ∈ m → m.getKey? k = some k | null | true |
iInf_prod' | Mathlib.Order.CompleteLattice.Basic | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} [inst : CompleteLattice α] (f : β → γ → α),
⨅ i, ⨅ j, f i j = ⨅ x, f x.1 x.2 | null | true |
_private.Mathlib.Data.Fin.SuccPred.0.Fin.succAbove_succAbove_succAbove_predAbove._proof_1_8 | Mathlib.Data.Fin.SuccPred | ∀ {n : ℕ} (i : Fin (n + 2)) (k : Fin n), ↑k < ↑i - 1 → ¬↑k + 1 < ↑i → ↑k + 1 = ↑k + 1 + 1 | null | false |
CFC.sqrt_eq_zero_iff._auto_1 | Mathlib.Analysis.SpecialFunctions.ContinuousFunctionalCalculus.Rpow.Basic | Lean.Syntax | null | false |
SpectrumRestricts.starAlgHom._proof_2 | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Restrict | ∀ {R : Type u_1} {S : Type u_2} [inst : Semifield R] [inst_1 : Semifield S] [inst_2 : TopologicalSpace S]
[IsTopologicalSemiring S] [inst_4 : Algebra R S], ContinuousConstSMul R S | null | false |
AdicCompletion.ofValEqZero | Mathlib.RingTheory.AdicCompletion.Completeness | {R : Type u_1} →
[inst : CommRing R] →
(I : Ideal R) →
{M : Type u_2} →
[inst_1 : AddCommGroup M] →
[inst_2 : Module R M] → {n : ℕ} → {x : AdicCompletion I M} → ↑x n = 0 → AdicCompletion I ↥(I ^ n • ⊤) | Given an element `x` in the adic completion of `M` whose projection to `M / I ^ n • M` is zero,
`ofValEqZero` constructs the corresponding element in the adic completion of `I ^ n • M`. | true |
_private.Mathlib.Tactic.TacticAnalysis.Declarations.0.Mathlib.TacticAnalysis.mergeWithGrind.match_4 | Mathlib.Tactic.TacticAnalysis.Declarations | (motive : Array Mathlib.TacticAnalysis.TacticNode → Sort u_1) →
(x : Array Mathlib.TacticAnalysis.TacticNode) →
((preI postI : Mathlib.TacticAnalysis.TacticNode) → motive #[preI, postI]) →
((x : Array Mathlib.TacticAnalysis.TacticNode) → motive x) → motive x | null | false |
AlgebraicGeometry.LocallyRingedSpace.instCategory._proof_3 | Mathlib.Geometry.RingedSpace.LocallyRingedSpace | ∀ {W X Y Z : AlgebraicGeometry.LocallyRingedSpace} (f : W.Hom X) (g : X.Hom Y) (h : Y.Hom Z),
AlgebraicGeometry.LocallyRingedSpace.comp (AlgebraicGeometry.LocallyRingedSpace.comp f g) h =
AlgebraicGeometry.LocallyRingedSpace.comp f (AlgebraicGeometry.LocallyRingedSpace.comp g h) | null | false |
ProbabilityTheory.integrable_exp_mul_of_le_of_le | Mathlib.Probability.Moments.IntegrableExpMul | ∀ {Ω : Type u_1} {m : MeasurableSpace Ω} {X : Ω → ℝ} {μ : MeasureTheory.Measure Ω} {t a b : ℝ},
MeasureTheory.Integrable (fun ω => Real.exp (a * X ω)) μ →
MeasureTheory.Integrable (fun ω => Real.exp (b * X ω)) μ →
a ≤ t → t ≤ b → MeasureTheory.Integrable (fun ω => Real.exp (t * X ω)) μ | null | true |
Mathlib.Tactic.MkIff.Shape.mk._flat_ctor | Mathlib.Tactic.MkIffOfInductiveProp | List Bool → Option ℕ → Mathlib.Tactic.MkIff.Shape | null | false |
_private.Init.Data.String.Lemmas.Pattern.Basic.0.String.Slice.Pattern.Model.matchesAt_iff_matchesAt_ofSliceFrom._simp_1_1 | Init.Data.String.Lemmas.Pattern.Basic | ∀ {ρ : Type} {pat : ρ} [inst : String.Slice.Pattern.Model.PatternModel pat] {s : String.Slice} {pos : s.Pos},
String.Slice.Pattern.Model.MatchesAt pat pos = ∃ endPos, String.Slice.Pattern.Model.IsLongestMatchAt pat pos endPos | null | false |
AddChar.FiniteField.primitiveChar._proof_5 | Mathlib.NumberTheory.LegendreSymbol.AddCharacter | ∀ (F : Type u_1) (F' : Type u_2) [inst : Field F] [inst_1 : Finite F] [inst_2 : Field F']
(hp₂ : ¬ringChar F' ∣ ringChar F),
(AddChar.primitiveZModChar ((ringChar F).toPNat ⋯) F' ⋯).char.compAddMonoidHom
(Algebra.trace (ZMod (ringChar F)) F).toAddMonoidHom ≠
1 | null | false |
PMF.bind_const | Mathlib.Probability.ProbabilityMassFunction.Monad | ∀ {α : Type u_1} {β : Type u_2} (p : PMF α) (q : PMF β), (p.bind fun x => q) = q | null | true |
PrimeSpectrum.isClosedMap_comap_of_isIntegral | Mathlib.RingTheory.Spectrum.Prime.Topology | ∀ {R : Type u_1} {S : Type u_2} [inst : CommRing R] [inst_1 : CommRing S] (f : R →+* S),
f.IsIntegral → IsClosedMap (PrimeSpectrum.comap f) | null | true |
UniformFun.uniformCore.match_5 | Mathlib.Topology.UniformSpace.UniformConvergenceTopology | ∀ (α : Type u_1) (β : Type u_2) (W : Set (β × β)) (x : UniformFun α β × UniformFun α β)
(motive : x ∈ SetRel.comp (UniformFun.gen α β W) (UniformFun.gen α β W) → Prop)
(x_1 : x ∈ SetRel.comp (UniformFun.gen α β W) (UniformFun.gen α β W)),
(∀ (w : UniformFun α β) (huw : (x.1, w) ∈ UniformFun.gen α β W) (hwv : (w, ... | null | false |
Filter.Germ.instAddSemigroup.eq_1 | Mathlib.Order.Filter.Germ.Basic | ∀ {α : Type u_1} {l : Filter α} {M : Type u_5} [inst : AddSemigroup M],
Filter.Germ.instAddSemigroup = { toAdd := Filter.Germ.instAdd, add_assoc := ⋯ } | null | true |
ArithmeticFunction.coe_mk | Mathlib.NumberTheory.ArithmeticFunction.Defs | ∀ {R : Type u_1} [inst : Zero R] (f : ℕ → R) (hf : f 0 = 0), ⇑{ toFun := f, map_zero' := hf } = f | null | true |
CategoryTheory.CoreSmallCategoryOfSet.mk.sizeOf_spec | Mathlib.CategoryTheory.SmallRepresentatives | ∀ {Ω : Type w} {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : SizeOf Ω] [inst_2 : SizeOf C]
(obj : Set Ω) (hom : ↑obj → ↑obj → Set Ω) (objEquiv : ↑obj ≃ C)
(homEquiv : {X Y : ↑obj} → ↑(hom X Y) ≃ (objEquiv X ⟶ objEquiv Y)),
sizeOf { obj := obj, hom := hom, objEquiv := objEquiv, homEquiv := homEq... | null | true |
univ_eq_singleton_of_card_one | Mathlib.Data.Fintype.Card | ∀ {α : Type u_3} [inst : Fintype α] (x : α), Fintype.card α = 1 → Finset.univ = {x} | null | true |
GenContFract.Pair.rec | Mathlib.Algebra.ContinuedFractions.Basic | {α : Type u_1} →
{motive : GenContFract.Pair α → Sort u} →
((a b : α) → motive { a := a, b := b }) → (t : GenContFract.Pair α) → motive t | null | false |
_private.Mathlib.Geometry.Euclidean.Angle.Unoriented.TriangleInequality.0.InnerProductGeometry.inner_normalize_ortho | Mathlib.Geometry.Euclidean.Angle.Unoriented.TriangleInequality | ∀ {V : Type u_1} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V] (x y : V),
inner ℝ y (NormedSpace.normalize (InnerProductGeometry.ortho✝ y x)) = 0 | null | true |
_private.Mathlib.RingTheory.SimpleModule.WedderburnArtin.0.isSimpleRing_isArtinianRing_iff._simp_1_6 | Mathlib.RingTheory.SimpleModule.WedderburnArtin | ∀ {R : Type u_5} [inst : Semiring R] {I : Ideal R}, Submodule.IsFullyInvariant I = I.IsTwoSided | null | false |
Polynomial.ofSubring | Mathlib.RingTheory.Polynomial.Subring | {R : Type u_1} → [inst : Ring R] → (T : Subring R) → Polynomial ↥T → Polynomial R | Given a polynomial whose coefficients are in some subring, return
the corresponding polynomial whose coefficients are in the ambient ring. | true |
FirstOrder.Language.DirectLimit.exists_quotient_mk'_sigma_mk'_eq | Mathlib.ModelTheory.DirectLimit | ∀ {L : FirstOrder.Language} {ι : Type v} [inst : Preorder ι] (G : ι → Type w) [inst_1 : (i : ι) → L.Structure (G i)]
(f : (i j : ι) → i ≤ j → L.Embedding (G i) (G j)) [inst_2 : IsDirectedOrder ι]
[inst_3 : DirectedSystem G fun i j h => ⇑(f i j h)] [Nonempty ι] {α : Type u_1} [Finite α]
(x : α → FirstOrder.Languag... | null | true |
_private.Init.Data.String.Lemmas.Order.0.String.Pos.ofSliceFrom_next._simp_1_3 | Init.Data.String.Lemmas.Order | ∀ {s : String} {p₀ : s.Pos} {p : (s.sliceFrom p₀).Pos} {q : s.Pos},
(String.Pos.ofSliceFrom p ≤ q) = ∃ (h : p₀ ≤ q), p ≤ p₀.sliceFrom q h | null | false |
ContDiffMapSupportedIn.mkCLMtoNormedSpace._proof_2 | Mathlib.Analysis.Distribution.ContDiffMapSupportedIn | ∀ (𝕜 : Type u_4) {E : Type u_1} {F : Type u_2} [inst : NontriviallyNormedField 𝕜] [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace ℝ E] [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace ℝ F] [inst_5 : NormedSpace 𝕜 F]
[inst_6 : SMulCommClass ℝ 𝕜 F] {n : ℕ∞} {K : TopologicalSpace.Compacts E} {G : Type u... | null | false |
_private.Lean.Compiler.LCNF.Basic.0.Lean.Compiler.LCNF.CodeDecl.fvarId.match_1 | Lean.Compiler.LCNF.Basic | {pu : Lean.Compiler.LCNF.Purity} →
(motive : Lean.Compiler.LCNF.CodeDecl pu → Sort u_1) →
(x : Lean.Compiler.LCNF.CodeDecl pu) →
((decl : Lean.Compiler.LCNF.LetDecl pu) → motive (Lean.Compiler.LCNF.CodeDecl.let decl)) →
((decl : Lean.Compiler.LCNF.FunDecl pu) →
(h : pu = Lean.Compiler.LC... | null | false |
MulSemiringAction.noConfusionType | Mathlib.Algebra.Ring.Action.Basic | Sort u_1 →
{M : Type u} →
{R : Type v} →
[inst : Monoid M] →
[inst_1 : Semiring R] →
MulSemiringAction M R →
{M' : Type u} →
{R' : Type v} → [inst' : Monoid M'] → [inst'_1 : Semiring R'] → MulSemiringAction M' R' → Sort u_1 | null | false |
HasSum.hasSum_compl_iff | Mathlib.Topology.Algebra.InfiniteSum.Group | ∀ {α : Type u_1} {β : Type u_2} [inst : AddCommGroup α] [inst_1 : TopologicalSpace α] [IsTopologicalAddGroup α]
{f : β → α} {a₁ a₂ : α} {s : Set β}, HasSum (f ∘ Subtype.val) a₁ → (HasSum (f ∘ Subtype.val) a₂ ↔ HasSum f (a₁ + a₂)) | null | true |
CategoryTheory.Sheaf.instIsRightAdjointΓ | Mathlib.CategoryTheory.Sites.GlobalSections | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_4, u_2} C] (J : CategoryTheory.GrothendieckTopology C)
(A : Type u_3) [inst_1 : CategoryTheory.Category.{u_1, u_3} A] [inst_2 : CategoryTheory.HasWeakSheafify J A]
[inst_3 : CategoryTheory.HasGlobalSectionsFunctor J A], (CategoryTheory.Sheaf.Γ J A).IsRightAdjoint | null | true |
SeparableClosure.hasEnoughRootsOfUnity_pow | Mathlib.RingTheory.RootsOfUnity.AlgebraicallyClosed | ∀ (F : Type u_1) [inst : Field F] (n k : ℕ) [NeZero ↑n], HasEnoughRootsOfUnity (SeparableClosure F) (n ^ k) | null | true |
HasFibers.ι | Mathlib.CategoryTheory.FiberedCategory.HasFibers | {𝒮 : Type u₁} →
{𝒳 : Type u₂} →
{inst : CategoryTheory.Category.{v₁, u₁} 𝒮} →
{inst_1 : CategoryTheory.Category.{v₂, u₂} 𝒳} →
{p : CategoryTheory.Functor 𝒳 𝒮} → [self : HasFibers p] → (S : 𝒮) → CategoryTheory.Functor (HasFibers.Fib p S) 𝒳 | The functor `ι : Fib S ⥤ 𝒳`. | true |
LocallyBoundedVariationOn.fun_mul | Mathlib.Analysis.BoundedVariation | ∀ {α : Type u_2} [inst : LinearOrder α] {f g : α → ℝ} {s : Set α},
LocallyBoundedVariationOn f s → LocallyBoundedVariationOn g s → LocallyBoundedVariationOn (fun i => f i * g i) s | Eta-expanded form of `LocallyBoundedVariationOn.mul` | true |
CategoryTheory.Abelian.SpectralObject.instEpiGShortComplexOpcyclesThreeδ₂Toδ₁ | Mathlib.Algebra.Homology.SpectralObject.Page | ∀ {C : Type u_1} {ι : Type u_2} [inst : CategoryTheory.Category.{v_1, u_1} C]
[inst_1 : CategoryTheory.Category.{v_2, u_2} ι] [inst_2 : CategoryTheory.Abelian C]
(X : CategoryTheory.Abelian.SpectralObject C ι) {i₀ i₁ i₂ i₃ : ι} (f₁ : i₀ ⟶ i₁) (f₂ : i₁ ⟶ i₂) (f₃ : i₂ ⟶ i₃)
(f₁₂ : i₀ ⟶ i₂) (f₂₃ : i₁ ⟶ i₃) (h₁₂ : Ca... | null | true |
MonoidWithZeroHom.fst.eq_1 | Mathlib.Algebra.GroupWithZero.ProdHom | ∀ (G₀ : Type u_1) (H₀ : Type u_2) [inst : GroupWithZero G₀] [inst_1 : GroupWithZero H₀],
MonoidWithZeroHom.fst G₀ H₀ = WithZero.lift' ((Units.coeHom G₀).comp (MonoidHom.fst G₀ˣ H₀ˣ)) | null | true |
ULift.subNegAddMonoid._proof_4 | Mathlib.Algebra.Group.ULift | ∀ {α : Type u_2} [inst : SubNegMonoid α] (x x_1 : ULift.{u_1, u_2} α), Equiv.ulift (x - x_1) = Equiv.ulift (x - x_1) | null | false |
_private.Mathlib.LinearAlgebra.FreeModule.Norm.0.associated_norm_prod_smith._simp_1_3 | Mathlib.LinearAlgebra.FreeModule.Norm | ∀ {R₁ : Type u_2} {R₂ : Type u_3} {R₃ : Type u_4} {M₁ : Type u_9} {M₂ : Type u_10} {M₃ : Type u_11} [inst : Semiring R₁]
[inst_1 : Semiring R₂] [inst_2 : Semiring R₃] [inst_3 : AddCommMonoid M₁] [inst_4 : AddCommMonoid M₂]
[inst_5 : AddCommMonoid M₃] {module_M₁ : Module R₁ M₁} {module_M₂ : Module R₂ M₂} {module_M₃ ... | null | false |
_private.Mathlib.Combinatorics.Additive.AP.Three.Behrend.0.Behrend.map_succ._simp_1_2 | Mathlib.Combinatorics.Additive.AP.Three.Behrend | ∀ {G : Type u_1} [inst : Semigroup G] (a b c : G), a * (b * c) = a * b * c | null | false |
Filter.Germ.coe_vadd'._simp_1 | Mathlib.Order.Filter.Germ.Basic | ∀ {α : Type u_1} {β : Type u_2} {l : Filter α} {M : Type u_5} [inst : VAdd M β] (c : α → M) (f : α → β),
↑c +ᵥ ↑f = ↑(c +ᵥ f) | null | false |
_private.Lean.Parser.Term.Doc.0.Lean.Parser.Term.Doc.getRecommendedSpellingString.bullet._sparseCasesOn_1 | Lean.Parser.Term.Doc | {α : Type u} →
{motive : List α → Sort u_1} → (t : List α) → motive [] → (Nat.hasNotBit 1 t.ctorIdx → motive t) → motive t | null | false |
AlgebraicGeometry.morphismRestrict_ι_image_ι_isoImage_inv | Mathlib.AlgebraicGeometry.Restrict | ∀ {X Y : AlgebraicGeometry.Scheme} (f : X ⟶ Y) (U : Y.Opens) (V : (↑U).Opens),
CategoryTheory.CategoryStruct.comp (f ∣_ (AlgebraicGeometry.Scheme.Hom.opensFunctor U.ι).obj V)
(AlgebraicGeometry.Scheme.Hom.isoImage U.ι V).inv =
CategoryTheory.CategoryStruct.comp
(CategoryTheory.CategoryStruct.comp (X.h... | null | true |
_private.Mathlib.Tactic.NormNum.Ineq.0.Mathlib.Meta.NormNum.evalLT.core.nnratArm._proof_1 | Mathlib.Tactic.NormNum.Ineq | ∀ {u : Lean.Level} {α : Q(Type u)} (lα : Q(LT «$α»)) (fst : Q(LinearOrder «$α»)),
«$lα» =Q instDistribLatticeOfLinearOrder.toSemilatticeInf.toLT | null | false |
Lean.Meta.RefinedDiscrTree.PreDiscrTree.toRefinedDiscrTree | Mathlib.Lean.Meta.RefinedDiscrTree.Initialize | {α : Type} → Lean.Meta.RefinedDiscrTree.PreDiscrTree α → Lean.Meta.RefinedDiscrTree α | Convert a `PreDiscrTree` to a `RefinedDiscrTree`. | true |
_private.Mathlib.Probability.Distributions.Gaussian.HasGaussianLaw.Independence.0.ContinuousLinearMap.diagonalStrongDualPi._proof_10 | Mathlib.Probability.Distributions.Gaussian.HasGaussianLaw.Independence | SMulCommClass ℝ ℝ ℝ | null | false |
Tactic.ComputeAsymptotics.UnitMonomial.inv | Mathlib.Tactic.ComputeAsymptotics.Multiseries.Monomial.Basic | Tactic.ComputeAsymptotics.UnitMonomial → Tactic.ComputeAsymptotics.UnitMonomial | Inversion of a unit monomial. | true |
TopCat.GlueData.ι_fromOpenSubsetsGlue | Mathlib.Topology.Gluing | ∀ {α : Type u} [inst : TopologicalSpace α] {J : Type u} (U : J → TopologicalSpace.Opens α) (i : J),
CategoryTheory.CategoryStruct.comp ((TopCat.GlueData.ofOpenSubsets U).ι i) (TopCat.GlueData.fromOpenSubsetsGlue U) =
(U i).inclusion' | null | true |
CategoryTheory.Triangulated.Octahedron.mem | Mathlib.CategoryTheory.Triangulated.Triangulated | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Preadditive C]
[inst_2 : CategoryTheory.Limits.HasZeroObject C] [inst_3 : CategoryTheory.HasShift C ℤ]
[inst_4 : ∀ (n : ℤ), (CategoryTheory.shiftFunctor C n).Additive] [inst_5 : CategoryTheory.Pretriangulated C]
{X₁ X₂ X₃ Z₁₂ ... | null | true |
StarAlgHom.fst_apply | Mathlib.Algebra.Star.StarAlgHom | ∀ (R : Type u_1) (A : Type u_2) (B : Type u_3) [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A]
[inst_3 : Star A] [inst_4 : Semiring B] [inst_5 : Algebra R B] [inst_6 : Star B] (self : A × B),
(StarAlgHom.fst R A B) self = self.1 | null | true |
WithVal.congr_trans | Mathlib.Topology.Algebra.Valued.WithVal | ∀ {R : Type u_1} {Γ₀ : Type u_2} [inst : LinearOrderedCommGroupWithZero Γ₀] [inst_1 : Ring R] (v : Valuation R Γ₀)
{S : Type u_3} [inst_2 : Ring S] {Λ₀ : Type u_4} [inst_3 : LinearOrderedCommGroupWithZero Λ₀] (w : Valuation S Λ₀)
{T : Type u_5} [inst_4 : Ring T] (u : Valuation T Γ₀) (f : R ≃+* S) (g : S ≃+* T),
W... | null | true |
ArchimedeanClass.addSubgroup_eq_bot | Mathlib.Algebra.Order.Archimedean.Class | ∀ (M : Type u_1) [inst : AddCommGroup M] [inst_1 : LinearOrder M] [inst_2 : IsOrderedAddMonoid M],
ArchimedeanClass.addSubgroup ⊤ = ⊥ | null | true |
Vector.eraseIdx_set_lt._proof_2 | Init.Data.Vector.Erase | ∀ {n i : ℕ} {w : i < n} {j : ℕ}, j < i → i - 1 < n - 1 | null | false |
PowerSeries.invOneSubPow.eq_2 | Mathlib.RingTheory.PowerSeries.WellKnown | ∀ (S : Type u_1) [inst : CommRing S] (d : ℕ),
PowerSeries.invOneSubPow S d.succ =
{ val := PowerSeries.mk fun n => ↑((d + n).choose d), inv := (1 - PowerSeries.X) ^ (d + 1), val_inv := ⋯,
inv_val := ⋯ } | null | true |
NumberField.mixedEmbedding.polarCoordReal | Mathlib.NumberTheory.NumberField.CanonicalEmbedding.PolarCoord | (K : Type u_1) →
[inst : Field K] →
[NumberField K] →
OpenPartialHomeomorph (NumberField.mixedEmbedding.realMixedSpace K) (NumberField.mixedEmbedding.realMixedSpace K) | The polar coordinate open partial homeomorphism of `ℝ^r₁ × (ℝ × ℝ)^r₂` defined as the identity on
the first component and mapping `(rᵢ cos θᵢ, rᵢ sin θᵢ)ᵢ` to `(rᵢ, θᵢ)ᵢ` on the second component.
| true |
Homeomorph.toEquiv_piCongr | Mathlib.Topology.Homeomorph.Lemmas | ∀ {ι₁ : Type u_5} {ι₂ : Type u_6} {Y₁ : ι₁ → Type u_7} {Y₂ : ι₂ → Type u_8}
[inst : (i₁ : ι₁) → TopologicalSpace (Y₁ i₁)] [inst_1 : (i₂ : ι₂) → TopologicalSpace (Y₂ i₂)] (e : ι₁ ≃ ι₂)
(F : (i₁ : ι₁) → Y₁ i₁ ≃ₜ Y₂ (e i₁)),
(Homeomorph.piCongr e F).toEquiv = (Equiv.piCongrRight fun i => (F i).toEquiv).trans (Equiv.... | null | true |
_private.Mathlib.Combinatorics.Enumerative.DyckWord.0.DyckWord.firstReturn_lt_length._proof_1_2 | Mathlib.Combinatorics.Enumerative.DyckWord | ∀ {p : DyckWord}, 0 < (↑p).length → (↑p).length - 1 < (↑p).length | null | false |
_private.Mathlib.Combinatorics.SimpleGraph.Regularity.Uniform.0.SimpleGraph.unreduced_edges_subset._simp_1_6 | Mathlib.Combinatorics.SimpleGraph.Regularity.Uniform | ∀ {α : Type u_1} [inst : DecidableEq α] {s t : Finset α} {a : α}, (a ∈ s ∪ t) = (a ∈ s ∨ a ∈ t) | null | false |
Std.ExtDTreeMap.minKey!_insert_le_self | Std.Data.ExtDTreeMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t : Std.ExtDTreeMap α β cmp} [inst : Std.TransCmp cmp]
[inst_1 : Inhabited α] {k : α} {v : β k}, (cmp (t.insert k v).minKey! k).isLE = true | null | true |
Lean.Lsp.SemanticTokenModifier.declaration.elim | Lean.Data.Lsp.LanguageFeatures | {motive : Lean.Lsp.SemanticTokenModifier → Sort u} →
(t : Lean.Lsp.SemanticTokenModifier) → t.ctorIdx = 0 → motive Lean.Lsp.SemanticTokenModifier.declaration → motive t | null | false |
Algebra.zariskisMainProperty_iff_exists_saturation_eq_top._proof_2 | Mathlib.RingTheory.ZariskisMainTheorem | ∀ {R : Type u_2} {S : Type u_1} [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S] (r : S),
IsIntegral R r → Submonoid.powers r ≤ (integralClosure R S).toSubmonoid | null | false |
Fin.rev_sub | Mathlib.Algebra.Group.Fin.Basic | ∀ {n : ℕ} (a b : Fin n), (a - b).rev = a.rev + b | null | true |
Finset.sum_eq_zero | Mathlib.Algebra.BigOperators.Group.Finset.Basic | ∀ {ι : Type u_1} {M : Type u_4} {s : Finset ι} [inst : AddCommMonoid M] {f : ι → M},
(∀ x ∈ s, f x = 0) → ∑ x ∈ s, f x = 0 | null | true |
Nat.cast_mem_Iic_iff | Mathlib.Order.Interval.Finset.Floor | ∀ {α : Type u_1} [inst : Semiring α] [inst_1 : LinearOrder α] [inst_2 : FloorSemiring α] {b : α} {n : ℕ},
0 ≤ b → (↑n ∈ Set.Iic b ↔ n ∈ Finset.Iic ⌊b⌋₊) | null | true |
TopModuleCat.withModuleTopologyAdj._proof_1 | Mathlib.Algebra.Category.ModuleCat.Topology.Basic | ∀ (R : Type u_2) [inst : Ring R] [inst_1 : TopologicalSpace R] ⦃X Y : TopModuleCat R⦄ (f : X ⟶ Y),
CategoryTheory.CategoryStruct.comp
(((CategoryTheory.forget₂ (TopModuleCat R) (ModuleCat R)).comp (TopModuleCat.withModuleTopology R)).map f)
(TopModuleCat.ofHom { toLinearMap := LinearMap.id, cont := ⋯ }) =... | null | false |
_private.Mathlib.AlgebraicTopology.SimplexCategory.GeneratorsRelations.NormalForms.0.SimplexCategoryGenRel.IsAdmissible.cons._proof_1_3 | Mathlib.AlgebraicTopology.SimplexCategory.GeneratorsRelations.NormalForms | ∀ (head : ℕ) (tail : List ℕ), 1 ≤ (head :: tail).length → 0 < (head :: tail).length | null | false |
isOpen.dynEntourage | Mathlib.Dynamics.TopologicalEntropy.DynamicalEntourage | ∀ {X : Type u_1} {U : SetRel X X} [inst : TopologicalSpace X] {T : X → X},
Continuous T → IsOpen U → ∀ (n : ℕ), IsOpen (Dynamics.dynEntourage T U n) | null | true |
_private.Lean.Elab.MutualInductive.0.Lean.Elab.Command.ResultingUniverseResult.u | Lean.Elab.MutualInductive | Lean.Elab.Command.ResultingUniverseResult✝ → Lean.Level | Inferred resulting universe | true |
RKHS.ext | Mathlib.Analysis.InnerProductSpace.Reproducing | ∀ {𝕜 : Type u_1} [inst : RCLike 𝕜] {X : Type u_2} {V : Type u_3} [inst_1 : NormedAddCommGroup V]
[inst_2 : InnerProductSpace 𝕜 V] {H : Type u_4} [inst_3 : NormedAddCommGroup H] [inst_4 : InnerProductSpace 𝕜 H]
[inst_5 : RKHS 𝕜 H X V] {f g : H}, (∀ (x : X), f x = g x) → f = g | null | true |
_private.Mathlib.Data.List.PeriodicityLemma.0.List.HasPeriod.drop_of_hasPeriod_add._proof_1_27 | Mathlib.Data.List.PeriodicityLemma | ∀ {α : Type u_1} {q k : ℕ} {w : List α} (i : ℕ), 6 * q + 6 * k + i + 1 ≤ w.length → 6 * q + 6 * k + i < w.length | null | false |
ContinuousLinearMap | Mathlib.Topology.Algebra.Module.ContinuousLinearMap.Basic | {R : Type u_1} →
{S : Type u_2} →
[inst : Semiring R] →
[inst_1 : Semiring S] →
(R →+* S) →
(M : Type u_3) →
[TopologicalSpace M] →
[inst_3 : AddCommMonoid M] →
(M₂ : Type u_4) →
[TopologicalSpace M₂] →
[inst_5... | Continuous linear maps between modules. We only put the type classes that are necessary for the
definition, although in applications `M` and `M₂` will be topological modules over the topological
ring `R`. | true |
SheafOfModules.instIsLeftAdjointOverOverRingCatPushforwardIdSheafOver | Mathlib.Algebra.Category.ModuleCat.Sheaf.PushforwardContinuous | ∀ {C : Type u'} [inst : CategoryTheory.Category.{v', u'} C] [CategoryTheory.Limits.HasBinaryProducts C]
{J : CategoryTheory.GrothendieckTopology C} {R : CategoryTheory.Sheaf J RingCat} (x : C),
(SheafOfModules.pushforward (CategoryTheory.CategoryStruct.id (R.over x))).IsLeftAdjoint | null | true |
Relation.ReflGen.mono | Mathlib.Logic.Relation | ∀ {α : Type u_1} {r p : α → α → Prop}, r ≤ p → Relation.ReflGen r ≤ Relation.ReflGen p | null | true |
AddSubgroup.map_injective | Mathlib.Algebra.Group.Subgroup.Ker | ∀ {G : Type u_1} [inst : AddGroup G] {N : Type u_4} [inst_1 : AddGroup N] {f : G →+ N},
Function.Injective ⇑f → Function.Injective (AddSubgroup.map f) | null | true |
MonoidHom.toHomPerm_apply_symm_apply | Mathlib.Algebra.Group.End | ∀ {α : Type u_4} {G : Type u_7} [inst : Group G] (f : G →* Function.End α) (x : G),
⇑(Equiv.symm (f.toHomPerm x)) = ↑(f.toHomUnits x)⁻¹ | null | true |
Lean.Grind.CommRing.Expr.pow.inj | Init.Grind.Ring.CommSolver | ∀ {a : Lean.Grind.CommRing.Expr} {k : ℕ} {a_1 : Lean.Grind.CommRing.Expr} {k_1 : ℕ},
a.pow k = a_1.pow k_1 → a = a_1 ∧ k = k_1 | null | true |
PresheafOfModules.toPresheaf._proof_3 | Mathlib.Algebra.Category.ModuleCat.Presheaf | ∀ {C : Type u_3} [inst : CategoryTheory.Category.{u_2, u_3} C] (R : CategoryTheory.Functor Cᵒᵖ RingCat)
(X : PresheafOfModules R),
{
app := fun X_1 =>
AddCommGrpCat.ofHom
(AddMonoidHom.mk' ⇑(CategoryTheory.ConcreteCategory.hom ((CategoryTheory.CategoryStruct.id X).app X_1)) ⋯),
natural... | null | false |
Rat.den_intFract | Mathlib.Data.Rat.Floor | ∀ (x : ℚ), (Int.fract x).den = x.den | null | true |
CategoryTheory.ObjectProperty.IsStrongTriangulatedGenerator | Mathlib.CategoryTheory.Triangulated.Generators | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
[inst_1 : CategoryTheory.Limits.HasZeroObject C] →
[inst_2 : CategoryTheory.HasShift C ℤ] →
[inst_3 : CategoryTheory.Preadditive C] →
[inst_4 : ∀ (n : ℤ), (CategoryTheory.shiftFunctor C n).Additive] →
[CategoryThe... | An object property `P` is called a strong triangulated generator, if every object
can be reached from objects in `P` by shifts, binary products, retracts and at most `n`
extensions, for some fixed `n`. | true |
CategoryTheory.MonadHom.app_μ_assoc | Mathlib.CategoryTheory.Monad.Basic | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {T₁ T₂ : CategoryTheory.Monad C}
(self : CategoryTheory.MonadHom T₁ T₂) (X : C) {Z : C} (h : T₂.obj X ⟶ Z),
CategoryTheory.CategoryStruct.comp (T₁.μ.app X) (CategoryTheory.CategoryStruct.comp (self.app X) h) =
CategoryTheory.CategoryStruct.comp (T₁.map... | null | true |
SimpleGraph.isBipartiteWith_bipartiteDoubleCover | Mathlib.Combinatorics.SimpleGraph.Bipartite | ∀ {V : Type u_1} {G : SimpleGraph V},
G.bipartiteDoubleCover.IsBipartiteWith {v | v.isLeft = true} {w | w.isRight = true} | null | true |
OrderHom.instIsOneApplyEqSelf | Mathlib.Algebra.Order.Group.End | ∀ {α : Type u_1} [inst : Preorder α], IsOneApplyEqSelf (α →o α) α | null | true |
_private.Mathlib.MeasureTheory.Measure.Map.0.MeasurableEquiv.map_ae._simp_1_1 | Mathlib.MeasureTheory.Measure.Map | ∀ {α : Type u_1} {β : Type u_2} {f : Filter α} {m : α → β} {t : Set β}, (t ∈ Filter.map m f) = (m ⁻¹' t ∈ f) | null | false |
Lean.Widget.GetWidgetSourceParams.mk.injEq | Lean.Widget.UserWidget | ∀ (hash : UInt64) (pos : Lean.Lsp.Position) (hash_1 : UInt64) (pos_1 : Lean.Lsp.Position),
({ hash := hash, pos := pos } = { hash := hash_1, pos := pos_1 }) = (hash = hash_1 ∧ pos = pos_1) | null | true |
MeasurableEmbedding.schroederBernstein._proof_3 | Mathlib.MeasureTheory.MeasurableSpace.Embedding | ∀ {α : Type u_1} {β : Type u_2} {f : α → β} {g : β → α} (A : Set α),
(fun A => (g '' (f '' A)ᶜ)ᶜ) A = A → Aᶜ = g '' (f '' A)ᶜ | null | false |
Rep.coindResAdjunction_counit_app | Mathlib.RepresentationTheory.FiniteIndex | ∀ {k : Type u} {G : Type v} [inst : CommRing k] [inst_1 : Group G] {S : Subgroup G}
[inst_2 : DecidableRel ⇑(QuotientGroup.rightRel S)] [inst_3 : S.FiniteIndex] (B : Rep.{max w u v, u, v} k G),
(Rep.coindResAdjunction k S).counit.app B =
CategoryTheory.CategoryStruct.comp (Rep.res S.subtype B).indCoindIso.inv
... | null | true |
CochainComplex.ConnectData.d_sub_one_zero | Mathlib.Algebra.Homology.Embedding.Connect | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{K : ChainComplex C ℕ} {L : CochainComplex C ℕ} (h : CochainComplex.ConnectData K L), h.d (-1) 0 = h.d₀ | null | true |
IsPreconnected.intermediate_value_Ioc | Mathlib.Topology.Order.IntermediateValue | ∀ {X : Type u} {α : Type v} [inst : TopologicalSpace X] [inst_1 : LinearOrder α] [inst_2 : TopologicalSpace α]
[OrderClosedTopology α] {s : Set X},
IsPreconnected s →
∀ {a : X} {l : Filter X},
a ∈ s →
∀ [l.NeBot],
l ≤ Filter.principal s →
∀ {f : X → α}, ContinuousOn f s → ∀ {... | null | true |
Filter.map_divLeft_nhdsNE | Mathlib.Topology.Algebra.Group.ContinuousDiv | ∀ {G : Type u_1} [inst : Group G] [inst_1 : TopologicalSpace G] [IsTopologicalGroup G] {c a : G},
Filter.map (fun x => c / x) (nhdsWithin a {a}ᶜ) = nhdsWithin (c / a) {c / a}ᶜ | null | true |
Set.injOn_iff_injective | Mathlib.Data.Set.Restrict | ∀ {α : Type u_1} {β : Type u_2} {s : Set α} {f : α → β}, Set.InjOn f s ↔ Function.Injective (s.domRestrict f) | null | true |
Turing.TM2to1.stmtStRec._unsafe_rec | Mathlib.Computability.TuringMachine.StackTuringMachine | {K : Type u_1} →
{Γ : K → Type u_2} →
{Λ : Type u_3} →
{σ : Type u_4} →
{motive : Turing.TM2.Stmt Γ Λ σ → Sort l} →
((k : K) →
(s : Turing.TM2to1.StAct K Γ σ k) →
(q : Turing.TM2.Stmt Γ Λ σ) → motive q → motive (Turing.TM2to1.stRun s q)) →
((a : σ ... | null | false |
FreeAddMonoid.length_surjective | Mathlib.Algebra.FreeMonoid.Basic | ∀ {α : Type u_1} [Nonempty α], Function.Surjective FreeAddMonoid.length | null | true |
CategoryTheory.Grp.Hom.hom_hom_div | Mathlib.CategoryTheory.Monoidal.Cartesian.Grp | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.CartesianMonoidalCategory C]
[inst_2 : CategoryTheory.BraidedCategory C] {G H : CategoryTheory.Grp C} [inst_3 : CategoryTheory.IsCommMonObj H.X]
(f g : G ⟶ H), (f / g).hom.hom = f.hom.hom / g.hom.hom | null | true |
Lean.Doc.MarkdownInline.mk | Lean.DocString.Markdown | {i : Type u} →
((Lean.Doc.Inline i → Lean.Doc.MarkdownM (Array String)) →
i → Array (Lean.Doc.Inline i) → Lean.Doc.MarkdownM (Array String)) →
Lean.Doc.MarkdownInline i | null | true |
Lean.Linter.LinterOptions.noConfusionType | Lean.Linter.Init | Sort u → Lean.Linter.LinterOptions → Lean.Linter.LinterOptions → Sort u | null | false |
CategoryTheory.Pretriangulated.shortComplexOfDistTriangleIsoOfIso._proof_3 | Mathlib.CategoryTheory.Triangulated.Pretriangulated | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Limits.HasZeroObject C]
[inst_2 : CategoryTheory.HasShift C ℤ] [inst_3 : CategoryTheory.Preadditive C]
[inst_4 : ∀ (n : ℤ), (CategoryTheory.shiftFunctor C n).Additive] [hC : CategoryTheory.Pretriangulated C]
{T T' : CategoryTh... | null | false |
SubalgebraClass.toAlgebra._proof_1 | Mathlib.Algebra.Algebra.Subalgebra.Basic | ∀ {S : Type u_2} {R : Type u_3} {A : Type u_1} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A]
[inst_3 : SetLike S A] [inst_4 : SubsemiringClass S A] [hSR : SMulMemClass S R A] (s : S),
↑⟨(algebraMap R A) 1, ⋯⟩ = ↑1 | null | false |
ContinuousSqrt.mk.noConfusion | Mathlib.Topology.ContinuousMap.StarOrdered | {R : Type u_1} →
{inst : LE R} →
{inst_1 : NonUnitalSemiring R} →
{inst_2 : TopologicalSpace R} →
{P : Sort u} →
{sqrt : R × R → R} →
{continuousOn_sqrt : ContinuousOn sqrt {x | x.1 ≤ x.2}} →
{sqrt_nonneg : ∀ (x : R × R), x.1 ≤ x.2 → 0 ≤ sqrt x} →
... | null | false |
Nat.Primes.prodNatEquiv_apply | Mathlib.Data.Nat.Factorization.PrimePow | ∀ (p : Nat.Primes) (k : ℕ), Nat.Primes.prodNatEquiv (p, k) = ⟨↑p ^ (k + 1), ⋯⟩ | null | true |
FiniteField.X_pow_card_sub_X_natDegree_eq | Mathlib.FieldTheory.Finite.Basic | ∀ (K' : Type u_3) [inst : Field K'] {p : ℕ}, 1 < p → (Polynomial.X ^ p - Polynomial.X).natDegree = p | null | true |
Lean.Meta.EtaStructMode | Init.MetaTypes | Type | Which structure types should eta be used with? | true |
nonzero_span_atom | Mathlib.LinearAlgebra.Basis.VectorSpace | ∀ {K : Type u_3} {V : Type u_4} [inst : DivisionRing K] [inst_1 : AddCommGroup V] [inst_2 : Module K V] (v : V),
v ≠ 0 → IsAtom (K ∙ v) | For a module over a division ring, the span of a nonzero element is an atom of the
lattice of submodules. | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.