name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
OpenPartialHomeomorph.pi._proof_4 | Mathlib.Topology.OpenPartialHomeomorph.Constructions | ∀ {ι : Type u_2} [Finite ι] {X : ι → Type u_3} {Y : ι → Type u_1} [inst : (i : ι) → TopologicalSpace (X i)]
[inst_1 : (i : ι) → TopologicalSpace (Y i)] (ei : (i : ι) → OpenPartialHomeomorph (X i) (Y i)),
IsOpen (Set.univ.pi fun i => (ei i).target) | null | false |
Lean.PrettyPrinter.Delaborator.appUnexpanderAttribute | Lean.PrettyPrinter.Delaborator.Basic | Lean.KeyedDeclsAttribute Lean.PrettyPrinter.Unexpander | Registers an unexpander for applications of a given constant.
`@[app_unexpander c]` registers a `Lean.PrettyPrinter.Unexpander` for applications of the constant
`c`. The unexpander is passed the result of pre-pretty printing the application *without*
implicitly passed arguments. If `pp.explicit` is set to true or `pp.... | true |
MonoidAlgebra.mul_apply_left | Mathlib.Algebra.MonoidAlgebra.Defs | ∀ {R : Type u_1} {G : Type u_3} [inst : Semiring R] [inst_1 : Group G] (x y : MonoidAlgebra R G) (g : G),
(x * y).coeff g = x.coeff.sum fun h r => r * y.coeff (h⁻¹ * g) | **Alias** of `MonoidAlgebra.coeff_mul_apply_left`. | true |
TensorProduct.tensorQuotEquivQuotSMul_symm_mk | Mathlib.LinearAlgebra.TensorProduct.Quotient | ∀ {R : Type u_1} {M : Type u_2} [inst : CommRing R] [inst_1 : AddCommGroup M] [inst_2 : Module R M] (I : Ideal R)
(x : M), (TensorProduct.tensorQuotEquivQuotSMul M I).symm (Submodule.Quotient.mk x) = x ⊗ₜ[R] 1 | null | true |
Bornology.IsCobounded.superset | Mathlib.Topology.Bornology.Basic | ∀ {α : Type u_2} {x : Bornology α} {s t : Set α}, Bornology.IsCobounded s → s ⊆ t → Bornology.IsCobounded t | null | true |
_private.Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Basic.0.CStarAlgebra.spectralOrder._simp_1 | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Basic | ∀ (R : Type u_1) [inst : AddMonoid R] [inst_1 : StarAddMonoid R], IsSelfAdjoint 0 = True | null | false |
HomologicalComplex.cylinder.mapHomologicalComplexObjIso.congr_simp | Mathlib.Algebra.Homology.HomotopyCofiber | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Preadditive C] {ι : Type u_2}
{c : ComplexShape ι} (F : HomologicalComplex C c) [inst_2 : DecidableRel c.Rel] {D : Type u_3}
[inst_3 : CategoryTheory.Category.{v_2, u_3} D] [inst_4 : CategoryTheory.Preadditive D]
(H : Category... | null | true |
Sigma._sizeOf_inst._@.Mathlib.Util.CompileInductive.4222055393._hygCtx._hyg.9 | Mathlib.Util.CompileInductive | {α : Type u} → (β : α → Type v) → [SizeOf α] → [(a : α) → SizeOf (β a)] → SizeOf (Sigma β) | null | false |
CategoryTheory.Abelian.SpectralObject.dHomologyData._auto_1 | Mathlib.Algebra.Homology.SpectralObject.Homology | Lean.Syntax | null | false |
_private.Mathlib.CategoryTheory.ObjectProperty.Basic.0.CategoryTheory.ObjectProperty.singleton_le_iff._simp_1_1 | Mathlib.CategoryTheory.ObjectProperty.Basic | ∀ {C : Type u} [inst : CategoryTheory.CategoryStruct.{v, u} C] {ι : Type u'} (X : ι → C)
(P : CategoryTheory.ObjectProperty C), (CategoryTheory.ObjectProperty.ofObj X ≤ P) = ∀ (i : ι), P (X i) | null | false |
Multiset.sort_range | Mathlib.Data.Multiset.Sort | ∀ (n : ℕ), ((Multiset.range n).sort fun a b => a ≤ b) = List.range n | null | true |
_private.Mathlib.RingTheory.Coalgebra.TensorProduct.0.Coalgebra._aux_Mathlib_RingTheory_Coalgebra_TensorProduct___macroRules__private_Mathlib_RingTheory_Coalgebra_TensorProduct_0_Coalgebra_termμ_1 | Mathlib.RingTheory.Coalgebra.TensorProduct | Lean.Macro | null | false |
Lean.Grind.CommRing.Poly.recOn | Init.Grind.Ring.CommSolver | {motive : Lean.Grind.CommRing.Poly → Sort u} →
(t : Lean.Grind.CommRing.Poly) →
((k : ℤ) → motive (Lean.Grind.CommRing.Poly.num k)) →
((k : ℤ) →
(v : Lean.Grind.CommRing.Mon) →
(p : Lean.Grind.CommRing.Poly) → motive p → motive (Lean.Grind.CommRing.Poly.add k v p)) →
motive t | null | false |
_private.Lean.Compiler.LCNF.MonoTypes.0.Lean.Compiler.LCNF.trivialStructureInfoExt | Lean.Compiler.LCNF.MonoTypes | Lean.MapDeclarationExtension (Option Lean.Compiler.LCNF.TrivialStructureInfo) | null | true |
AlgebraicIndependent.option_iff_transcendental | Mathlib.RingTheory.AlgebraicIndependent.Transcendental | ∀ {ι : Type u_1} {R : Type u_3} {A : Type v} {x : ι → A} [inst : CommRing R] [inst_1 : CommRing A]
[inst_2 : Algebra R A],
AlgebraicIndependent R x →
∀ (a : A), (AlgebraicIndependent R fun o => o.elim a x) ↔ Transcendental (↥(Algebra.adjoin R (Set.range x))) a | null | true |
mabs_div | Mathlib.Algebra.Order.Group.Abs | ∀ {G : Type u_1} [inst : CommGroup G] [inst_1 : LinearOrder G] [IsOrderedMonoid G] (a b : G), |a / b|ₘ ≤ |a|ₘ * |b|ₘ | null | true |
MvPolynomial.sumToIter_iterToSum | Mathlib.Algebra.MvPolynomial.Equiv | ∀ {R : Type u_4} {S : Type u_5} [inst : Mul R] [inst_1 : Mul S] [inst_2 : Add R] [inst_3 : Add S] (e : R ≃+* S) (x : S),
e (e.symm x) = x | **Alias** of `RingEquiv.apply_symm_apply`. | true |
Lean.Omega.Int.ofNat_natAbs | Init.Omega.Int | ∀ (a : ℤ), ↑a.natAbs = if 0 ≤ a then a else -a | null | true |
CategoryTheory.LocalizerMorphism.RightResolution.unopFunctor._proof_3 | Mathlib.CategoryTheory.Localization.Resolution | ∀ {C₁ : Type u_4} {C₂ : Type u_2} [inst : CategoryTheory.Category.{u_3, u_4} C₁]
[inst_1 : CategoryTheory.Category.{u_1, u_2} C₂] {W₁ : CategoryTheory.MorphismProperty C₁}
{W₂ : CategoryTheory.MorphismProperty C₂} (Φ : CategoryTheory.LocalizerMorphism W₁ W₂) (X₂ : C₂ᵒᵖ)
{X Y : (Φ.op.RightResolution X₂)ᵒᵖ} (φ : X ... | null | false |
Opposite.unop_injective | Mathlib.Basic.Opposite | ∀ {α : Sort u}, Function.Injective Opposite.unop | null | true |
LinearIsometryEquiv.smul_apply | Mathlib.Analysis.RCLike.Basic | ∀ {𝕜 : Type u_3} {V : Type u_4} {W : Type u_5} [inst : RCLike 𝕜] [inst_1 : SeminormedAddCommGroup V]
[inst_2 : Module 𝕜 V] [inst_3 : SeminormedAddCommGroup W] [inst_4 : NormedSpace 𝕜 W] (e : V ≃ₗᵢ[𝕜] W)
(α : ↥(unitary 𝕜)) (x : V), (α • e) x = ↑α • e x | null | true |
MulArchimedean.rec | Mathlib.Algebra.Order.Archimedean.Defs | {R : Type u_2} →
[inst : CommMonoid R] →
[inst_1 : PartialOrder R] →
{motive : MulArchimedean R → Sort u} →
((arch : ∀ (x : R) {y : R}, 1 < y → ∃ n, x ≤ y ^ n) → motive ⋯) → (t : MulArchimedean R) → motive t | null | false |
Lean.Elab.Tactic.ElimTargetView.casesOn | Lean.Elab.Tactic.Induction | {motive : Lean.Elab.Tactic.ElimTargetView → Sort u} →
(t : Lean.Elab.Tactic.ElimTargetView) →
((hIdent? : Option Lean.Ident) → (term : Lean.Syntax) → motive { hIdent? := hIdent?, term := term }) → motive t | null | false |
AddOreLocalization.universalAddHom.eq_1 | Mathlib.GroupTheory.OreLocalization.Basic | ∀ {R : Type u_1} [inst : AddMonoid R] {S : AddSubmonoid R} [inst_1 : AddOreLocalization.AddOreSet S] {T : Type u_2}
[inst_2 : AddMonoid T] (f : R →+ T) (fS : ↥S →+ AddUnits T) (hf : ∀ (s : ↥S), f ↑s = ↑(fS s)),
AddOreLocalization.universalAddHom f fS hf =
{ toFun := fun x => AddOreLocalization.liftExpand (fun r... | null | true |
ContinuousAddMonoidHom.toContinuousMap_toContinuousAddMonoidHom | Mathlib.Topology.Algebra.ContinuousMonoidHom | ∀ {A : Type u_2} {B : Type u_3} [inst : AddMonoid A] [inst_1 : AddMonoid B] [inst_2 : TopologicalSpace A]
[inst_3 : TopologicalSpace B] {F : Type u_7} [inst_4 : FunLike F A B] [inst_5 : AddMonoidHomClass F A B]
[inst_6 : ContinuousMapClass F A B] (f : F), ↑↑f = ↑f | null | true |
MeasureTheory.Lp.instFourierPairInv | Mathlib.Analysis.Fourier.LpSpace | ∀ {E : Type u_1} {F : Type u_2} [inst : NormedAddCommGroup E] [inst_1 : MeasurableSpace E] [inst_2 : BorelSpace E]
[inst_3 : NormedAddCommGroup F] [inst_4 : InnerProductSpace ℂ F] [inst_5 : CompleteSpace F]
[inst_6 : InnerProductSpace ℝ E] [inst_7 : FiniteDimensional ℝ E],
FourierInvPair ↥(MeasureTheory.Lp F 2 Me... | null | true |
Filter.liminf_eq_sSup_sInf | Mathlib.Order.LiminfLimsup | ∀ {ι : Type u_6} {R : Type u_7} (F : Filter ι) [inst : CompleteLattice R] (a : ι → R),
Filter.liminf a F = sSup ((fun I => sInf (a '' I)) '' F.sets) | null | true |
Std.TreeSet.Raw.mem_of_mem_insertMany_list | Std.Data.TreeSet.Raw.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t : Std.TreeSet.Raw α cmp} [Std.TransCmp cmp] [inst : BEq α]
[Std.LawfulBEqCmp cmp], t.WF → ∀ {l : List α} {k : α}, l.contains k = false → k ∈ t.insertMany l → k ∈ t | null | true |
WeierstrassCurve.Affine.baseChange_equation | Mathlib.AlgebraicGeometry.EllipticCurve.Affine.Basic | ∀ {R : Type r} [inst : CommRing R] (W : WeierstrassCurve.Affine R) {S : Type s} [inst_1 : CommRing S] {A : Type u}
[inst_2 : CommRing A] {B : Type v} [inst_3 : CommRing B] [inst_4 : Algebra R S] [inst_5 : Algebra R A]
[inst_6 : Algebra S A] [IsScalarTower R S A] [inst_8 : Algebra R B] [inst_9 : Algebra S B] [IsScal... | null | true |
_private.Mathlib.Tactic.DuplicateDecls.0.Mathlib.Tactic.DuplicateDecls.duplicateDeclarations.match_4 | Mathlib.Tactic.DuplicateDecls | (motive : Option Lean.Name → Sort u_1) →
(x : Option Lean.Name) → ((name' : Lean.Name) → motive (some name')) → ((x : Option Lean.Name) → motive x) → motive x | null | false |
List.instLawfulBEqCmpCompareLex | Init.Data.Order.Ord | ∀ {α : Type u_1} {cmp : α → α → Ordering} [inst : BEq α] [Std.LawfulBEqCmp cmp], Std.LawfulBEqCmp (List.compareLex cmp) | null | true |
_private.Mathlib.LinearAlgebra.Matrix.Stochastic.0.Matrix.colStochastic._proof_1 | Mathlib.LinearAlgebra.Matrix.Stochastic | ∀ (R : Type u_2) (n : Type u_1) [inst : Fintype n] [inst_1 : Semiring R] [inst_2 : PartialOrder R] [IsOrderedRing R]
{M N : Matrix n n R},
M ∈ {M | (∀ (i j : n), 0 ≤ M i j) ∧ Matrix.vecMul 1 M = 1} →
N ∈ {M | (∀ (i j : n), 0 ≤ M i j) ∧ Matrix.vecMul 1 M = 1} →
∀ (i j i_1 : n), i_1 ∈ Finset.univ → 0 ≤ M i ... | null | false |
_private.Mathlib.MeasureTheory.Function.L1Space.HasFiniteIntegral.0.MeasureTheory.HasFiniteIntegral.norm._simp_1_1 | Mathlib.MeasureTheory.Function.L1Space.HasFiniteIntegral | ∀ {α : Type u_1} {ε : Type u_4} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} [inst : ENorm ε] {f : α → ε},
MeasureTheory.HasFiniteIntegral f μ = (∫⁻ (a : α), ‖f a‖ₑ ∂μ < ⊤) | null | false |
HahnSeries.toPowerSeries_symm_apply_coeff | Mathlib.RingTheory.HahnSeries.PowerSeries | ∀ {R : Type u_2} [inst : Semiring R] (f : PowerSeries R) (n : ℕ),
(HahnSeries.toPowerSeries.symm f).coeff n = (PowerSeries.coeff n) f | null | true |
SimpleGraph.ConnectedComponent.lift | Mathlib.Combinatorics.SimpleGraph.Connectivity.Connected | {V : Type u} →
{G : SimpleGraph V} →
{β : Sort u_1} → (f : V → β) → (∀ (v w : V) (p : G.Walk v w), p.IsPath → f v = f w) → G.ConnectedComponent → β | The `ConnectedComponent` specialization of `Quot.lift`. Provides the stronger
assumption that the vertices are connected by a path. | true |
CategoryTheory.Equivalence.symmEquivInverse_obj_inverse | Mathlib.CategoryTheory.Equivalence.Symmetry | ∀ (C : Type u_1) [inst : CategoryTheory.Category.{v_1, u_1} C] (D : Type u_2)
[inst_1 : CategoryTheory.Category.{v_2, u_2} D] (X : (D ≌ C)ᵒᵖ),
((CategoryTheory.Equivalence.symmEquivInverse C D).obj X).inverse = (Opposite.unop X).functor | null | true |
LinearMap.toMatrix₂._proof_6 | Mathlib.LinearAlgebra.Matrix.SesquilinearForm | ∀ {R : Type u_1} [inst : CommSemiring R] {σ₁ : R →+* R}, RingHomCompTriple (RingHom.id R) σ₁ σ₁ | null | false |
Set.symmDiff_subset_union | Mathlib.Data.Set.SymmDiff | ∀ {α : Type u} {s t : Set α}, symmDiff s t ⊆ s ∪ t | null | true |
Std.WP.Spec.Iter.forIn_filter | Std.WP.Triple.SpecLemmas | ∀ {α β γ : Type w} {n : Type w → Type w'} {Pred : Type uₚ} {EPred : Type uₑ} [inst : Std.Iterator α Id β]
[inst_1 : Monad n] [inst_2 : Std.WP.Assertion Pred] [inst_3 : Std.WP.Assertion EPred]
[inst_4 : Std.WP.WPMonad n Pred EPred] [Std.Iterators.Finite α Id] [inst_6 : Std.IteratorLoop α Id n]
[Std.LawfulIteratorL... | null | true |
FreeSimplexQuiver.Hom._sizeOf_1 | Mathlib.AlgebraicTopology.SimplexCategory.GeneratorsRelations.Basic | {a a_1 : FreeSimplexQuiver} → a.Hom a_1 → ℕ | null | false |
_private.Mathlib.Tactic.Linter.UnusedInstancesInType.0.Mathlib.Linter.UnusedInstancesInType.collectFVarsOutsideOfProofs._sparseCasesOn_1 | Mathlib.Tactic.Linter.UnusedInstancesInType | {motive : Lean.Expr → Sort u} →
(t : Lean.Expr) →
((fvarId : Lean.FVarId) → motive (Lean.Expr.fvar fvarId)) → (Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t | null | false |
ProofWidgets.GetExprPresentationsParams.casesOn | ProofWidgets.Presentation.Expr | {motive : ProofWidgets.GetExprPresentationsParams → Sort u} →
(t : ProofWidgets.GetExprPresentationsParams) →
((expr : Lean.Server.WithRpcRef ProofWidgets.ExprWithCtx) → motive { expr := expr }) → motive t | null | false |
UpperHemicontinuousWithinAt.of_forall_isOpen | Mathlib.Topology.Semicontinuity.Hemicontinuity | ∀ {α : Type u_1} {β : Type u_2} [inst : TopologicalSpace α] {f : α → Set β} {s : Set α} {x : α}
[inst_1 : TopologicalSpace β],
(∀ (u : Set β), IsOpen u → f x ⊆ u → ∀ᶠ (x' : α) in nhdsWithin x s, f x' ⊆ u) → UpperHemicontinuousWithinAt f s x | **Alias** of the reverse direction of `upperHemicontinuousWithinAt_iff_forall_isOpen`. | true |
MonovaryOn.of_inv_left | Mathlib.Algebra.Order.Monovary | ∀ {ι : Type u_1} {α : Type u_2} {β : Type u_3} [inst : CommGroup α] [inst_1 : Preorder α] [IsOrderedMonoid α]
[inst_3 : PartialOrder β] {s : Set ι} {f : ι → α} {g : ι → β}, MonovaryOn f⁻¹ g s → AntivaryOn f g s | **Alias** of the forward direction of `monovaryOn_inv_left`. | true |
Partrec.map | Mathlib.Computability.Partrec | ∀ {α : Type u_1} {β : Type u_2} {σ : Type u_3} [inst : Primcodable α] [inst_1 : Primcodable β] [inst_2 : Primcodable σ]
{f : α →. β} {g : α → β → σ}, Partrec f → Computable₂ g → Partrec fun a => Part.map (g a) (f a) | null | true |
Std.Iterators.Types.ArrayIterator.pos | Std.Data.Iterators.Producers.Monadic.Array | {α : Type w} → Std.Iterators.Types.ArrayIterator α → ℕ | Internal implementation detail of the iterator library. | true |
Int.ediv_lt_ediv_iff_of_dvd_of_neg_of_pos | Init.Data.Int.DivMod.Lemmas | ∀ {a b c d : ℤ}, b < 0 → 0 < d → b ∣ a → d ∣ c → (a / b < c / d ↔ c * b < d * a) | null | true |
CFC.conjSqrt_ringInverse_conjSqrt._auto_1 | Mathlib.Analysis.SpecialFunctions.ContinuousFunctionalCalculus.Rpow.ConjSqrt | Lean.Syntax | null | false |
Turing.PartrecToTM2.Cont'.cons₁.sizeOf_spec | Mathlib.Computability.TuringMachine.ToPartrec | ∀ (a : Turing.ToPartrec.Code) (a_1 : Turing.PartrecToTM2.Cont'),
sizeOf (Turing.PartrecToTM2.Cont'.cons₁ a a_1) = 1 + sizeOf a + sizeOf a_1 | null | true |
Std.ExtDHashMap.Const.getKey?_insertManyIfNewUnit_list_of_not_mem_of_contains_eq_false | Std.Data.ExtDHashMap.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {m : Std.ExtDHashMap α fun x => Unit} [inst : EquivBEq α]
[inst_1 : LawfulHashable α] {l : List α} {k : α},
k ∉ m → l.contains k = false → (Std.ExtDHashMap.Const.insertManyIfNewUnit m l).getKey? k = none | null | true |
CategoryTheory.Mon.instCreatesLimitsOfSizeForget | Mathlib.CategoryTheory.Monoidal.Internal.Limits | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
[inst_1 : CategoryTheory.MonoidalCategory C] →
CategoryTheory.CreatesLimitsOfSize.{w, u_1, v, v, max u v, u} (CategoryTheory.Mon.forget C) | null | true |
Std.HashSet.Equiv.union_right | Std.Data.HashSet.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {m₁ m₂ m₃ : Std.HashSet α} [EquivBEq α] [LawfulHashable α],
m₂.Equiv m₃ → (m₁ ∪ m₂).Equiv (m₁ ∪ m₃) | null | true |
CategoryTheory.mateEquiv_hcomp | Mathlib.CategoryTheory.Adjunction.Mates | ∀ {A : Type u₁} {B : Type u₂} {C : Type u₃} {D : Type u₄} {E : Type u₅} {F : Type u₆}
[inst : CategoryTheory.Category.{v₁, u₁} A] [inst_1 : CategoryTheory.Category.{v₂, u₂} B]
[inst_2 : CategoryTheory.Category.{v₃, u₃} C] [inst_3 : CategoryTheory.Category.{v₄, u₄} D]
[inst_4 : CategoryTheory.Category.{v₅, u₅} E] ... | The mates equivalence commutes with horizontal composition of squares. | true |
_private.Qq.MatchImpl.0.Lean.Syntax.stripPos.match_1 | Qq.MatchImpl | (motive : Lean.Syntax → Sort u_1) →
(x : Lean.Syntax) →
((info : Lean.SourceInfo) → (a : String) → motive (Lean.Syntax.atom info a)) →
((info : Lean.SourceInfo) →
(r : Substring.Raw) →
(v : Lean.Name) → (p : List Lean.Syntax.Preresolved) → motive (Lean.Syntax.ident info r v p)) →
... | null | false |
SSet.horn₂₁.ι₁₂._proof_1 | Mathlib.AlgebraicTopology.SimplicialSet.HornColimits | 0 ≠ 1 | null | false |
_private.Init.Data.Iterators.Lemmas.Consumers.Loop.0.Std.Iter.mem_toList_iff_isPlausibleIndirectOutput._simp_1_4 | Init.Data.Iterators.Lemmas.Consumers.Loop | ∀ {α β : Type w} [inst : Std.Iterator α Id β] {it' it : Std.Iter β},
it'.IsPlausibleSuccessorOf it = ∃ step, step.successor = some it' ∧ it.IsPlausibleStep step | null | false |
_private.Mathlib.Order.SuccPred.WithBot.0.WithBot.succ_strictMono.match_1_1 | Mathlib.Order.SuccPred.WithBot | ∀ {α : Type u_1} [inst : Preorder α] (motive : (x x_1 : WithBot α) → x < x_1 → Prop) (x x_1 : WithBot α)
(x_2 : x < x_1),
(∀ (b : α) (hab : ⊥ < ↑b), motive none (some b) hab) →
(∀ (a b : α) (hab : ↑a < ↑b), motive (some a) (some b) hab) → motive x x_1 x_2 | null | false |
_private.Mathlib.NumberTheory.Modular.0.ModularGroup.fdo_eq_interior_fd._simp_1_1 | Mathlib.NumberTheory.Modular | ∀ {α : Type u} {β : Type v} {f : α → β} {s : Set β} {a : α}, (a ∈ f ⁻¹' s) = (f a ∈ s) | null | false |
_private.Mathlib.Combinatorics.SimpleGraph.Regularity.Chunk.0.SzemerediRegularity.le_sum_card_subset_chunk_parts | Mathlib.Combinatorics.SimpleGraph.Regularity.Chunk | ∀ {α : Type u_1} [inst : Fintype α] [inst_1 : DecidableEq α] {P : Finpartition Finset.univ} {hP : P.IsEquipartition}
{G : SimpleGraph α} [inst_2 : DecidableRel G.Adj] {ε : ℝ} {U : Finset α} {hU : U ∈ P.parts} {𝒜 : Finset (Finset α)}
{s : Finset α},
𝒜 ⊆ (SzemerediRegularity.chunk hP G ε hU).parts →
s ∈ 𝒜 →
... | null | true |
Fin2.last.eq_1 | Mathlib.Data.Fin.Fin2 | Fin2.last = Fin2.fz | null | true |
exists_eq_pow_of_mul_eq_pow | Mathlib.Algebra.GCDMonoid.Basic | ∀ {α : Type u_1} [inst : CommMonoidWithZero α] [inst_1 : GCDMonoid α] [Subsingleton αˣ] {a b c : α},
IsUnit (gcd a b) → ∀ {k : ℕ}, a * b = c ^ k → ∃ d, a = d ^ k | null | true |
Rat.padicValuation._proof_1 | Mathlib.NumberTheory.Padics.PadicNumbers | ∀ (p : ℕ), (if 0 = 0 then 0 else WithZero.exp (-padicValRat p 0)) = 0 | null | false |
Lean.Meta.withFreshCache | Lean.Meta.Basic | {n : Type → Type u_1} → [MonadControlT Lean.MetaM n] → [Monad n] → {α : Type} → n α → n α | null | true |
Metric.coveringNumber_empty | Mathlib.Topology.MetricSpace.CoveringNumbers | ∀ {X : Type u_1} [inst : PseudoEMetricSpace X] (ε : NNReal), Metric.coveringNumber ε ∅ = 0 | null | true |
Module.isTorsionBySet_iff_subseteq_ker_lsmul | Mathlib.Algebra.Module.Torsion.Basic | ∀ {R : Type u_1} {M : Type u_2} [inst : CommSemiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] (s : Set R),
Module.IsTorsionBySet R M s ↔ s ⊆ ↑(LinearMap.lsmul R M).ker | null | true |
Real.volume_Ioo | Mathlib.MeasureTheory.Measure.Lebesgue.Basic | ∀ {a b : ℝ}, MeasureTheory.volume (Set.Ioo a b) = ENNReal.ofReal (b - a) | null | true |
_private.Mathlib.Tactic.Subsingleton.0.Lean.MVarId.subsingleton._sparseCasesOn_1 | Mathlib.Tactic.Subsingleton | {α : Type u} →
{motive : Option α → Sort u_1} →
(t : Option α) → ((val : α) → motive (some val)) → (Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t | null | false |
_private.Init.Data.UInt.IntToBitVec.0.USize.lt_iff_toBitVec32_lt._simp_1_1 | Init.Data.UInt.IntToBitVec | ∀ {a b : USize}, (a < b) = (a.toBitVec < b.toBitVec) | null | false |
PiTensorProduct.tprod._proof_2 | Mathlib.LinearAlgebra.PiTensorProduct.Basic | ∀ {ι : Type u_1} (R : Type u_2) [inst : CommSemiring R] {s : ι → Type u_3} [inst_1 : (i : ι) → AddCommMonoid (s i)]
[inst_2 : (i : ι) → Module R (s i)] {x : DecidableEq ι} {f : (i : ι) → s i} (i : ι) (x_1 y : s i),
PiTensorProduct.tprodCoeff R 1 (Function.update f i (x_1 + y)) =
PiTensorProduct.tprodCoeff R 1 (... | null | false |
Finset.centerMass | Mathlib.Analysis.Convex.Combination | {R : Type u_1} →
{E : Type u_3} →
{ι : Type u_5} → [inst : Field R] → [inst_1 : AddCommGroup E] → [Module R E] → Finset ι → (ι → R) → (ι → E) → E | Center of mass of a finite collection of points with prescribed weights.
Note that we require neither `0 ≤ w i` nor `∑ w = 1`. | true |
CoalgEquiv.instEquivLike._proof_1 | Mathlib.RingTheory.Coalgebra.Equiv | ∀ {R : Type u_1} {A : Type u_2} {B : Type u_3} [inst : CommSemiring R] [inst_1 : AddCommMonoid A]
[inst_2 : AddCommMonoid B] [inst_3 : Module R A] [inst_4 : Module R B] [inst_5 : CoalgebraStruct R A]
[inst_6 : CoalgebraStruct R B] (x x_1 : A ≃ₗc[R] B), x.toFun = x_1.toFun → x.invFun = x_1.invFun → x = x_1 | null | false |
List.mapIdx_singleton | Init.Data.List.MapIdx | ∀ {α : Type u_1} {α_1 : Type u_2} {f : ℕ → α → α_1} {a : α}, List.mapIdx f [a] = [f 0 a] | null | true |
SSet.boundary_zero | Mathlib.AlgebraicTopology.SimplicialSet.Boundary | SSet.boundary 0 = ⊥ | null | true |
AlexDisc.category._aux_5 | Mathlib.Topology.Order.Category.AlexDisc | {X Y Z : AlexDisc} → (X ⟶ Y) → (Y ⟶ Z) → (X ⟶ Z) | null | false |
instLTOption | Init.Data.Option.Basic | {α : Type u_1} → [LT α] → LT (Option α) | null | true |
Lean.JsonRpc.RequestID.null.sizeOf_spec | Lean.Data.JsonRpc | sizeOf Lean.JsonRpc.RequestID.null = 1 | null | true |
HomogeneousPow.rec | Init.Prelude | {α : Type u} →
{motive : HomogeneousPow α → Sort u_1} →
((pow : α → α → α) → motive { pow := pow }) → (t : HomogeneousPow α) → motive t | null | false |
TensorProduct.instBialgebra._proof_18 | Mathlib.RingTheory.Bialgebra.TensorProduct | ∀ (R : Type u_1) (S : Type u_4) (A : Type u_2) (B : Type u_3) [inst : CommSemiring R] [inst_1 : CommSemiring S]
[inst_2 : Semiring A] [inst_3 : Semiring B] [inst_4 : Bialgebra S A] [inst_5 : Bialgebra R B] [inst_6 : Algebra R A]
[inst_7 : Algebra R S] [inst_8 : IsScalarTower R S A],
CoalgebraStruct.comul =
... | null | false |
Std.Iterators.PostconditionT.bind | Init.Data.Iterators.PostconditionMonad | {m : Type w → Type w'} →
[Monad m] →
{α β : Type w} →
Std.Iterators.PostconditionT m α → (α → Std.Iterators.PostconditionT m β) → Std.Iterators.PostconditionT m β | Given a function `α → PostconditionT m β`, returns a function
`PostconditionT m α → PostconditionT m β`, turning `PostconditionT m` into a monad.
| true |
Perfection.lift._proof_12 | Mathlib.RingTheory.Perfection | ∀ (p : ℕ) [hp : Fact (Nat.Prime p)] (R : Type u_2) [inst : CommSemiring R] [inst_1 : CharP R p]
[inst_2 : PerfectRing R p] (S : Type u_1) [inst_3 : CommSemiring S] (f : R →+* S) (x x_1 : R) (n : ℕ),
f ((⇑↑(frobeniusEquiv R p).symm)^[n + 1] (x + x_1)) ^ p = f ((⇑↑(frobeniusEquiv R p).symm)^[n] (x + x_1)) | null | false |
Polynomial.Splits.comp_of_degree_le_one | Mathlib.Algebra.Polynomial.Splits | ∀ {R : Type u_1} [inst : Field R] {f g : Polynomial R}, f.Splits → g.degree ≤ 1 → (f.comp g).Splits | null | true |
Lean.Parser.ParserContextCore.quotDepth._inherited_default | Lean.Parser.Types | ℕ | null | false |
AddSubmonoid.center.addCommMonoid | Mathlib.GroupTheory.Submonoid.Center | {M : Type u_1} → [inst : AddMonoid M] → AddCommMonoid ↥(AddSubmonoid.center M) | The center of an additive monoid is additively commutative. | true |
_private.Init.Data.Dyadic.Basic.0.Dyadic.neg_ofIntWithPrec._simp_1_2 | Init.Data.Dyadic.Basic | ∀ {a : ℤ}, (-a = 0) = (a = 0) | null | false |
Lean.Parser.simprocPatternBuiltin | Init.Simproc | Lean.ParserDescr | Auxiliary command for associating a pattern with a builtin simplification procedure.
| true |
MeasureTheory.VectorMeasure.restrict_le_restrict_subset | Mathlib.MeasureTheory.VectorMeasure.Order | ∀ {α : Type u_1} {m : MeasurableSpace α} {M : Type u_3} [inst : TopologicalSpace M] [inst_1 : AddCommMonoid M]
[inst_2 : PartialOrder M] (v w : MeasureTheory.VectorMeasure α M) {i j : Set α},
MeasurableSet i → v.restrict i ≤ w.restrict i → j ⊆ i → v.restrict j ≤ w.restrict j | null | true |
_private.Mathlib.Algebra.Ring.Associator.0.associator_op._simp_1_2 | Mathlib.Algebra.Ring.Associator | ∀ {α : Type u_1} [inst : Sub α] (x y : αᵐᵒᵖ), MulOpposite.unop x - MulOpposite.unop y = MulOpposite.unop (x - y) | null | false |
NumberField.mixedEmbedding.fundamentalCone.expMap_symm_apply | Mathlib.NumberTheory.NumberField.CanonicalEmbedding.NormLeOne | ∀ {K : Type u_1} [inst : Field K] [inst_1 : NumberField K] (x : NumberField.mixedEmbedding.realSpace K)
(w : NumberField.InfinitePlace K),
↑NumberField.mixedEmbedding.fundamentalCone.expMap.symm x w = ↑w.mult * Real.log (x w) | null | true |
Topology.RelCWComplex.mkFiniteType_map | Mathlib.Topology.CWComplex.Classical.Finite | ∀ {X : Type u} [inst : TopologicalSpace X] (C : Set X) (D : outParam (Set X)) (cell : ℕ → Type u)
(map : (n : ℕ) → cell n → PartialEquiv (Fin n → ℝ) X) (finite_cell : ∀ (n : ℕ), Finite (cell n))
(source_eq : ∀ (n : ℕ) (i : cell n), (map n i).source = Metric.ball 0 1)
(continuousOn : ∀ (n : ℕ) (i : cell n), Contin... | null | true |
CategoryTheory.Monoidal.CommMonFunctorCategoryEquivalence.functor_map_app_hom_hom | Mathlib.CategoryTheory.Monoidal.Internal.FunctorCategory | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
[inst_2 : CategoryTheory.MonoidalCategory D] [inst_3 : CategoryTheory.BraidedCategory D]
{X Y : CategoryTheory.CommMon (CategoryTheory.Functor C D)} (f : X ⟶ Y) (X_1 : C),
((CategoryTheory.Monoi... | null | true |
Function.uncurry.eq_1 | Mathlib.Data.Set.NAry | ∀ {α : Type u_1} {β : Type u_2} {φ : Sort u_3} (f : α → β → φ) (a : α × β), Function.uncurry f a = f a.1 a.2 | null | true |
_private.Mathlib.Order.Filter.Basic.0.Filter.iInf_neBot_of_directed'._simp_1_1 | Mathlib.Order.Filter.Basic | ∀ {α : Sort u_1} {p : α → Prop}, (¬∀ (x : α), p x) = ∃ x, ¬p x | null | false |
IsLocalization.Away.integralClosure | Mathlib.RingTheory.Localization.Integral | ∀ {R : Type u_1} [inst : CommRing R] {S : Type u_2} [inst_1 : CommRing S] [inst_2 : Algebra R S] {Rf : Type u_5}
{Sf : Type u_6} [inst_3 : CommRing Rf] [inst_4 : CommRing Sf] [inst_5 : Algebra R Rf] [inst_6 : Algebra S Sf]
[inst_7 : Algebra Rf Sf] [inst_8 : Algebra R Sf] [IsScalarTower R S Sf] [inst_10 : IsScalarTo... | null | true |
Sat.Literal.pos.sizeOf_spec | Mathlib.Tactic.Sat.FromLRAT | ∀ (a : ℕ), sizeOf (Sat.Literal.pos a) = 1 + sizeOf a | null | true |
Std.Rxi.Iterator.instLawfulIteratorLoop | Init.Data.Range.Polymorphic.RangeIterator | ∀ {α : Type u} [inst : Std.PRange.UpwardEnumerable α] [inst_1 : Std.PRange.LawfulUpwardEnumerable α]
{n : Type u → Type w} [inst_2 : Monad n] [LawfulMonad n], Std.LawfulIteratorLoop (Std.Rxi.Iterator α) Id n | null | true |
_private.Mathlib.Data.Sym.Sym2.Card.0.Sym2.diagSetComplEquiv.match_1.eq_1 | Mathlib.Data.Sym.Sym2.Card | ∀ {α : Type u_1} (motive : Bool × ↑Sym2.diagSetᶜ ⊕ α → Sort u_2) (z : Sym2 α) (property : z ∈ Sym2.diagSetᶜ)
(h_1 : (z : Sym2 α) → (property : z ∈ Sym2.diagSetᶜ) → motive (Sum.inl (true, ⟨z, property⟩)))
(h_2 : (z : Sym2 α) → (property : z ∈ Sym2.diagSetᶜ) → motive (Sum.inl (false, ⟨z, property⟩)))
(h_3 : (a : α)... | null | true |
OrderMonoidWithZeroHom.mk_toMonoidWithZeroHom | Mathlib.Algebra.Order.Hom.MonoidWithZero | ∀ {α : Type u_2} {β : Type u_3} [inst : Preorder α] [inst_1 : Preorder β] [inst_2 : MulZeroOneClass α]
[inst_3 : MulZeroOneClass β] (f : α →*₀o β) (h : Monotone (↑↑f).toFun),
{ toMonoidWithZeroHom := ↑f, monotone' := h } = f | null | true |
_private.Init.Grind.Ring.Field.0.Lean.Grind.Field.natCast_div_of_dvd._proof_1_1 | Init.Grind.Ring.Field | ∀ {y : ℕ}, ¬y = 0 → ¬0 < y → False | null | false |
Finset.sup_eq_bot_iff._simp_2 | Mathlib.Data.Finset.Lattice.Fold | ∀ {α : Type u_2} {β : Type u_3} [inst : SemilatticeSup α] [inst_1 : OrderBot α] (f : β → α) (S : Finset β),
(S.sup f = ⊥) = ∀ s ∈ S, f s = ⊥ | null | false |
neg_eq_self | Mathlib.Algebra.Group.Torsion | ∀ {G : Type u_2} [inst : AddGroup G] {a : G} [IsAddTorsionFree G], -a = a ↔ a = 0 | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.