name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
AlgCat.instCategory._proof_1 | Mathlib.Algebra.Category.AlgCat.Basic | ∀ (R : Type u_2) [inst : CommRing R] {X Y : AlgCat R} (f : X.Hom Y),
{ hom' := f.hom'.comp { hom' := AlgHom.id R ↑X }.hom' } = f | false |
CategoryTheory.MonoidalCategory.MonoidalRightAction.actionOfMonoidalFunctorToEndofunctor._proof_14 | Mathlib.CategoryTheory.Monoidal.Action.End | ∀ {C : Type u_2} {D : Type u_4} [inst : CategoryTheory.Category.{u_1, u_2} C]
[inst_1 : CategoryTheory.MonoidalCategory C] [inst_2 : CategoryTheory.Category.{u_3, u_4} D]
(F : CategoryTheory.Functor C (CategoryTheory.Functor D D)) [inst_3 : F.Monoidal] (c : C) {c' c'' : C} (f : c' ⟶ c'')
(d : D),
(F.map (CategoryTheory.MonoidalCategoryStruct.whiskerLeft c f)).app d =
CategoryTheory.CategoryStruct.comp ((CategoryTheory.Functor.Monoidal.μIso F c c').app d).symm.hom
(CategoryTheory.CategoryStruct.comp ((F.map f).app ((F.obj c).obj d))
((CategoryTheory.Functor.Monoidal.μIso F c c'').app d).symm.inv) | false |
ContinuousMonoidHom.compLeft._proof_1 | Mathlib.Topology.Algebra.Group.CompactOpen | ∀ {A : Type u_1} {B : Type u_3} (E : Type u_2) [inst : Monoid A] [inst_1 : Monoid B] [inst_2 : CommGroup E]
[inst_3 : TopologicalSpace A] [inst_4 : TopologicalSpace B] [inst_5 : TopologicalSpace E]
[inst_6 : IsTopologicalGroup E] (f : A →ₜ* B), ContinuousMonoidHom.comp 1 f = ContinuousMonoidHom.comp 1 f | false |
Finsupp.Lex.wellFounded | Mathlib.Data.Finsupp.WellFounded | ∀ {α : Type u_1} {N : Type u_2} [inst : Zero N] {r : α → α → Prop} {s : N → N → Prop},
(∀ ⦃n : N⦄, ¬s n 0) → WellFounded s → WellFounded (rᶜ ⊓ fun x1 x2 => x1 ≠ x2) → WellFounded (Finsupp.Lex r s) | true |
Lean.Elab.Tactic.Conv.evalUnfold | Lean.Elab.Tactic.Conv.Unfold | Lean.Elab.Tactic.Tactic | true |
ENNReal.add_lt_add_iff_right | Mathlib.Data.ENNReal.Operations | ∀ {a b c : ENNReal}, a ≠ ⊤ → (b + a < c + a ↔ b < c) | true |
PSigma.Lex.orderTop._proof_1 | Mathlib.Data.PSigma.Order | ∀ {ι : Type u_1} {α : ι → Type u_2} [inst : PartialOrder ι] [inst_1 : OrderTop ι] [inst_2 : (i : ι) → Preorder (α i)]
[inst_3 : OrderTop (α ⊤)] (a : ι) (b : α a), ⟨a, b⟩ ≤ ⟨⊤, ⊤⟩ | false |
Std.DTreeMap.Internal.Unit.RioSliceData._sizeOf_inst | Std.Data.DTreeMap.Internal.Zipper | (α : Type u) → {inst : Ord α} → [SizeOf α] → SizeOf (Std.DTreeMap.Internal.Unit.RioSliceData α) | false |
Bundle.Trivialization.coordChangeL | Mathlib.Topology.VectorBundle.Basic | (R : Type u_1) →
{B : Type u_2} →
{F : Type u_3} →
{E : B → Type u_4} →
[inst : Semiring R] →
[inst_1 : TopologicalSpace F] →
[inst_2 : TopologicalSpace B] →
[inst_3 : TopologicalSpace (Bundle.TotalSpace F E)] →
[inst_4 : AddCommMonoid F] →
[inst_5 : Module R F] →
[inst_6 : (x : B) → AddCommMonoid (E x)] →
[inst_7 : (x : B) → Module R (E x)] →
(e e' : Bundle.Trivialization F Bundle.TotalSpace.proj) →
[Bundle.Trivialization.IsLinear R e] → [Bundle.Trivialization.IsLinear R e'] → B → F ≃L[R] F | true |
Std.ExtDTreeMap.maxKeyD_le | Std.Data.ExtDTreeMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t : Std.ExtDTreeMap α β cmp} [inst : Std.TransCmp cmp],
t ≠ ∅ → ∀ {k fallback : α}, (cmp (t.maxKeyD fallback) k).isLE = true ↔ ∀ k' ∈ t, (cmp k' k).isLE = true | true |
Set.subset_symmDiff_union_symmDiff_left | Mathlib.Data.Set.SymmDiff | ∀ {α : Type u} {s t u : Set α}, Disjoint s t → u ⊆ symmDiff s u ∪ symmDiff t u | true |
HomologicalComplex.extend.d_eq | Mathlib.Algebra.Homology.Embedding.Extend | ∀ {ι : Type u_1} {c : ComplexShape ι} {C : Type u_3} [inst : CategoryTheory.Category.{v_1, u_3} C]
[inst_1 : CategoryTheory.Limits.HasZeroObject C] [inst_2 : CategoryTheory.Limits.HasZeroMorphisms C]
(K : HomologicalComplex C c) {i j : Option ι} {a b : ι} (hi : i = some a) (hj : j = some b),
HomologicalComplex.extend.d K i j =
CategoryTheory.CategoryStruct.comp (HomologicalComplex.extend.XIso K hi).hom
(CategoryTheory.CategoryStruct.comp (K.d a b) (HomologicalComplex.extend.XIso K hj).inv) | true |
ContinuousMap.tendsto_iff_tendstoLocallyUniformly | Mathlib.Topology.UniformSpace.CompactConvergence | ∀ {α : Type u₁} {β : Type u₂} [inst : TopologicalSpace α] [inst_1 : UniformSpace β] {f : C(α, β)} {ι : Type u₃}
{p : Filter ι} {F : ι → C(α, β)} [WeaklyLocallyCompactSpace α],
Filter.Tendsto F p (nhds f) ↔ TendstoLocallyUniformly (fun i a => (F i) a) (⇑f) p | true |
CompletelyRegularSpace.mk | Mathlib.Topology.Separation.CompletelyRegular | ∀ {X : Type u} [inst : TopologicalSpace X],
(∀ (x : X) (K : Set X), IsClosed K → x ∉ K → ∃ f, Continuous f ∧ f x = 0 ∧ Set.EqOn f 1 K) → CompletelyRegularSpace X | true |
BitVec.carry_extractLsb'_eq_carry | Init.Data.BitVec.Bitblast | ∀ {w i len : ℕ},
i < len →
∀ {x y : BitVec w} {b : Bool},
BitVec.carry i (BitVec.extractLsb' 0 len x) (BitVec.extractLsb' 0 len y) b = BitVec.carry i x y b | true |
CategoryTheory.Bicategory.InducedBicategory.bicategory._proof_2 | Mathlib.CategoryTheory.Bicategory.InducedBicategory | ∀ {B : Type u_1} {C : Type u_2} [inst : CategoryTheory.Bicategory C] {F : B → C}
{a b c : CategoryTheory.Bicategory.InducedBicategory C F} (f : a ⟶ b) (g : b ⟶ c),
CategoryTheory.Bicategory.InducedBicategory.mkHom₂
(CategoryTheory.Bicategory.whiskerLeft f.hom (CategoryTheory.CategoryStruct.id g).hom) =
CategoryTheory.CategoryStruct.id (CategoryTheory.CategoryStruct.comp f g) | false |
Flag.ofIsMaxChain._proof_2 | Mathlib.Order.Preorder.Chain | ∀ {α : Type u_1} [inst : LE α] (c : Set α),
IsMaxChain (fun x1 x2 => x1 ≤ x2) c → ∀ ⦃t : Set α⦄, IsChain (fun x1 x2 => x1 ≤ x2) t → c ⊆ t → c = t | false |
Mathlib.Tactic.IntervalCases.Bound._sizeOf_1 | Mathlib.Tactic.IntervalCases | Mathlib.Tactic.IntervalCases.Bound → ℕ | false |
TopCommRingCat.isCommRing | Mathlib.Topology.Category.TopCommRingCat | (self : TopCommRingCat) → CommRing self.α | true |
mulActionSphereClosedBall._proof_2 | Mathlib.Analysis.Normed.Module.Ball.Action | ∀ {𝕜 : Type u_2} {E : Type u_1} [inst : NormedField 𝕜] [inst_1 : SeminormedAddCommGroup E] [inst_2 : NormedSpace 𝕜 E]
{r : ℝ} (x : ↑(Metric.closedBall 0 r)), 1 • x = x | false |
Submonoid.map.congr_simp | Mathlib.Algebra.Group.Submonoid.Operations | ∀ {M : Type u_1} {N : Type u_2} [inst : MulOneClass M] [inst_1 : MulOneClass N] {F : Type u_4} [inst_2 : FunLike F M N]
[mc : MonoidHomClass F M N] (f f_1 : F),
f = f_1 → ∀ (S S_1 : Submonoid M), S = S_1 → Submonoid.map f S = Submonoid.map f_1 S_1 | true |
CategoryTheory.Limits.idZeroEquivIsoZero_apply_hom | Mathlib.CategoryTheory.Limits.Shapes.ZeroMorphisms | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasZeroObject C]
[inst_2 : CategoryTheory.Limits.HasZeroMorphisms C] (X : C) (h : CategoryTheory.CategoryStruct.id X = 0),
((CategoryTheory.Limits.idZeroEquivIsoZero X) h).hom = 0 | true |
divisionRingOfFiniteDimensional._proof_15 | Mathlib.LinearAlgebra.FiniteDimensional.Basic | ∀ (F : Type u_2) (K : Type u_1) [inst : Field F] [inst_1 : Ring K] [inst_2 : IsDomain K] [inst_3 : Algebra F K]
[inst_4 : FiniteDimensional F K], (if H : 0 = 0 then 0 else Classical.choose ⋯) = 0 | false |
CentroidHom.instFunLike._proof_1 | Mathlib.Algebra.Ring.CentroidHom | ∀ {α : Type u_1} [inst : NonUnitalNonAssocSemiring α] (f g : CentroidHom α),
(fun f => (↑f.toAddMonoidHom).toFun) f = (fun f => (↑f.toAddMonoidHom).toFun) g → f = g | false |
CommGroupWithZero.ctorIdx | Mathlib.Algebra.GroupWithZero.Defs | {G₀ : Type u_2} → CommGroupWithZero G₀ → ℕ | false |
HomologicalComplex.units_smul_f_apply | Mathlib.Algebra.Homology.Linear | ∀ {R : Type u_1} [inst : Semiring R] {C : Type u_2} [inst_1 : CategoryTheory.Category.{v_1, u_2} C]
[inst_2 : CategoryTheory.Preadditive C] [inst_3 : CategoryTheory.Linear R C] {ι : Type u_4} {c : ComplexShape ι}
{X Y : HomologicalComplex C c} (r : Rˣ) (f : X ⟶ Y) (n : ι), (r • f).f n = r • f.f n | true |
CategoryTheory.Limits.IsImage.lift | Mathlib.CategoryTheory.Limits.Shapes.Images | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{X Y : C} →
{f : X ⟶ Y} →
{F : CategoryTheory.Limits.MonoFactorisation f} →
CategoryTheory.Limits.IsImage F → (F' : CategoryTheory.Limits.MonoFactorisation f) → F.I ⟶ F'.I | true |
Std.Sat.AIG.Entrypoint.ctorIdx | Std.Sat.AIG.Basic | {α : Type} → {inst : DecidableEq α} → {inst_1 : Hashable α} → Std.Sat.AIG.Entrypoint α → ℕ | false |
_private.Mathlib.Tactic.ComputeAsymptotics.Multiseries.Defs.0.ComputeAsymptotics.MultiseriesExpansion.Multiseries.destruct_eq_destruct_map.match_1 | Mathlib.Tactic.ComputeAsymptotics.Multiseries.Defs | {basis_hd : ℝ → ℝ} →
{basis_tl : ComputeAsymptotics.Basis} →
(motive :
ℝ ×
ComputeAsymptotics.MultiseriesExpansion basis_tl ×
ComputeAsymptotics.MultiseriesExpansion.Multiseries basis_hd basis_tl →
Sort u_1) →
(x :
ℝ ×
ComputeAsymptotics.MultiseriesExpansion basis_tl ×
ComputeAsymptotics.MultiseriesExpansion.Multiseries basis_hd basis_tl) →
((exp : ℝ) →
(coef : ComputeAsymptotics.MultiseriesExpansion basis_tl) →
(tl : ComputeAsymptotics.MultiseriesExpansion.Multiseries basis_hd basis_tl) → motive (exp, coef, tl)) →
motive x | false |
CategoryTheory.Limits.Cone.equivalenceOfReindexing | Mathlib.CategoryTheory.Limits.Cones | {J : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} J] →
{K : Type u₂} →
[inst_1 : CategoryTheory.Category.{v₂, u₂} K] →
{C : Type u₃} →
[inst_2 : CategoryTheory.Category.{v₃, u₃} C] →
{F : CategoryTheory.Functor J C} →
{G : CategoryTheory.Functor K C} →
(e : K ≌ J) → (e.functor.comp F ≅ G) → (CategoryTheory.Limits.Cone F ≌ CategoryTheory.Limits.Cone G) | true |
Lean.Unhygienic.Context.mk.inj | Lean.Hygiene | ∀ {ref : Lean.Syntax} {scope : Lean.MacroScope} {ref_1 : Lean.Syntax} {scope_1 : Lean.MacroScope},
{ ref := ref, scope := scope } = { ref := ref_1, scope := scope_1 } → ref = ref_1 ∧ scope = scope_1 | true |
Std.DHashMap.insert_eq_insert | Std.Data.DHashMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {x : BEq α} {x_1 : Hashable α} {m : Std.DHashMap α β} {p : (a : α) × β a},
insert p m = m.insert p.fst p.snd | true |
CategoryTheory.Pseudofunctor.DescentData'.pullHom'_self'._auto_1 | Mathlib.CategoryTheory.Sites.Descent.DescentDataPrime | Lean.Syntax | false |
Std.DHashMap.Equiv.symm | Std.Data.DHashMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {x : BEq α} {x_1 : Hashable α} {m₁ m₂ : Std.DHashMap α β}, m₁.Equiv m₂ → m₂.Equiv m₁ | true |
UInt8.toFin_inj | Init.Data.UInt.Lemmas | ∀ {a b : UInt8}, a.toFin = b.toFin ↔ a = b | true |
Representation.IsIrreducible.finrank_intertwiningMap_self | Mathlib.RepresentationTheory.Irreducible | ∀ {G : Type u_1} {k : Type u_2} {V : Type u_3} [inst : Monoid G] [inst_1 : Field k] [inst_2 : AddCommGroup V]
[inst_3 : Module k V] (ρ : Representation k G V) [ρ.IsIrreducible] [FiniteDimensional k V] [IsAlgClosed k],
Module.finrank k (ρ.IntertwiningMap ρ) = 1 | true |
Set.encard_exchange' | Mathlib.Data.Set.Card | ∀ {α : Type u_1} {s : Set α} {a b : α}, a ∉ s → b ∈ s → (insert a s \ {b}).encard = s.encard | true |
Std.IterM.dropWhileWithPostcondition | Std.Data.Iterators.Combinators.Monadic.DropWhile | {α : Type w} →
{m : Type w → Type w'} →
{β : Type w} → (P : β → Std.Iterators.PostconditionT m (ULift.{w, 0} Bool)) → Std.IterM m β → Std.IterM m β | true |
_private.Init.Data.FloatArray.Basic.0.FloatArray.forIn.loop._proof_3 | Init.Data.FloatArray.Basic | ∀ (as : FloatArray) (i : ℕ), as.size - 1 < as.size → as.size - 1 - i < as.size | false |
Matrix.self_mul_conjTranspose_mulVec_eq_zero | Mathlib.LinearAlgebra.Matrix.DotProduct | ∀ {m : Type u_1} {n : Type u_2} {R : Type u_4} [inst : Fintype m] [inst_1 : Fintype n] [inst_2 : PartialOrder R]
[inst_3 : NonUnitalRing R] [inst_4 : StarRing R] [StarOrderedRing R] [NoZeroDivisors R] (A : Matrix m n R)
(v : m → R), (A * A.conjTranspose).mulVec v = 0 ↔ A.conjTranspose.mulVec v = 0 | true |
Rat.le_coe_toNNRat | Mathlib.Data.NNRat.Defs | ∀ (q : ℚ), q ≤ ↑q.toNNRat | true |
_private.Init.Grind.Ordered.Rat.0.Lean.Grind.instOrderedAddRat._simp_1 | Init.Grind.Ordered.Rat | ∀ {a b c : ℚ}, (c + a ≤ c + b) = (a ≤ b) | false |
Aesop.RulePattern.mk | Aesop.RulePattern | Lean.Meta.AbstractMVarsResult → Array (Option ℕ) → Array (Option ℕ) → Array Lean.Meta.DiscrTree.Key → Aesop.RulePattern | true |
_private.Std.Time.Format.Basic.0.Std.Time.formatMarkerShort.match_1 | Std.Time.Format.Basic | (motive : Std.Time.HourMarker → Sort u_1) →
(marker : Std.Time.HourMarker) →
(Unit → motive Std.Time.HourMarker.am) → (Unit → motive Std.Time.HourMarker.pm) → motive marker | false |
_private.Mathlib.CategoryTheory.Limits.Types.Images.0.CategoryTheory.Limits.Types.surjective_π_app_zero_of_surjective_map_aux.match_1_1 | Mathlib.CategoryTheory.Limits.Types.Images | (motive : ℕᵒᵖ → Sort u_1) → (x : ℕᵒᵖ) → ((n : ℕ) → motive (Opposite.op n)) → motive x | false |
WeierstrassCurve.toCharTwoJNeZeroNF | Mathlib.AlgebraicGeometry.EllipticCurve.NormalForms | {F : Type u_2} → [inst : Field F] → (W : WeierstrassCurve F) → W.a₁ ≠ 0 → WeierstrassCurve.VariableChange F | true |
Nat.psub | Mathlib.Data.Nat.PSub | ℕ → ℕ → Option ℕ | true |
Quiver.Path.addWeightOfEPs_cons | Mathlib.Combinatorics.Quiver.Path.Weight | ∀ {V : Type u_1} [inst : Quiver V] {R : Type u_2} [inst_1 : AddMonoid R] (w : V → V → R) {a b c : V}
(p : Quiver.Path a b) (e : b ⟶ c), Quiver.Path.addWeightOfEPs w (p.cons e) = Quiver.Path.addWeightOfEPs w p + w b c | true |
PreAbstractSimplicialComplex.instMin | Mathlib.AlgebraicTopology.SimplicialComplex.Basic | (ι : Type u_1) → Min (PreAbstractSimplicialComplex ι) | true |
AffineEquiv.equivLike | Mathlib.LinearAlgebra.AffineSpace.AffineEquiv | {k : Type u_1} →
{P₁ : Type u_2} →
{P₂ : Type u_3} →
{V₁ : Type u_6} →
{V₂ : Type u_7} →
[inst : Ring k] →
[inst_1 : AddCommGroup V₁] →
[inst_2 : AddCommGroup V₂] →
[inst_3 : Module k V₁] →
[inst_4 : Module k V₂] →
[inst_5 : AddTorsor V₁ P₁] → [inst_6 : AddTorsor V₂ P₂] → EquivLike (P₁ ≃ᵃ[k] P₂) P₁ P₂ | true |
_private.Lean.Server.FileWorker.RequestHandling.0.Lean.Server.FileWorker.findGoalsAt?.getPositions | Lean.Server.FileWorker.RequestHandling | Lean.Syntax → Option (String.Pos.Raw × String.Pos.Raw × String.Pos.Raw) | true |
UpperSet.mem_iInf_iff | Mathlib.Order.UpperLower.CompleteLattice | ∀ {α : Type u_1} {ι : Sort u_4} [inst : LE α] {a : α} {f : ι → UpperSet α}, a ∈ ⨅ i, f i ↔ ∃ i, a ∈ f i | true |
ModularGroup.denom_apply | Mathlib.Analysis.Complex.UpperHalfPlane.MoebiusAction | ∀ (g : Matrix.SpecialLinearGroup (Fin 2) ℤ) (z : UpperHalfPlane),
UpperHalfPlane.denom (Matrix.SpecialLinearGroup.toGL ((Matrix.SpecialLinearGroup.map (Int.castRingHom ℝ)) g)) ↑z =
↑(↑g 1 0) * ↑z + ↑(↑g 1 1) | true |
Nat.lt.base | Init.Data.Nat.Basic | ∀ (n : ℕ), n < n.succ | true |
finprod_apply | Mathlib.Algebra.BigOperators.Finprod | ∀ {N : Type u_6} [inst : CommMonoid N] {α : Type u_7} {ι : Type u_8} {f : ι → α → N},
Function.HasFiniteMulSupport f → ∀ (a : α), (∏ᶠ (i : ι), f i) a = ∏ᶠ (i : ι), f i a | true |
_private.Batteries.Data.RBMap.WF.0.Batteries.RBNode.Ordered.ins.match_1_1 | Batteries.Data.RBMap.WF | ∀ {α : Type u_1} {cmp : α → α → Ordering} (motive : (x : Batteries.RBNode α) → Batteries.RBNode.Ordered cmp x → Prop)
(x : Batteries.RBNode α) (x_1 : Batteries.RBNode.Ordered cmp x),
(∀ (x : Batteries.RBNode.Ordered cmp Batteries.RBNode.nil), motive Batteries.RBNode.nil x) →
(∀ (a : Batteries.RBNode α) (y : α) (b : Batteries.RBNode α)
(ay : Batteries.RBNode.All (fun x => Batteries.RBNode.cmpLT cmp x y) a)
(yb : Batteries.RBNode.All (fun x => Batteries.RBNode.cmpLT cmp y x) b) (ha : Batteries.RBNode.Ordered cmp a)
(hb : Batteries.RBNode.Ordered cmp b), motive (Batteries.RBNode.node Batteries.RBColor.red a y b) ⋯) →
(∀ (a : Batteries.RBNode α) (y : α) (b : Batteries.RBNode α)
(ay : Batteries.RBNode.All (fun x => Batteries.RBNode.cmpLT cmp x y) a)
(yb : Batteries.RBNode.All (fun x => Batteries.RBNode.cmpLT cmp y x) b) (ha : Batteries.RBNode.Ordered cmp a)
(hb : Batteries.RBNode.Ordered cmp b), motive (Batteries.RBNode.node Batteries.RBColor.black a y b) ⋯) →
motive x x_1 | false |
_private.Mathlib.Combinatorics.SimpleGraph.Connectivity.Subgraph.0.SimpleGraph.Walk.IsCycle.neighborSet_toSubgraph_endpoint._simp_1_5 | Mathlib.Combinatorics.SimpleGraph.Connectivity.Subgraph | ∀ {α : Type u_1} {a b c d : α}, (s(a, b) = s(c, d)) = Sym2.Rel α (a, b) (c, d) | false |
AddUnits.neg_mul_left | Mathlib.Algebra.Ring.Invertible | ∀ {R : Type u_1} [inst : NonUnitalNonAssocSemiring R] {x : AddUnits R} {y : R}, -x.mulLeft y = (-x).mulLeft y | true |
_private.Lean.Data.RBMap.0.Lean.RBMap.erase.match_1 | Lean.Data.RBMap | {α : Type u_1} →
{β : Type u_2} →
{cmp : α → α → Ordering} →
(motive : Lean.RBMap α β cmp → α → Sort u_3) →
(x : Lean.RBMap α β cmp) →
(x_1 : α) →
((t : Lean.RBNode α fun x => β) → (w : Lean.RBNode.WellFormed cmp t) → (k : α) → motive ⟨t, w⟩ k) →
motive x x_1 | false |
MeasureTheory.weightedSMul_union' | Mathlib.MeasureTheory.Integral.Bochner.L1 | ∀ {α : Type u_1} {F : Type u_3} [inst : NormedAddCommGroup F] [inst_1 : NormedSpace ℝ F] {m : MeasurableSpace α}
{μ : MeasureTheory.Measure α} (s t : Set α),
MeasurableSet t →
μ s ≠ ⊤ →
μ t ≠ ⊤ →
Disjoint s t →
MeasureTheory.weightedSMul μ (s ∪ t) = MeasureTheory.weightedSMul μ s + MeasureTheory.weightedSMul μ t | true |
AlgebraicGeometry.IsAffine.casesOn | Mathlib.AlgebraicGeometry.AffineScheme | {X : AlgebraicGeometry.Scheme} →
{motive : AlgebraicGeometry.IsAffine X → Sort u} →
(t : AlgebraicGeometry.IsAffine X) → ((affine : CategoryTheory.IsIso X.toSpecΓ) → motive ⋯) → motive t | false |
Std.ExtDHashMap.Const.getD_union | Std.Data.ExtDHashMap.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {β : Type v} {m₁ m₂ : Std.ExtDHashMap α fun x => β} [inst : EquivBEq α]
[inst_1 : LawfulHashable α] {k : α} {fallback : β},
Std.ExtDHashMap.Const.getD (m₁.union m₂) k fallback =
Std.ExtDHashMap.Const.getD m₂ k (Std.ExtDHashMap.Const.getD m₁ k fallback) | true |
Filter.prod_mono_right | Mathlib.Order.Filter.Prod | ∀ {α : Type u_1} {β : Type u_2} (f : Filter α) {g₁ g₂ : Filter β}, g₁ ≤ g₂ → f ×ˢ g₁ ≤ f ×ˢ g₂ | true |
Lean.Meta.Grind.Order.Weight.casesOn | Lean.Meta.Tactic.Grind.Order.Types | {motive : Lean.Meta.Grind.Order.Weight → Sort u} →
(t : Lean.Meta.Grind.Order.Weight) → ((k : ℤ) → (strict : Bool) → motive { k := k, strict := strict }) → motive t | false |
_private.Mathlib.NumberTheory.NumberField.CanonicalEmbedding.NormLeOne.0.NumberField.mixedEmbedding.fundamentalCone.expMap_sum._simp_1_1 | Mathlib.NumberTheory.NumberField.CanonicalEmbedding.NormLeOne | ∀ {α : Type u_1} (s : Finset α) (f : α → ℝ), ∏ x ∈ s, Real.exp (f x) = Real.exp (∑ x ∈ s, f x) | false |
ONote.split._sunfold | Mathlib.SetTheory.Ordinal.Notation | ONote → ONote × ℕ | false |
Lean.Doc.DocScope.local.sizeOf_spec | Lean.Elab.DocString.Builtin.Scopes | sizeOf Lean.Doc.DocScope.local = 1 | true |
Std.Time.PlainDateTime.instHSubDuration | Std.Time.DateTime | HSub Std.Time.PlainDateTime Std.Time.PlainDateTime Std.Time.Duration | true |
_private.Std.Data.DTreeMap.Internal.WF.Lemmas.0.Std.DTreeMap.Internal.Impl.entryAtIdx?_eq_getElem?._simp_1_3 | Std.Data.DTreeMap.Internal.WF.Lemmas | ∀ {a b : ℕ}, (compare a b = Ordering.eq) = (a = b) | false |
ArchimedeanOrder.of | Mathlib.Algebra.Order.Archimedean.Class | {M : Type u_1} → M ≃ ArchimedeanOrder M | true |
WriterT.uliftable' | Mathlib.Control.ULiftable | {w : Type u_3} →
{w' : Type u_4} →
{m : Type u_3 → Type u_5} →
{m' : Type u_4 → Type u_6} → [ULiftable m m'] → w ≃ w' → ULiftable (WriterT w m) (WriterT w' m') | true |
USize.ofBitVec.sizeOf_spec | Init.SizeOf | ∀ (toBitVec : BitVec System.Platform.numBits), sizeOf { toBitVec := toBitVec } = 1 + sizeOf toBitVec | true |
CommRingCat.instCategory._proof_1 | Mathlib.Algebra.Category.Ring.Basic | ∀ {X Y : CommRingCat} (f : X.Hom Y), { hom' := f.hom'.comp { hom' := RingHom.id ↑X }.hom' } = f | false |
mul_eq_zero_iff_right | Mathlib.Algebra.GroupWithZero.Defs | ∀ {M₀ : Type u_1} [inst : MulZeroClass M₀] [NoZeroDivisors M₀] {a b : M₀}, b ≠ 0 → (a * b = 0 ↔ a = 0) | true |
WithLp.instProdPseudoMetricSpace | Mathlib.Analysis.Normed.Lp.ProdLp | (p : ENNReal) →
(α : Type u_2) →
(β : Type u_3) →
[hp : Fact (1 ≤ p)] → [PseudoMetricSpace α] → [PseudoMetricSpace β] → PseudoMetricSpace (WithLp p (α × β)) | true |
CategoryTheory.Limits.LimitPresentation.changeDiag | Mathlib.CategoryTheory.Limits.Presentation | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{J : Type w} →
[inst_1 : CategoryTheory.Category.{t, w} J] →
{X : C} →
(P : CategoryTheory.Limits.LimitPresentation J X) →
{F : CategoryTheory.Functor J C} → (F ≅ P.diag) → CategoryTheory.Limits.LimitPresentation J X | true |
Stream'.Seq.cons_not_terminatedAt_zero._simp_1 | Mathlib.Data.Seq.Defs | ∀ {α : Type u} {x : α} {s : Stream'.Seq α}, (Stream'.Seq.cons x s).TerminatedAt 0 = False | false |
Denumerable | Mathlib.Logic.Denumerable | Type u_3 → Type u_3 | true |
BitVec.toInt_sshiftRight' | Init.Data.BitVec.Lemmas | ∀ {w : ℕ} {x y : BitVec w}, (x.sshiftRight' y).toInt = x.toInt >>> y.toNat | true |
TopologicalSpace.Opens.map_id_obj | Mathlib.Topology.Category.TopCat.Opens | ∀ {X : TopCat} (U : TopologicalSpace.Opens ↑X),
(TopologicalSpace.Opens.map (CategoryTheory.CategoryStruct.id X)).obj U = U | true |
_private.Mathlib.Tactic.NormNum.Ineq.0.Mathlib.Meta.NormNum.evalLT.core.nnratArm | Mathlib.Tactic.NormNum.Ineq | {u : Lean.Level} →
{α : Q(Type u)} →
(lα : Q(LT «$α»)) →
{a b : Q(«$α»)} →
Mathlib.Meta.NormNum.Result a →
Mathlib.Meta.NormNum.Result b →
have e := q(«$a» < «$b»);
Lean.MetaM (Mathlib.Meta.NormNum.Result e) | true |
Std.Internal.IO.Async.Signal.sigttou.elim | Std.Internal.Async.Signal | {motive : Std.Internal.IO.Async.Signal → Sort u} →
(t : Std.Internal.IO.Async.Signal) → t.ctorIdx = 14 → motive Std.Internal.IO.Async.Signal.sigttou → motive t | false |
normSeminorm | Mathlib.Analysis.Seminorm | (𝕜 : Type u_3) →
(E : Type u_7) →
[inst : NormedField 𝕜] → [inst_1 : SeminormedAddCommGroup E] → [inst_2 : NormedSpace 𝕜 E] → Seminorm 𝕜 E | true |
_private.Mathlib.Algebra.GroupWithZero.Basic.0.zero_pow.match_1_1 | Mathlib.Algebra.GroupWithZero.Basic | ∀ (motive : (x : ℕ) → x ≠ 0 → Prop) (x : ℕ) (x_1 : x ≠ 0), (∀ (n : ℕ) (x : n + 1 ≠ 0), motive n.succ x) → motive x x_1 | false |
CategoryTheory.ShortComplex.Splitting.map | Mathlib.Algebra.Homology.ShortComplex.Exact | {C : Type u_1} →
{D : Type u_2} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
[inst_1 : CategoryTheory.Category.{v_2, u_2} D] →
[inst_2 : CategoryTheory.Preadditive C] →
[inst_3 : CategoryTheory.Preadditive D] →
{S : CategoryTheory.ShortComplex C} →
S.Splitting → (F : CategoryTheory.Functor C D) → [inst_4 : F.Additive] → (S.map F).Splitting | true |
Lean.PersistentHashMap.Node.brecOn_3 | Lean.Data.PersistentHashMap | {α : Type u} →
{β : Type v} →
{motive_1 : Lean.PersistentHashMap.Node α β → Sort u_1} →
{motive_2 : Array (Lean.PersistentHashMap.Entry α β (Lean.PersistentHashMap.Node α β)) → Sort u_1} →
{motive_3 : List (Lean.PersistentHashMap.Entry α β (Lean.PersistentHashMap.Node α β)) → Sort u_1} →
{motive_4 : Lean.PersistentHashMap.Entry α β (Lean.PersistentHashMap.Node α β) → Sort u_1} →
(t : Lean.PersistentHashMap.Entry α β (Lean.PersistentHashMap.Node α β)) →
((t : Lean.PersistentHashMap.Node α β) → t.below → motive_1 t) →
((t : Array (Lean.PersistentHashMap.Entry α β (Lean.PersistentHashMap.Node α β))) →
Lean.PersistentHashMap.Node.below_1 t → motive_2 t) →
((t : List (Lean.PersistentHashMap.Entry α β (Lean.PersistentHashMap.Node α β))) →
Lean.PersistentHashMap.Node.below_2 t → motive_3 t) →
((t : Lean.PersistentHashMap.Entry α β (Lean.PersistentHashMap.Node α β)) →
Lean.PersistentHashMap.Node.below_3 t → motive_4 t) →
motive_4 t | false |
_private.Mathlib.Analysis.InnerProductSpace.Reproducing.0.RKHS.isSelfAdjoint_finsuppSum | 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] [inst_3 : CompleteSpace V] {K : Matrix X X (V →L[𝕜] V)},
K.IsHermitian → ∀ (f : X →₀ V →L[𝕜] V), IsSelfAdjoint (f.sum fun i xi => f.sum fun j xj => star xi * K i j * xj) | true |
MeasureTheory.L1.SimpleFunc.setToL1SCLM.congr_simp | Mathlib.MeasureTheory.Integral.SetToL1 | ∀ (α : Type u_1) (E : Type u_2) {F : Type u_3} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E]
[inst_2 : NormedAddCommGroup F] [inst_3 : NormedSpace ℝ F] {m : MeasurableSpace α} (μ : MeasureTheory.Measure α)
{T T_1 : Set α → E →L[ℝ] F} (e_T : T = T_1) {C C_1 : ℝ} (e_C : C = C_1)
(hT : MeasureTheory.DominatedFinMeasAdditive μ T C),
MeasureTheory.L1.SimpleFunc.setToL1SCLM α E μ hT = MeasureTheory.L1.SimpleFunc.setToL1SCLM α E μ ⋯ | true |
Subgroup.prod_eq_bot_iff._simp_2 | Mathlib.Algebra.Group.Subgroup.Basic | ∀ {G : Type u_1} [inst : Group G] {N : Type u_5} [inst_1 : Group N] {H : Subgroup G} {K : Subgroup N},
(H.prod K = ⊥) = (H = ⊥ ∧ K = ⊥) | false |
specializingMap_iff_isClosed_image_closure_singleton | Mathlib.Topology.Inseparable | ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] {f : X → Y},
Continuous f → (SpecializingMap f ↔ ∀ (x : X), IsClosed (f '' closure {x})) | true |
Module.Basis.traceDual_traceDual | Mathlib.RingTheory.Trace.Basic | ∀ {K : Type u_4} {L : Type u_5} [inst : Field K] [inst_1 : Field L] [inst_2 : Algebra K L] {ι : Type w}
[inst_3 : FiniteDimensional K L] [inst_4 : Algebra.IsSeparable K L] [inst_5 : Finite ι] [inst_6 : DecidableEq ι]
(b : Module.Basis ι K L), b.traceDual.traceDual = b | true |
Lean.Meta.Match.Pattern.val.sizeOf_spec | Lean.Meta.Match.Basic | ∀ (e : Lean.Expr), sizeOf (Lean.Meta.Match.Pattern.val e) = 1 + sizeOf e | true |
MeasureTheory.MemLp.of_fst_of_snd_prodLp | Mathlib.MeasureTheory.SpecificCodomains.WithLp | ∀ {X : Type u_1} {mX : MeasurableSpace X} {μ : MeasureTheory.Measure X} {p q : ENNReal} [inst : Fact (1 ≤ q)]
{E : Type u_2} {F : Type u_3} [inst_1 : NormedAddCommGroup E] [inst_2 : NormedAddCommGroup F]
{f : X → WithLp q (E × F)},
MeasureTheory.MemLp (fun x => (f x).fst) p μ ∧ MeasureTheory.MemLp (fun x => (f x).snd) p μ →
MeasureTheory.MemLp f p μ | true |
Delone.DeloneSet.mapIsometry_refl | Mathlib.Analysis.AperiodicOrder.Delone.Basic | ∀ {X : Type u_1} [inst : MetricSpace X] (D : Delone.DeloneSet X),
(Delone.DeloneSet.mapIsometry (IsometryEquiv.refl X)) D = D | true |
_private.Lean.Server.FileWorker.WidgetRequests.0.Lean.Widget.TaggedTextHighlightState.mk.inj | Lean.Server.FileWorker.WidgetRequests | ∀ {query : String} {ms : Array String.Pos.Raw} {p : String.Pos.Raw} {anyHighlight : Bool} {query_1 : String}
{ms_1 : Array String.Pos.Raw} {p_1 : String.Pos.Raw} {anyHighlight_1 : Bool},
{ query := query, ms := ms, p := p, anyHighlight := anyHighlight } =
{ query := query_1, ms := ms_1, p := p_1, anyHighlight := anyHighlight_1 } →
query = query_1 ∧ ms = ms_1 ∧ p = p_1 ∧ anyHighlight = anyHighlight_1 | true |
Set.inv_mem_center | Mathlib.Algebra.Group.Center | ∀ {M : Type u_1} [inst : DivisionMonoid M] {a : M}, a ∈ Set.center M → a⁻¹ ∈ Set.center M | true |
QuotientGroup.mulEquivPiModRangePowMonoidHom._proof_1 | Mathlib.GroupTheory.QuotientGroup.Basic | ∀ {ι : Type u_1} (A : ι → Type u_2) [inst : (i : ι) → CommGroup (A i)] (n : ℕ), (fun x => ↑(1 x)) = 1 | false |
MeasureTheory.Measure.pi.isOpenPosMeasure | Mathlib.MeasureTheory.Constructions.Pi | ∀ {ι : Type u_1} {α : ι → Type u_3} [inst : Fintype ι] [inst_1 : (i : ι) → MeasurableSpace (α i)]
(μ : (i : ι) → MeasureTheory.Measure (α i)) [∀ (i : ι), MeasureTheory.SigmaFinite (μ i)]
[inst_3 : (i : ι) → TopologicalSpace (α i)] [∀ (i : ι), (μ i).IsOpenPosMeasure],
(MeasureTheory.Measure.pi μ).IsOpenPosMeasure | true |
LocallyConstant.indicator_of_notMem | Mathlib.Topology.LocallyConstant.Basic | ∀ {X : Type u_1} [inst : TopologicalSpace X] {R : Type u_5} [inst_1 : Zero R] {U : Set X} (f : LocallyConstant X R)
{a : X} (hU : IsClopen U), a ∉ U → (f.indicator hU) a = 0 | true |
Lean.Grind.instCommRingUSize._proof_5 | Init.GrindInstances.Ring.UInt | ∀ (n : ℕ) (a : USize), ↑↑n * a = ↑n * a | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.