name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
ProbabilityTheory.variance_sum_pi | Mathlib.Probability.Moments.Variance | ∀ {ι : Type u_2} [inst : Fintype ι] {Ω : ι → Type u_3} {mΩ : (i : ι) → MeasurableSpace (Ω i)}
{μ : (i : ι) → MeasureTheory.Measure (Ω i)} [∀ (i : ι), MeasureTheory.IsProbabilityMeasure (μ i)]
{X : (i : ι) → Ω i → ℝ},
(∀ (i : ι), MeasureTheory.MemLp (X i) 2 (μ i)) →
ProbabilityTheory.variance (∑ i, fun ω => X ... | null | true |
RingHom.pi._proof_4 | Mathlib.Algebra.Ring.Pi | ∀ {I : Type u_1} {f : I → Type u_2} {γ : Type u_3} [inst : (i : I) → NonAssocSemiring (f i)]
[inst_1 : NonAssocSemiring γ] (g : (i : I) → γ →+* f i) (x y : γ),
(↑(AddMonoidHom.pi fun i => (g i).toAddMonoidHom)).toFun (x + y) =
(↑(AddMonoidHom.pi fun i => (g i).toAddMonoidHom)).toFun x +
(↑(AddMonoidHom.pi... | null | false |
MeasureTheory.Measure.compProd_eq_comp_prod | Mathlib.Probability.Kernel.Composition.MeasureComp | ∀ {α : Type u_1} {β : Type u_2} {mα : MeasurableSpace α} {mβ : MeasurableSpace β} (μ : MeasureTheory.Measure α)
[MeasureTheory.SFinite μ] (κ : ProbabilityTheory.Kernel α β) [ProbabilityTheory.IsSFiniteKernel κ],
μ.compProd κ = μ.bind ⇑(ProbabilityTheory.Kernel.id.prod κ) | null | true |
MeasureTheory.integral_conv | Mathlib.MeasureTheory.Group.IntegralConvolution | ∀ {M : Type u_1} {F : Type u_2} [inst : AddMonoid M] {mM : MeasurableSpace M} [MeasurableAdd₂ M]
[inst_2 : NormedAddCommGroup F] {μ ν : MeasureTheory.Measure M} {f : M → F} [inst_3 : NormedSpace ℝ F]
[MeasureTheory.SFinite μ] [MeasureTheory.SFinite ν],
MeasureTheory.Integrable f (μ.conv ν) → ∫ (x : M), f x ∂μ.con... | null | true |
CategoryTheory.Limits.limit.cone_x | Mathlib.CategoryTheory.Limits.HasLimits | ∀ {J : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} J] {C : Type u} [inst_1 : CategoryTheory.Category.{v, u} C]
{F : CategoryTheory.Functor J C} [inst_2 : CategoryTheory.Limits.HasLimit F],
(CategoryTheory.Limits.limit.cone F).pt = CategoryTheory.Limits.limit F | null | true |
SimpleGraph.Walk.exists_minimalFor_isCircuit_length | Mathlib.Combinatorics.SimpleGraph.Paths | ∀ {V : Type u} {G : SimpleGraph V} {v : V},
(∃ p, p.IsCircuit) → ∃ p, MinimalFor SimpleGraph.Walk.IsCircuit SimpleGraph.Walk.length p | null | true |
LineDeriv.«_aux_Mathlib_Analysis_Distribution_DerivNotation___macroRules_LineDeriv_term∂_{_}_1» | Mathlib.Analysis.Distribution.DerivNotation | Lean.Macro | null | false |
Pi.isCompact_iff_of_isClosed | Mathlib.Topology.Compactness.Compact | ∀ {ι : Type u_1} {X : ι → Type u_2} [inst : (i : ι) → TopologicalSpace (X i)] {s : Set ((i : ι) → X i)},
IsClosed s → (IsCompact s ↔ ∀ (i : ι), IsCompact (Function.eval i '' s)) | null | true |
TemperedDistribution.instFourierTransformInv | Mathlib.Analysis.Distribution.TemperedDistribution | {E : Type u_3} →
{F : Type u_4} →
[inst : NormedAddCommGroup E] →
[inst_1 : InnerProductSpace ℝ E] →
[FiniteDimensional ℝ E] →
[inst_3 : MeasurableSpace E] →
[BorelSpace E] →
[inst_5 : AddCommGroup F] →
[inst_6 : Module ℂ F] →
[in... | null | true |
Subgroup.zpowers_one_eq_bot | Mathlib.Algebra.Group.Subgroup.ZPowers.Basic | ∀ {G : Type u_1} [inst : Group G], Subgroup.zpowers 1 = ⊥ | null | true |
_private.Lean.Elab.Tactic.Conv.Pattern.0.Lean.Elab.Tactic.Conv.evalPattern.match_5 | Lean.Elab.Tactic.Conv.Pattern | (motive : Lean.Elab.Tactic.Conv.PatternMatchState → Sort u_1) →
(occs : Lean.Elab.Tactic.Conv.PatternMatchState) →
((subgoals : Array Lean.MVarId) → motive (Lean.Elab.Tactic.Conv.PatternMatchState.all subgoals)) →
((x : Lean.Elab.Tactic.Conv.PatternMatchState) → motive x) → motive occs | null | false |
AlgebraicGeometry.Scheme.Modules.instCategory._proof_2 | Mathlib.AlgebraicGeometry.Modules.Sheaf | ∀ {X : AlgebraicGeometry.Scheme} {X_1 Y : SheafOfModules X.ringCatSheaf} (f : X_1 ⟶ Y),
CategoryTheory.CategoryStruct.comp f (CategoryTheory.CategoryStruct.id Y) = f | null | false |
DividedPowers.ofInjective._proof_2 | Mathlib.RingTheory.DividedPowers.Padic | ∀ {A : Type u_1} {B : Type u_2} [inst : CommSemiring A] [inst_1 : CommSemiring B] (I : Ideal A) (J : Ideal B)
(f : A →+* B),
Function.Injective ⇑f →
∀ (hJ : DividedPowers J),
Ideal.map f I = J →
∀ (hmem : ∀ (n : ℕ) {x : A}, x ∈ I → ∃ y, ∃ (_ : n ≠ 0 → y ∈ I), f y = hJ.dpow n (f x)) {x : A},
... | null | false |
WeierstrassCurve.Jacobian.addXYZ.eq_1 | Mathlib.AlgebraicGeometry.EllipticCurve.Jacobian.Formula | ∀ {R : Type r} [inst : CommRing R] (W' : WeierstrassCurve.Jacobian R) (P Q : Fin 3 → R),
W'.addXYZ P Q = ![W'.addX P Q, W'.addY P Q, WeierstrassCurve.Jacobian.addZ P Q] | null | true |
Lean.Elab.Do.elabDoElem._unsafe_rec | Lean.Elab.Do.Basic | Lean.DoElem → Lean.Elab.Do.DoElemCont → optParam Bool true → Lean.Elab.Do.DoElabM Lean.Expr | null | false |
ClosedIciTopology | Mathlib.Topology.Order.OrderClosed | (α : Type u_1) → [TopologicalSpace α] → [Preorder α] → Prop | If `α` is a topological space and a preorder, `ClosedIciTopology α` means that `Ici a` is
closed for all `a : α`. | true |
_private.Mathlib.RingTheory.Valuation.RankOne.0.Valuation.RankLeOne.exists_val_lt._simp_1_1 | Mathlib.RingTheory.Valuation.RankOne | ∀ {a b : Prop}, (a ∨ b) = (¬a → b) | null | false |
QuadraticMap.Nondegenerate.rank_rad_polar_le | Mathlib.LinearAlgebra.QuadraticForm.Radical | ∀ {R : Type u_1} {M : Type u_2} {P : Type u_4} [inst : AddCommGroup M] [inst_1 : AddCommGroup P] [inst_2 : CommRing R]
[inst_3 : Module R M] [inst_4 : Module R P] {Q : QuadraticMap R M P},
QuadraticMap.Nondegenerate → Module.rank R ↥(LinearMap.ker Q.polarBilin) ≤ 1 | null | true |
OrderDual.instLocallyFiniteOrderTop._proof_1 | Mathlib.Order.Interval.Finset.Defs | ∀ {α : Type u_1} [inst : Preorder α] [inst_1 : LocallyFiniteOrderBot α] (x x_1 : αᵒᵈ),
x_1 ∈ Finset.Iic (OrderDual.ofDual x) ↔ x_1 ≤ OrderDual.ofDual x | null | false |
CategoryTheory.SmallObject.locallySmall | Mathlib.CategoryTheory.SmallObject.IsCardinalForSmallObjectArgument | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (I : CategoryTheory.MorphismProperty C) (κ : Cardinal.{w})
[inst_1 : Fact κ.IsRegular] [inst_2 : OrderBot κ.ord.ToType] [I.IsCardinalForSmallObjectArgument κ],
CategoryTheory.LocallySmall.{w, v, u} C | null | true |
_private.Std.Data.DTreeMap.Internal.Balancing.0.Std.DTreeMap.Internal.Impl.balanceL!.match_5.eq_2 | Std.Data.DTreeMap.Internal.Balancing | ∀ {α : Type u_1} {β : α → Type u_2} (motive : Std.DTreeMap.Internal.Impl α β → Sort u_3) (ls : ℕ) (lk : α) (lv : β lk)
(ll lr : Std.DTreeMap.Internal.Impl α β) (h_1 : Unit → motive Std.DTreeMap.Internal.Impl.leaf)
(h_2 :
(ls : ℕ) →
(lk : α) →
(lv : β lk) →
(ll lr : Std.DTreeMap.Internal.... | null | true |
SimpleGraph.componentComplMk_eq_of_adj | Mathlib.Combinatorics.SimpleGraph.Ends.Defs | ∀ {V : Type u} {K : Set V} (G : SimpleGraph V) {v w : V} (vK : v ∉ K) (wK : w ∉ K),
G.Adj v w → G.componentComplMk vK = G.componentComplMk wK | null | true |
CategoryTheory.Functor.CoconeTypes.mk.injEq | Mathlib.CategoryTheory.Limits.Types.ColimitType | ∀ {J : Type u} [inst : CategoryTheory.Category.{v, u} J] {F : CategoryTheory.Functor J (Type w₀)} (pt : Type w₁)
(ι : (j : J) → F.obj j → pt)
(ι_naturality :
autoParam (∀ {j j' : J} (f : j ⟶ j'), ι j' ∘ ⇑(CategoryTheory.ConcreteCategory.hom (F.map f)) = ι j)
CategoryTheory.Functor.CoconeTypes.ι_naturality... | null | true |
List.cons_head!_tail | Mathlib.Data.List.Basic | ∀ {α : Type u} [inst : Inhabited α] {l : List α}, l ≠ [] → l.head! :: l.tail = l | null | true |
Profinite.lift_lifts | Mathlib.Topology.Category.Stonean.Basic | ∀ {X Y : Profinite} {Z : Stonean} (e : Stonean.toProfinite.obj Z ⟶ Y) (f : X ⟶ Y) [inst : CategoryTheory.Epi f],
CategoryTheory.CategoryStruct.comp (Profinite.lift e f) f = e | null | true |
Nat.sqrt_mul_sqrt_lt_succ | Mathlib.Data.Nat.Sqrt | ∀ (n : ℕ), n.sqrt * n.sqrt < n + 1 | null | true |
_private.Mathlib.GroupTheory.DivisibleHull.0.DivisibleHull.mk_eq_mk_iff_smul_eq_smul._simp_1_2 | Mathlib.GroupTheory.DivisibleHull | ∀ {M : Type u_1} [inst : AddMonoid M] [HasUniqueDiv M] {n : ℕ} {a b : M}, n ≠ 0 → (n • a = n • b) = (a = b) | null | false |
CategoryTheory.ComposableArrows.opEquivalence_inverse_obj | Mathlib.CategoryTheory.ComposableArrows.Basic | ∀ (C : Type u_1) [inst : CategoryTheory.Category.{v_1, u_1} C] (n : ℕ) (X : CategoryTheory.ComposableArrows Cᵒᵖ n),
(CategoryTheory.ComposableArrows.opEquivalence C n).inverse.obj X =
Opposite.op
((⋯.functor.comp (CategoryTheory.orderDualEquivalence (Fin (n + 1))).functor).comp
(CategoryTheory.Funct... | null | true |
Matrix.UnitaryGroup.map_star_inv_eq_transpose | Mathlib.LinearAlgebra.UnitaryGroup | ∀ {n : Type u} [inst : DecidableEq n] [inst_1 : Fintype n] {α : Type v} [inst_2 : CommRing α] [inst_3 : StarRing α]
(U : ↥(Matrix.unitaryGroup n α)), (Matrix.UnitaryGroup.map_star U)⁻¹ = Matrix.UnitaryGroup.transpose U | null | true |
Set.uIcc_subset_uIcc_iff_le | Mathlib.Order.Interval.Set.UnorderedInterval | ∀ {α : Type u_1} [inst : LinearOrder α] {a₁ a₂ b₁ b₂ : α},
Set.uIcc a₁ b₁ ⊆ Set.uIcc a₂ b₂ ↔ min a₂ b₂ ≤ min a₁ b₁ ∧ max a₁ b₁ ≤ max a₂ b₂ | null | true |
CategoryTheory.WithTerminal.map | Mathlib.CategoryTheory.WithTerminal.Basic | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{D : Type u_1} →
[inst_1 : CategoryTheory.Category.{v_1, u_1} D] →
CategoryTheory.Functor C D →
CategoryTheory.Functor (CategoryTheory.WithTerminal C) (CategoryTheory.WithTerminal D) | Map `WithTerminal` with respect to a functor `F : C ⥤ D`. | true |
Std.HashMap.emptyWithCapacity_equiv_iff_isEmpty | Std.Data.HashMap.Lemmas | ∀ {α : Type u} {β : Type v} {x : BEq α} {x_1 : Hashable α} {m : Std.HashMap α β} [EquivBEq α] [LawfulHashable α]
{c : ℕ}, (Std.HashMap.emptyWithCapacity c).Equiv m ↔ m.isEmpty = true | null | true |
Plausible.TestResult.gaveUp.injEq | Plausible.Testable | ∀ {p : Prop} (a a_1 : ℕ), (Plausible.TestResult.gaveUp a = Plausible.TestResult.gaveUp a_1) = (a = a_1) | null | true |
UniversalEnvelopingAlgebra.ι_comp_lift | Mathlib.Algebra.Lie.UniversalEnveloping | ∀ (R : Type u₁) {L : Type u₂} [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : LieAlgebra R L] {A : Type u₃}
[inst_3 : Ring A] [inst_4 : Algebra R A] (f : L →ₗ⁅R⁆ A),
⇑((UniversalEnvelopingAlgebra.lift R) f) ∘ ⇑(UniversalEnvelopingAlgebra.ι R) = ⇑f | null | true |
CategoryTheory.coyonedaEquiv_coyoneda_map | Mathlib.CategoryTheory.Yoneda | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {X Y : C} (f : X ⟶ Y),
CategoryTheory.coyonedaEquiv (CategoryTheory.coyoneda.map f.op) = f | null | true |
InnerProductGeometry.mul_norm_eq_abs_sub_sq_norm | Mathlib.Geometry.Euclidean.Sphere.Power | ∀ {V : Type u_1} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V] {x y z : V},
(∃ k, x = k • y) → ‖z - y‖ = ‖z + y‖ → ‖x - y‖ * ‖x + y‖ = |‖z + y‖ ^ 2 - ‖z - x‖ ^ 2| | null | true |
Order.Coframe.mk._flat_ctor | Mathlib.Order.CompleteBooleanAlgebra | {α : Type u_1} →
(le lt : α → α → Prop) →
(le_refl : ∀ (a : α), le a a) →
(le_trans : ∀ (a b c : α), le a b → le b c → le a c) →
(lt_iff_le_not_ge : autoParam (∀ (a b : α), lt a b ↔ le a b ∧ ¬le b a) Preorder.lt_iff_le_not_ge._autoParam) →
(le_antisymm : ∀ (a b : α), le a b → le b a → a = ... | null | false |
ISize.pow._f | Init.Data.SInt.Basic | ISize → (n : ℕ) → Nat.below n → ISize | null | false |
interior_mem_nhds | Mathlib.Topology.Neighborhoods | ∀ {X : Type u} [inst : TopologicalSpace X] {x : X} {s : Set X}, interior s ∈ nhds x ↔ s ∈ nhds x | null | true |
ULift.addZeroClass._proof_2 | Mathlib.Algebra.Group.ULift | ∀ {α : Type u_1} [inst : AddZeroClass α], Equiv.ulift 0 = Equiv.ulift 0 | null | false |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.Const.get?_inter._simp_1_2 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {instOrd : Ord α} {a b : α}, (compare a b ≠ Ordering.eq) = ((a == b) = false) | null | false |
Batteries.Tactic.GeneralizeProofs.GState.mk.inj | Batteries.Tactic.GeneralizeProofs | ∀ {propToFVar propToFVar_1 : Lean.ExprMap Lean.Expr},
{ propToFVar := propToFVar } = { propToFVar := propToFVar_1 } → propToFVar = propToFVar_1 | null | true |
FirstOrder.Language.BoundedFormula.toPrenexImpRight._sparseCasesOn_1 | Mathlib.ModelTheory.Complexity | {L : FirstOrder.Language} →
{α : Type u'} →
{motive : (a : ℕ) → L.BoundedFormula α a → Sort u_1} →
{a : ℕ} →
(t : L.BoundedFormula α a) →
({n : ℕ} → (f₁ f₂ : L.BoundedFormula α n) → motive n (f₁.imp f₂)) →
({n : ℕ} → (f : L.BoundedFormula α (n + 1)) → motive n f.all) →
... | null | false |
_private.Mathlib.Analysis.Complex.Exponential.0.Complex.isCauSeq_norm_exp.match_1_1 | Mathlib.Analysis.Complex.Exponential | ∀ (z : ℂ) (motive : (∃ n, ‖z‖ < ↑n) → Prop) (x : ∃ n, ‖z‖ < ↑n), (∀ (n : ℕ) (hn : ‖z‖ < ↑n), motive ⋯) → motive x | null | false |
CategoryTheory.functorCategoryPreadditive._proof_9 | Mathlib.CategoryTheory.Preadditive.FunctorCategory | ∀ {C : Type u_1} {D : Type u_3} [inst : CategoryTheory.Category.{u_4, u_1} C]
[inst_1 : CategoryTheory.Category.{u_2, u_3} D] [inst_2 : CategoryTheory.Preadditive D]
(F G : CategoryTheory.Functor C D) (x x_1 : F ⟶ G), x - x_1 = x + -x_1 | null | false |
_private.Init.Data.List.MapIdx.0.List.mapIdx_eq_replicate_iff._simp_1_2 | Init.Data.List.MapIdx | ∀ {α : Sort u_1} {p : α → Prop} {q : (∃ x, p x) → Prop}, (∀ (h : ∃ x, p x), q h) = ∀ (x : α) (h : p x), q ⋯ | null | false |
Sum.swap_monotone | Mathlib.Order.Sum.Order | ∀ {α : Type u_1} {β : Type u_2} [inst : Preorder α] [inst_1 : Preorder β], Monotone Sum.swap | null | true |
_private.Mathlib.RingTheory.GradedAlgebra.Radical.0.Ideal.IsHomogeneous.isPrime_of_homogeneous_mem_or_mem._simp_1_3 | Mathlib.RingTheory.GradedAlgebra.Radical | ∀ {α : Type u_1} [inst : DecidableEq α] {a b : α} {s : Finset α}, (a ∈ s.erase b) = (a ≠ b ∧ a ∈ s) | null | false |
IO.AccessRight.mk.injEq | Init.System.IO | ∀ (read write execution read_1 write_1 execution_1 : Bool),
({ read := read, write := write, execution := execution } =
{ read := read_1, write := write_1, execution := execution_1 }) =
(read = read_1 ∧ write = write_1 ∧ execution = execution_1) | null | true |
Std.DTreeMap.Internal.Impl.get_eq_getD | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Std.DTreeMap.Internal.Impl α β} [Std.TransOrd α]
[inst : Std.LawfulEqOrd α], t.WF → ∀ {a : α} {fallback : β a} {h : a ∈ t}, t.get a h = t.getD a fallback | null | true |
CategoryTheory.GrothendieckTopology.instCompleteLattice._proof_14 | Mathlib.CategoryTheory.Sites.Grothendieck | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] (a a_1 : CategoryTheory.GrothendieckTopology C) ⦃X Y : C⦄
⦃S : CategoryTheory.Sieve X⦄ (f : Y ⟶ X),
S ∈ sInf (CategoryTheory.GrothendieckTopology.sieves '' {x | a ≤ x ∧ a_1 ≤ x}) X →
CategoryTheory.Sieve.pullback f S ∈ sInf (CategoryTheory.Grothendi... | null | false |
CategoryTheory.MorphismProperty.Over.pullbackComp._proof_1 | Mathlib.CategoryTheory.MorphismProperty.OverAdjunction | ∀ {T : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} T] {P : CategoryTheory.MorphismProperty T} {X Y Z : T}
(f : X ⟶ Y) (g : Y ⟶ Z) [P.IsStableUnderBaseChangeAlong g] [P.HasPullbacksAlong f] [P.HasPullbacksAlong g]
(fg : X ⟶ Z), fg = CategoryTheory.CategoryStruct.comp f g → P.HasPullbacksAlong fg | null | false |
Real.sinh_lt_self_iff | Mathlib.Analysis.SpecialFunctions.Trigonometric.DerivHyp | ∀ {x : ℝ}, Real.sinh x < x ↔ x < 0 | null | true |
HomologicalComplex.HomologySequence.composableArrows₃_exact | Mathlib.Algebra.Homology.HomologySequence | ∀ {C : Type u_1} {ι : Type u_2} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Preadditive C]
{c : ComplexShape ι} (K : HomologicalComplex C c) (i j : ι),
c.Rel i j →
∀ [inst_2 : CategoryTheory.CategoryWithHomology C],
(HomologicalComplex.HomologySequence.composableArrows₃ K i j).E... | The diagram `K.homology i ⟶ K.opcycles i ⟶ K.cycles j ⟶ K.homology j` is exact
when `c.Rel i j`. | true |
CategoryTheory.Sheaf.H.longSequenceHom._proof_1 | Mathlib.CategoryTheory.Sites.SheafCohomology.ExactSequences | 0 < 5 + 1 | null | false |
Submodule.submoduleOfEquivOfLe._proof_1 | Mathlib.Algebra.Module.Submodule.Map | ∀ {R : Type u_2} {M : Type u_1} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
{p q : Submodule R M} (h : p ≤ q), Function.LeftInverse (fun m => ⟨⟨↑m, ⋯⟩, ⋯⟩) fun m => ⟨↑↑m, ⋯⟩ | null | false |
_private.Lean.Elab.Command.0.Lean.Elab.Command.elabCommand.match_5 | Lean.Elab.Command | (motive : List (Lean.KeyedDeclsAttribute.AttributeEntry Lean.Elab.Command.CommandElab) → Sort u_1) →
(x : List (Lean.KeyedDeclsAttribute.AttributeEntry Lean.Elab.Command.CommandElab)) →
(Unit → motive []) →
((elabFns : List (Lean.KeyedDeclsAttribute.AttributeEntry Lean.Elab.Command.CommandElab)) → motive el... | null | false |
RingHom.compLeft_apply | Mathlib.Algebra.Ring.Pi | ∀ {α : Type u_1} {β : Type u_2} [inst : NonAssocSemiring α] [inst_1 : NonAssocSemiring β] (f : α →+* β) (I : Type u_3)
(h : I → α) (a : I), (f.compLeft I) h a = (⇑f ∘ h) a | null | true |
_private.Mathlib.Combinatorics.SimpleGraph.Connectivity.Represents.0.SimpleGraph.ConnectedComponent.Represents.existsUnique_rep._simp_1_2 | Mathlib.Combinatorics.SimpleGraph.Connectivity.Represents | ∀ {V : Type u} {G : SimpleGraph V} (C : G.ConnectedComponent) (v : V), (v ∈ C.supp) = (G.connectedComponentMk v = C) | null | false |
_private.Mathlib.MeasureTheory.Integral.SetToL1.ChangeMeasure.0.MeasureTheory.setToFun_top_smul_measure._simp_1_5 | Mathlib.MeasureTheory.Integral.SetToL1.ChangeMeasure | ∀ {a : Prop}, (¬¬a) = a | null | false |
Fin.exists_iff_exists_maximal | Batteries.Data.Fin.Lemmas | ∀ {n : ℕ} (p : Fin n → Prop) [DecidablePred p], (∃ i, p i) ↔ ∃ i, p i ∧ ∀ (j : Fin n), i < j → ¬p j | null | true |
_private.Mathlib.NumberTheory.Fermat.0.Nat.coprime_fermatNumber_fermatNumber._simp_1_1 | Mathlib.NumberTheory.Fermat | ∀ {n m : ℕ}, n.Coprime m = m.Coprime n | null | false |
Lean.PersistentArray.foldrM | Lean.Data.PersistentArray | {α : Type u} → {m : Type v → Type w} → {β : Type v} → [Monad m] → Lean.PersistentArray α → (α → β → m β) → β → m β | null | true |
Lean.Elab.ComputedFields.Context.toInductiveVal | Lean.Elab.ComputedFields | Lean.Elab.ComputedFields.Context → Lean.InductiveVal | null | true |
ciSup_mono' | Mathlib.Order.ConditionallyCompleteLattice.Indexed | ∀ {α : Type u_1} {ι : Sort u_4} [inst : ConditionallyCompleteLinearOrderBot α] {ι' : Sort u_6} {f : ι → α} {g : ι' → α},
BddAbove (Set.range g) → (∀ (i : ι), ∃ i', f i ≤ g i') → ⨆ i, f i ≤ ⨆ i', g i' | **Alias** of `ciSup_mono_of_forall_exists'`. | true |
Lean.Elab.Term.Do.ToTerm.Context.ctorIdx | Lean.Elab.Do.Legacy | Lean.Elab.Term.Do.ToTerm.Context → ℕ | null | false |
ProbabilityTheory.cond_eq_zero_of_meas_eq_zero | Mathlib.Probability.ConditionalProbability | ∀ {Ω : Type u_1} {m : MeasurableSpace Ω} {μ : MeasureTheory.Measure Ω} {s : Set Ω}, μ s = 0 → μ[|s] = 0 | null | true |
_private.Mathlib.Analysis.SpecialFunctions.Trigonometric.Chebyshev.Extremal.0.Polynomial.Chebyshev.negOnePow_mul_iterateDerivativeC_pos._proof_1_8 | Mathlib.Analysis.SpecialFunctions.Trigonometric.Chebyshev.Extremal | ∀ (s : Finset ℕ), 0 ∉ s → ∀ a ∈ s, 0 < a | null | false |
Nat.lt_add_one_iff | Init.Data.Nat.Basic | ∀ {m n : ℕ}, m < n + 1 ↔ m ≤ n | null | true |
Bundle.ContinuousLinearMap.fiberBundle | Mathlib.Topology.VectorBundle.Hom | {𝕜₁ : Type u_1} →
[inst : NontriviallyNormedField 𝕜₁] →
{𝕜₂ : Type u_2} →
[inst_1 : NontriviallyNormedField 𝕜₂] →
(σ : 𝕜₁ →+* 𝕜₂) →
{B : Type u_3} →
(F₁ : Type u_4) →
[inst_2 : NormedAddCommGroup F₁] →
[inst_3 : NormedSpace 𝕜₁ F₁] →
... | The continuous `σ`-semilinear maps between two vector bundles form a fiber bundle. | true |
NumberField.InfinitePlace.Completion.ringEquivRealOfIsReal_apply | Mathlib.NumberTheory.NumberField.Completion.InfinitePlace | ∀ {K : Type u_1} [inst : Field K] {v : NumberField.InfinitePlace K} (hv : v.IsReal) (x : v.Completion),
(NumberField.InfinitePlace.Completion.ringEquivRealOfIsReal hv) x =
(NumberField.InfinitePlace.Completion.extensionEmbeddingOfIsReal hv) x | null | true |
Matrix.exists_rank_normal_form | Mathlib.LinearAlgebra.Matrix.Rank | ∀ {m : Type um} {R : Type uR} [inst : Field R] [inst_1 : Fintype m] [inst_2 : DecidableEq m] (M : Matrix m m R),
∃ V U e, IsUnit V ∧ IsUnit U ∧ V * M * U = (Matrix.fromBlocks 1 0 0 0).submatrix ⇑e ⇑e | Every square matrix over a field can be brought, by left and right multiplication by
invertible matrices, into the block form `fromBlocks 1 0 0 0`, where the identity block has size
equal to the rank of the matrix. | true |
AlgebraicGeometry.LocallyRingedSpace.restrictTopIso | Mathlib.Geometry.RingedSpace.LocallyRingedSpace | (X : AlgebraicGeometry.LocallyRingedSpace) → X.restrict ⋯ ≅ X | The restriction of a locally ringed space `X` to the top subspace is isomorphic to `X` itself.
| true |
_private.Mathlib.Algebra.TrivSqZeroExt.Basic.0.TrivSqZeroExt.isUnit_inv_iff._simp_1_1 | Mathlib.Algebra.TrivSqZeroExt.Basic | ∀ {R : Type u} {M : Type v} [inst : AddCommGroup M] [inst_1 : Semiring R] [inst_2 : Module Rᵐᵒᵖ M] [inst_3 : Module R M]
[inst_4 : SMulCommClass R Rᵐᵒᵖ M] {x : TrivSqZeroExt R M}, IsUnit x = IsUnit x.fst | null | false |
IsGreatest.eq_1 | Mathlib.Order.Bounds.Defs | ∀ {α : Type u_1} [inst : LE α] (s : Set α) (a : α), IsGreatest s a = (a ∈ s ∧ a ∈ upperBounds s) | null | true |
MulOpposite.unop_comp_op | Mathlib.Algebra.Opposites | ∀ {α : Type u_1}, MulOpposite.unop ∘ MulOpposite.op = id | null | true |
Configuration.HasPoints.mkPoint | Mathlib.Combinatorics.Configuration | {P : Type u_1} →
{L : Type u_2} → {inst : Membership P L} → [self : Configuration.HasPoints P L] → {l₁ l₂ : L} → l₁ ≠ l₂ → P | Intersection of two lines | true |
_private.Mathlib.Topology.UniformSpace.CompactConvergence.0.ContinuousMap.instIsCountablyGeneratedProdUniformityOfWeaklyLocallyCompactSpaceOfSigmaCompactSpace.match_1 | Mathlib.Topology.UniformSpace.CompactConvergence | ∀ {β : Type u_1} [inst : UniformSpace β] (motive : (∃ x, (uniformity β).HasAntitoneBasis x) → Prop)
(x : ∃ x, (uniformity β).HasAntitoneBasis x),
(∀ (_V : ℕ → Set (β × β)) (hV : (uniformity β).HasAntitoneBasis _V), motive ⋯) → motive x | null | false |
_private.Batteries.Recycling.RBTree.WF.0.RBTree.RBNode.Ordered.append.match_1_6 | Batteries.Recycling.RBTree.WF | ∀ {α : Type u_1} {cmp : α → α → Ordering} {v : α} (c : RBTree.RBNode α) (y : α) (d : RBTree.RBNode α)
(motive :
RBTree.RBNode.All (fun x => RBTree.RBNode.cmpLT cmp v x) (RBTree.RBNode.node RBTree.RBColor.red c y d) → Prop)
(vr : RBTree.RBNode.All (fun x => RBTree.RBNode.cmpLT cmp v x) (RBTree.RBNode.node RBTree... | null | false |
Lean.Elab.Term.FixedTermElabRef.toFixedTermElabImpl | Lean.Elab.Term.TermElabM | Lean.Elab.Term.FixedTermElabRef → Lean.Elab.Term.FixedTermElab | null | true |
DFinsupp.instAdd._proof_1 | Mathlib.Data.DFinsupp.Defs | ∀ {ι : Type u_2} {β : ι → Type u_1} [inst : (i : ι) → AddZeroClass (β i)] (x : ι), 0 + 0 = 0 | null | false |
CategoryTheory.TwoSquare.whiskerHorizontal | Mathlib.CategoryTheory.GuitartExact.HorizontalComposition | {C₁ : Type u_1} →
{C₂ : Type u_2} →
{D₁ : Type u_4} →
{D₂ : Type u_5} →
[inst : CategoryTheory.Category.{v_1, u_1} C₁] →
[inst_1 : CategoryTheory.Category.{v_2, u_2} C₂] →
[inst_2 : CategoryTheory.Category.{v_4, u_4} D₁] →
[inst_3 : CategoryTheory.Category.{v_5, u... | Given `w : TwoSquare T L R B`, one may obtain a 2-square `TwoSquare T' L R B'` if we
provide natural transformations `α : T ⟶ T'` and `β : B' ⟶ B`. | true |
Finsupp.cons_right_injective | Mathlib.Data.Finsupp.Fin | ∀ {n : ℕ} {M : Type u_1} [inst : Zero M] (y : M), Function.Injective (Finsupp.cons y) | null | true |
Lean.Server.RefInfo.mk.injEq | Lean.Server.References | ∀ (definition : Option Lean.Server.Reference) (usages : Array Lean.Server.Reference)
(definition_1 : Option Lean.Server.Reference) (usages_1 : Array Lean.Server.Reference),
({ definition := definition, usages := usages } = { definition := definition_1, usages := usages_1 }) =
(definition = definition_1 ∧ usages... | null | true |
MeasureTheory.VectorMeasure.absolutelyContinuous | Mathlib.MeasureTheory.VectorMeasure.Variation.Basic | ∀ {X : Type u_1} {V : Type u_2} {mX : MeasurableSpace X} [inst : TopologicalSpace V] [inst_1 : ENormedAddCommMonoid V]
[inst_2 : T2Space V] (μ : MeasureTheory.VectorMeasure X V), μ.AbsolutelyContinuous μ.ennrealVariation | null | true |
Subsemigroup.ext | Mathlib.Algebra.Group.Subsemigroup.Defs | ∀ {M : Type u_1} [inst : Mul M] {S T : Subsemigroup M}, (∀ (x : M), x ∈ S ↔ x ∈ T) → S = T | Two subsemigroups are equal if they have the same elements. | true |
UniqueFactorizationMonoid.factors | Mathlib.RingTheory.UniqueFactorizationDomain.Defs | {α : Type u_1} → [inst : CommMonoidWithZero α] → [UniqueFactorizationMonoid α] → α → Multiset α | Noncomputably determines the multiset of prime factors. | true |
_private.Init.Data.Range.Polymorphic.IntLemmas.0.Int.getElem!_toList_roc_ne_zero_iff._proof_1_2 | Init.Data.Range.Polymorphic.IntLemmas | ∀ {m n : ℤ} {i : ℕ}, ¬(i < (n - m).toNat ∧ m + 1 + ↑i ≠ 0 ↔ i < (n - m).toNat ∧ m + ↑i ≠ -1) → False | null | false |
WithBot.range_eq | Mathlib.Order.Set | ∀ {α : Type u_1} {β : Type u_2} (f : WithBot α → β), Set.range f = insert (f ⊥) (Set.range (f ∘ WithBot.some)) | null | true |
_private.Std.Data.Internal.List.Associative.0.Std.Internal.List.perm_filter_containsKey_of_perm._simp_1_1 | Std.Data.Internal.List.Associative | ∀ {α : Type u_1} (a : α) {l₁ l₂ : List α}, (a :: l₁).Perm (a :: l₂) = l₁.Perm l₂ | null | false |
Std.Tactic.BVDecide.instDecidableEqBVUnOp.decEq._proof_2 | Std.Tactic.BVDecide.Bitblast.BVExpr.Basic | ∀ (a : ℕ), Std.Tactic.BVDecide.BVUnOp.rotateRight a = Std.Tactic.BVDecide.BVUnOp.rotateRight a | null | false |
legendreSym.eq_neg_one_iff_not_one | Mathlib.NumberTheory.LegendreSymbol.Basic | ∀ (p : ℕ) [inst : Fact (Nat.Prime p)] {a : ℤ}, ↑a ≠ 0 → (legendreSym p a = -1 ↔ ¬legendreSym p a = 1) | null | true |
List.zipWith_zipWith_left._f | Mathlib.Data.List.Zip | ∀ {α : Type u} {β : Type u_1} {γ : Type u_2} {δ : Type u_3} {ε : Type u_4} (f : δ → γ → ε) (g : α → β → δ) (x : List α)
(f_1 :
List.below (motive := fun x =>
∀ (x_1 : List β) (x_2 : List γ),
List.zipWith f (List.zipWith g x x_1) x_2 = List.zipWith3 (fun a b c => f (g a b) c) x x_1 x_2)
x)
(x... | null | false |
StrictMono.neg | Mathlib.Algebra.Order.Group.Unbundled.Basic | ∀ {α : Type u} {β : Type u_1} [inst : AddGroup α] [inst_1 : Preorder α] [AddLeftStrictMono α] [AddRightStrictMono α]
[inst_4 : Preorder β] {f : β → α}, StrictMono f → StrictAnti fun x => -f x | null | true |
Lake.instDecodeVersionSemVerCore | Lake.Util.Version | Lake.DecodeVersion Lake.SemVerCore | null | true |
CategoryTheory.eqToHom_heq_id_cod._to_dual_1 | Mathlib.CategoryTheory.EqToHom | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] (X Y : C) (h : X = Y),
CategoryTheory.eqToHom ⋯ ≍ CategoryTheory.CategoryStruct.id Y | null | false |
Commute.mul_inv_cancel_assoc | Mathlib.Algebra.Group.Commute.Defs | ∀ {G : Type u_1} [inst : Group G] {a b : G}, Commute a b → a * (b * a⁻¹) = b | null | true |
Valued.integer.exists_norm_lt_one | Mathlib.Topology.Algebra.Valued.LocallyCompact | ∀ (K : Type u_1) [inst : NontriviallyNormedField K] [inst_1 : IsUltrametricDist K], ∃ x, 0 < ‖x‖ ∧ ‖x‖ < 1 | null | true |
_private.Batteries.Data.String.Lemmas.0.String.Pos.Raw.Valid.exists.match_1_1 | Batteries.Data.String.Lemmas | ∀ (motive : (x : String) → (x_1 : String.Pos.Raw) → String.Pos.Raw.Valid x x_1 → Prop) (x : String)
(x_1 : String.Pos.Raw) (x_2 : String.Pos.Raw.Valid x x_1),
(∀ (cs cs' : List Char), motive (String.ofList (cs ++ cs')) { byteIdx := String.utf8Len cs } ⋯) → motive x x_1 x_2 | null | false |
_private.Lean.Environment.0.Lean.Environment.ConstPromiseVal._sizeOf_inst | Lean.Environment | SizeOf Lean.Environment.ConstPromiseVal✝ | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.