name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11.5k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
_private.Mathlib.RingTheory.Smooth.NoetherianDescent.0.Algebra.Smooth.DescentAux.q | Mathlib.RingTheory.Smooth.NoetherianDescent | {A : Type u} →
{B : Type u_2} →
[inst : CommRing A] →
[inst_1 : CommRing B] →
[inst_2 : Algebra A B] →
(self : Algebra.Smooth.DescentAux✝ A B) →
Algebra.Smooth.DescentAux.vars✝ self →
MvPolynomial (Algebra.Smooth.DescentAux.rels✝ self) (Algebra.Smooth.DescentAux.P... | null | true |
Finset.notMem_mono | Mathlib.Data.Finset.Defs | ∀ {α : Type u_1} {s t : Finset α}, s ⊆ t → ∀ {a : α}, a ∉ t → a ∉ s | null | true |
TopCat.coe_of_of | Mathlib.Topology.Category.TopCat.Basic | ∀ {X Y : Type u} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] {f : C(X, Y)}
{x : (CategoryTheory.forget TopCat).obj (TopCat.of X)}, (TopCat.ofHom f) x = f x | Replace a function coercion for a morphism `TopCat.of X ⟶ TopCat.of Y` with the definitionally
equal function coercion for a continuous map `C(X, Y)`.
| true |
_private.Mathlib.Algebra.Module.ZLattice.Covolume.0._auto_28 | Mathlib.Algebra.Module.ZLattice.Covolume | Lean.Syntax | null | false |
Rep.equivalenceModuleMonoidAlgebra | Mathlib.RepresentationTheory.Rep.Iso | {k : Type u} →
{G : Type v} → [inst : CommRing k] → [inst_1 : Monoid G] → Rep.{w, u, v} k G ≌ ModuleCat (MonoidAlgebra k G) | The categorical equivalence `Rep k G ≌ ModuleCat k[G]`. | true |
Turing.ListBlank.modifyNth._unsafe_rec | Mathlib.Computability.TuringMachine.Tape | {Γ : Type u_1} → [inst : Inhabited Γ] → (Γ → Γ) → ℕ → Turing.ListBlank Γ → Turing.ListBlank Γ | null | false |
CategoryTheory.NonPreadditiveAbelian.isIso_factorThruImage | Mathlib.CategoryTheory.Abelian.NonPreadditive | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.NonPreadditiveAbelian C] {P Q : C}
(f : P ⟶ Q) [CategoryTheory.Mono f], CategoryTheory.IsIso (CategoryTheory.Abelian.factorThruImage f) | null | true |
Quiver.Path.heq_of_cons_eq_cons | Mathlib.Combinatorics.Quiver.Path | ∀ {V : Type u} [inst : Quiver V] {a b c d : V} {p : Quiver.Path a b} {p' : Quiver.Path a c} {e : b ⟶ d} {e' : c ⟶ d},
p.cons e = p'.cons e' → p ≍ p' | null | true |
Aesop.RuleBuilder.cases | Aesop.Builder.Cases | Aesop.RuleBuilder | null | true |
Matroid.comap_indep_iff._simp_1 | Mathlib.Combinatorics.Matroid.Map | ∀ {α : Type u_1} {β : Type u_2} {f : α → β} {I : Set α} {N : Matroid β},
(N.comap f).Indep I = (N.Indep (f '' I) ∧ Set.InjOn f I) | null | false |
MeasureTheory.VectorMeasure.transpose_dirac | Mathlib.MeasureTheory.VectorMeasure.Integral | ∀ {X : Type u_2} {E : Type u_4} {F : Type u_5} {G : Type u_6} {mX : MeasurableSpace X} [inst : NormedAddCommGroup E]
[inst_1 : NormedSpace ℝ E] [inst_2 : NormedAddCommGroup F] [inst_3 : NormedSpace ℝ F] [inst_4 : NormedAddCommGroup G]
[inst_5 : NormedSpace ℝ G] (B : E →L[ℝ] F →L[ℝ] G) (x : X) (v : F),
(MeasureThe... | null | true |
UInt32.ofNatLT_bitVecToNat | Init.Data.UInt.Lemmas | ∀ (n : BitVec 32), UInt32.ofNatLT n.toNat ⋯ = { toBitVec := n } | null | true |
Subarray.foldr | Init.Data.Array.Subarray | {α : Type u} → {β : Type v} → (α → β → β) → β → Subarray α → β | Folds an operation from right to left over the elements in a subarray.
An accumulator of type `β` is constructed by starting with `init` and combining each element of the
subarray with the current accumulator value in turn, moving from the end to the start.
Examples:
* `#["red", "green", "blue"].toSubarray.foldr (·.... | true |
NNReal.holderConjugate_comm | Mathlib.Data.Real.ConjExponents | ∀ {p q : NNReal}, p.HolderConjugate q ↔ q.HolderConjugate p | null | true |
Multiset.sym2_mono | Mathlib.Data.Multiset.Sym | ∀ {α : Type u_1} {m m' : Multiset α}, m ≤ m' → m.sym2 ≤ m'.sym2 | null | true |
Real.Angle.toReal_le_pi | Mathlib.Analysis.SpecialFunctions.Trigonometric.Angle | ∀ (θ : Real.Angle), θ.toReal ≤ Real.pi | null | true |
_private.Mathlib.FieldTheory.RatFunc.Luroth.0.RatFunc.Luroth.q | Mathlib.FieldTheory.RatFunc.Luroth | {K : Type u_1} → [inst : Field K] → (E : IntermediateField K (RatFunc K)) → Polynomial ↥E | A polynomial `q` that satisfies `φ * q = (generator E).minpolyX`. | true |
PartialEquiv.IsImage.restr._proof_2 | Mathlib.Logic.Equiv.PartialEquiv | ∀ {α : Type u_1} {β : Type u_2} {e : PartialEquiv α β} {t : Set β}, Set.RightInvOn (↑e.symm) (↑e) (e.target ∩ t) | null | false |
_private.Mathlib.Topology.Sequences.0.compactSpace_iff_seqCompactSpace._simp_1_1 | Mathlib.Topology.Sequences | ∀ {X : Type u} [inst : TopologicalSpace X], CompactSpace X = IsCompact Set.univ | null | false |
Lean.Elab.Tactic.Do.ProofMode.mRefineCore._unsafe_rec | Lean.Elab.Tactic.Do.ProofMode.Refine | Lean.Elab.Tactic.Do.ProofMode.MGoal →
Lean.Parser.Tactic.MRefinePat →
(Lean.Elab.Tactic.Do.ProofMode.MGoal → Lean.TSyntax `Lean.binderIdent → Lean.Elab.Tactic.TacticM Lean.Expr) →
Lean.Elab.Tactic.TacticM Lean.Expr | null | false |
Bimod.AssociatorBimod.hom._proof_1 | Mathlib.CategoryTheory.Monoidal.Bimod | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.MonoidalCategory C]
[inst_2 : CategoryTheory.Limits.HasCoequalizers C]
[inst_3 :
∀ (X : C),
CategoryTheory.Limits.PreservesColimitsOfSize.{0, 0, u_1, u_1, u_2, u_2}
(CategoryTheory.MonoidalCategory.tensorLeft X... | null | false |
Set.inter_self | Mathlib.Data.Set.Basic | ∀ {α : Type u} (a : Set α), a ∩ a = a | null | true |
Std.DHashMap.Raw.getKeyD_erase | Std.Data.DHashMap.RawLemmas | ∀ {α : Type u} {β : α → Type v} {m : Std.DHashMap.Raw α β} [inst : BEq α] [inst_1 : Hashable α] [EquivBEq α]
[LawfulHashable α],
m.WF →
∀ {k a fallback : α}, (m.erase k).getKeyD a fallback = if (k == a) = true then fallback else m.getKeyD a fallback | null | true |
CategoryTheory.Limits.coneRightOpOfCoconeEquiv._proof_6 | Mathlib.CategoryTheory.Limits.Cones | ∀ {J : Type u_2} [inst : CategoryTheory.Category.{u_4, u_2} J] {C : Type u_1}
[inst_1 : CategoryTheory.Category.{u_3, u_1} C] {F : CategoryTheory.Functor Jᵒᵖ C}
(X : (CategoryTheory.Limits.Cocone F)ᵒᵖ),
CategoryTheory.CategoryStruct.comp
((CategoryTheory.Iso.refl
({ obj := fun c => Opposite.op... | null | false |
CategoryTheory.Limits.MulticospanIndex.multiforkEquivPiFork_inverse_map_hom | Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {J : CategoryTheory.Limits.MulticospanShape}
(I : CategoryTheory.Limits.MulticospanIndex J C) [inst_1 : CategoryTheory.Limits.HasProduct I.left]
[inst_2 : CategoryTheory.Limits.HasProduct I.right]
{K₁ K₂ :
CategoryTheory.Limits.Fork
(I.fstPiMapOfI... | null | true |
Nat.ofDigits_div_pow_eq_ofDigits_drop | Mathlib.Data.Nat.Digits.Defs | ∀ {p : ℕ} (i : ℕ),
0 < p →
∀ (digits : List ℕ), (∀ l ∈ digits, l < p) → Nat.ofDigits p digits / p ^ i = Nat.ofDigits p (List.drop i digits) | Interpreting as a base `p` number and dividing by `p^i` is the same as dropping `i`.
| true |
instIsDirectedOrder | Mathlib.Algebra.Order.Archimedean.Basic | ∀ {R : Type u_3} [inst : Semiring R] [inst_1 : PartialOrder R] [IsOrderedRing R] [Archimedean R], IsDirectedOrder R | null | true |
Prod.le_def | Mathlib.Order.Basic | ∀ {α : Type u_2} {β : Type u_3} [inst : LE α] [inst_1 : LE β] {x y : α × β}, x ≤ y ↔ x.1 ≤ y.1 ∧ x.2 ≤ y.2 | null | true |
Submonoid.closure_eq_one_union | Mathlib.Algebra.Group.Submonoid.Basic | ∀ {M : Type u_1} [inst : MulOneClass M] (s : Set M), ↑(Submonoid.closure s) = {1} ∪ ↑(Subsemigroup.closure s) | The `Submonoid.closure` of a set is the union of `{1}` and its `Subsemigroup.closure`. | true |
ZSpan.ceil | Mathlib.Algebra.Module.ZLattice.Basic | {E : Type u_1} →
{ι : Type u_2} →
{K : Type u_3} →
[inst : NormedField K] →
[inst_1 : NormedAddCommGroup E] →
[inst_2 : NormedSpace K E] →
(b : Module.Basis ι K E) →
[inst_3 : LinearOrder K] →
[IsStrictOrderedRing K] → [FloorRing K] → [Fintype ι] →... | The map that sends a vector of `E` to the element of the ℤ-lattice spanned by `b` obtained
by rounding up its coordinates on the basis `b`. | true |
Mathlib.Meta.FunProp.Mor.isCoeFun | Mathlib.Tactic.FunProp.Mor | Lean.Expr → Lean.MetaM Bool | Is `e` a coercion from some function space to functions? | true |
IsLocalization.Away.sec.congr_simp | Mathlib.RingTheory.Extension.Generators | ∀ {R : Type u_1} [inst : CommSemiring R] {S : Type u_2} [inst_1 : CommSemiring S] [inst_2 : Algebra R S] (x x_1 : R)
(e_x : x = x_1) [inst_3 : IsLocalization.Away x S] (s s_1 : S),
s = s_1 → IsLocalization.Away.sec x s = IsLocalization.Away.sec x_1 s_1 | null | true |
eq_zero_of_sameRay_neg_smul_right | Mathlib.LinearAlgebra.Ray | ∀ {R : Type u_1} [inst : CommRing R] [inst_1 : PartialOrder R] [inst_2 : IsStrictOrderedRing R] {M : Type u_2}
[inst_3 : AddCommGroup M] [inst_4 : Module R M] {x : M} [IsDomain R] [Module.IsTorsionFree R M] {r : R},
r < 0 → SameRay R x (r • x) → x = 0 | null | true |
SupHom.dual_comp | Mathlib.Order.Hom.Lattice | ∀ {α : Type u_2} {β : Type u_3} {γ : Type u_4} [inst : Max α] [inst_1 : Max β] [inst_2 : Max γ] (g : SupHom β γ)
(f : SupHom α β), SupHom.dual (g.comp f) = (SupHom.dual g).comp (SupHom.dual f) | null | true |
Homotopy.compRight._proof_1 | Mathlib.Algebra.Homology.Homotopy | ∀ {ι : Type u_3} {V : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} V] [inst_1 : CategoryTheory.Preadditive V]
{c : ComplexShape ι} {C D E : HomologicalComplex V c} {e f : C ⟶ D} (h : Homotopy e f) (g : D ⟶ E) (i j : ι),
¬c.Rel j i → CategoryTheory.CategoryStruct.comp (h.hom i j) (g.f j) = 0 | null | false |
zero_mem_tangentConeAt_iff._simp_1 | Mathlib.Analysis.Calculus.TangentCone.Basic | ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : AddCommGroup E] [inst_1 : Semiring 𝕜] [inst_2 : Module 𝕜 E]
[inst_3 : TopologicalSpace E] [ContinuousAdd E] {s : Set E} {x : E}, (0 ∈ tangentConeAt 𝕜 s x) = (x ∈ closure s) | null | false |
LocallyFiniteOrder.addMonoidHom._proof_1 | Mathlib.Algebra.Order.Monoid.LocallyFiniteOrder | ∀ (G : Type u_1) [inst : AddCommGroup G] [inst_1 : LinearOrder G] [inst_2 : LocallyFiniteOrder G],
↑(Finset.Ico 0 0).card - ↑(Finset.Ico 0 (-0)).card = 0 | null | false |
Std.Internal.Do.PredTrans.ctorIdx | Std.Internal.Do.PredTrans | {Pred : Type u} → {EPred : Type v} → {α : Type w} → Std.Internal.Do.PredTrans Pred EPred α → ℕ | null | false |
TopologicalSpace.Opens.mapComp_hom_app | Mathlib.Topology.Category.TopCat.Opens | ∀ {X Y Z : TopCat} (f : X ⟶ Y) (g : Y ⟶ Z) (U : TopologicalSpace.Opens ↑Z),
(TopologicalSpace.Opens.mapComp f g).hom.app U = CategoryTheory.eqToHom ⋯ | null | true |
CovariantDerivative.affine_combination | Mathlib.Geometry.Manifold.VectorBundle.CovariantDerivative.Basic | {𝕜 : Type u_1} →
[inst : NontriviallyNormedField 𝕜] →
{E : Type u_2} →
[inst_1 : NormedAddCommGroup E] →
[inst_2 : NormedSpace 𝕜 E] →
{H : Type u_3} →
[inst_3 : TopologicalSpace H] →
{I : ModelWithCorners 𝕜 E H} →
{M : Type u_4} →
... | An affine combination of covariant derivatives as a covariant derivative. | true |
CentroidHom.centerToCentroid_apply | Mathlib.Algebra.Ring.CentroidHom | ∀ {α : Type u_5} [inst : NonUnitalNonAssocSemiring α] (z : ↥(NonUnitalSubsemiring.center α)) (a : α),
(CentroidHom.centerToCentroid z) a = ↑z * a | null | true |
Nat.gcd_gcd_self_right_left | Init.Data.Nat.Gcd | ∀ (m n : ℕ), m.gcd (m.gcd n) = m.gcd n | null | true |
_private.Mathlib.Analysis.Complex.PhragmenLindelof.0.PhragmenLindelof.quadrant_II._simp_1_3 | Mathlib.Analysis.Complex.PhragmenLindelof | ∀ {α : Type u} [inst : AddGroup α] [inst_1 : LT α] [AddLeftStrictMono α] {a : α}, (-a < 0) = (0 < a) | null | false |
Std.DHashMap.Internal.Raw₀.Const.get_eq_of_equiv | Std.Data.DHashMap.Internal.RawLemmas | ∀ {α : Type u} [inst : BEq α] [inst_1 : Hashable α] {β : Type v} (m₁ m₂ : Std.DHashMap.Internal.Raw₀ α fun x => β)
[inst_2 : EquivBEq α] [inst_3 : LawfulHashable α] (h₁ : (↑m₁).WF) (h₂ : (↑m₂).WF) (h : (↑m₁).Equiv ↑m₂) {k : α}
(h' : m₁.contains k = true),
Std.DHashMap.Internal.Raw₀.Const.get m₁ k h' = Std.DHashMa... | null | true |
ProfiniteAddGrp.instHasForget₂ContinuousAddMonoidHomCarrierToTopTotallyDisconnectedSpaceToProfiniteProfiniteContinuousMap._proof_1 | Mathlib.Topology.Algebra.Category.ProfiniteGrp.Basic | ∀ {X Y : ProfiniteAddGrp.{u_1}} (f : X ⟶ Y), Continuous ⇑(ProfiniteAddGrp.Hom.hom f) | null | false |
_private.Lean.Meta.Sym.AlphaShareBuilder.0.Lean.Expr.updateLetS!._sparseCasesOn_1 | Lean.Meta.Sym.AlphaShareBuilder | {motive : Lean.Expr → Sort u} →
(t : Lean.Expr) →
((declName : Lean.Name) →
(type value body : Lean.Expr) → (nondep : Bool) → motive (Lean.Expr.letE declName type value body nondep)) →
(Nat.hasNotBit 256 t.ctorIdx → motive t) → motive t | null | false |
CategoryTheory.Functor.preservesFiniteColimits_of_preservesHomology | Mathlib.Algebra.Homology.ShortComplex.ExactFunctor | ∀ {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] (F : CategoryTheory.Functor C D) [inst_4 : F.Additive] [F.PreservesHomology]
[CategoryTheory.Limits.HasZeroO... | An additive which preserves homology preserves finite colimits. | true |
LinearMap.submoduleComap_apply_coe | Mathlib.Algebra.Module.Submodule.Map | ∀ {R : Type u_1} {R₂ : Type u_3} {M : Type u_5} {M₂ : Type u_7} [inst : Semiring R] [inst_1 : Semiring R₂]
[inst_2 : AddCommMonoid M] [inst_3 : AddCommMonoid M₂] [inst_4 : Module R M] [inst_5 : Module R₂ M₂] {σ₁₂ : R →+* R₂}
(f : M →ₛₗ[σ₁₂] M₂) (q : Submodule R₂ M₂) (c : ↥(Submodule.comap f q)), ↑((f.submoduleComap... | null | true |
EuclideanGeometry.Sphere.IsDiameter.mk._flat_ctor | Mathlib.Geometry.Euclidean.Sphere.Basic | ∀ {V : Type u_1} {P : Type u_2} [inst : NormedAddCommGroup V] [inst_1 : NormedSpace ℝ V] [inst_2 : MetricSpace P]
[inst_3 : NormedAddTorsor V P] {s : EuclideanGeometry.Sphere P} {p₁ p₂ : P},
p₁ ∈ s → midpoint ℝ p₁ p₂ = s.center → s.IsDiameter p₁ p₂ | null | false |
Profinite.NobelingProof.π | Mathlib.Topology.Category.Profinite.Nobeling.Basic | {I : Type u} → Set (I → Bool) → (J : I → Prop) → [(i : I) → Decidable (J i)] → Set (I → Bool) | The image of `Proj π J` | true |
FourierInvModule.mk.noConfusion | Mathlib.Analysis.Fourier.Notation | {R : Type u_5} →
{E : Type u_6} →
{F : outParam (Type u_7)} →
{inst : Add E} →
{inst_1 : Add F} →
{inst_2 : SMul R E} →
{inst_3 : SMul R F} →
{P : Sort u} →
{toFourierTransformInv : FourierTransformInv E F} →
{fourierInv_add :
... | null | false |
AlgebraicTopology.DoldKan.N₁_obj_X | Mathlib.AlgebraicTopology.DoldKan.FunctorN | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Preadditive C]
(X : CategoryTheory.SimplicialObject C),
(AlgebraicTopology.DoldKan.N₁.obj X).X = AlgebraicTopology.AlternatingFaceMapComplex.obj X | null | true |
hnot_hnot_hnot | Mathlib.Order.Heyting.Basic | ∀ {α : Type u_2} [inst : CoheytingAlgebra α] (a : α), ￢￢￢a = ￢a | null | true |
SkewMonoidAlgebra.recOn | Mathlib.Algebra.SkewMonoidAlgebra.Basic | {k : Type u_1} →
{G : Type u_2} →
[inst : Zero k] →
{motive : SkewMonoidAlgebra k G → Sort u} →
(t : SkewMonoidAlgebra k G) → ((toFinsupp : G →₀ k) → motive { toFinsupp := toFinsupp }) → motive t | null | false |
isSigmaCompact_iff_isSigmaCompact_univ | Mathlib.Topology.Compactness.SigmaCompact | ∀ {X : Type u_1} [inst : TopologicalSpace X] {s : Set X}, IsSigmaCompact s ↔ IsSigmaCompact Set.univ | A subset `s` is σ-compact iff `s` (with the subspace topology) is a σ-compact space. | true |
Std.DTreeMap.Internal.Impl.Tree.noConfusion | Std.Data.DTreeMap.Internal.Operations | {P : Sort u_1} →
{α : Type u} →
{β : α → Type v} →
{size : ℕ} →
{t : Std.DTreeMap.Internal.Impl.Tree α β size} →
{α' : Type u} →
{β' : α' → Type v} →
{size' : ℕ} →
{t' : Std.DTreeMap.Internal.Impl.Tree α' β' size'} →
α = α' → β ≍ ... | null | false |
Lean.Elab.Deriving.withoutExposeFromCtors | Lean.Elab.Deriving.Util | {α : Type} → Lean.Name → Lean.Elab.Command.CommandElabM α → Lean.Elab.Command.CommandElabM α | Removes any `[expose]` section attributes when running `cont` if `typeName` has private ctors.
| true |
PowerBasis.finite | Mathlib.RingTheory.PowerBasis | ∀ {R : Type u_1} {S : Type u_2} [inst : CommRing R] [inst_1 : Ring S] [inst_2 : Algebra R S] (pb : PowerBasis R S),
Module.Finite R S | Cannot be an instance because `PowerBasis` cannot be a class. | true |
List.sum_le_sum | Mathlib.Algebra.Order.BigOperators.Group.List | ∀ {ι : Type u_1} {M : Type u_3} [inst : AddMonoid M] [inst_1 : Preorder M] [AddRightMono M] [AddLeftMono M] {l : List ι}
{f g : ι → M}, (∀ i ∈ l, f i ≤ g i) → (List.map f l).sum ≤ (List.map g l).sum | null | true |
Lean.PrettyPrinter.Formatter.checkNoWsBefore.formatter | Lean.PrettyPrinter.Formatter | Lean.PrettyPrinter.Formatter | null | true |
_private.Mathlib.Algebra.Category.HopfAlgCat.Basic.0.HopfAlgCat.mk.sizeOf_spec | Mathlib.Algebra.Category.HopfAlgCat.Basic | ∀ {R : Type u} [inst : CommRing R] [inst_1 : SizeOf R] (carrier : Type v) [instRing : Ring carrier]
[instHopfAlgebra : HopfAlgebra R carrier],
sizeOf { carrier := carrier, instRing := instRing, instHopfAlgebra := instHopfAlgebra } =
1 + sizeOf carrier + sizeOf instRing + sizeOf instHopfAlgebra | null | true |
_private.BatteriesRecycling.MonadSatisfying.Basic.0.SatisfiesM_ExceptT_eq.match_1_11 | BatteriesRecycling.MonadSatisfying.Basic | {α ρ : Type u_1} →
{p : α → Prop} →
(motive : { a // (fun x => ∀ (a : α), x = Except.ok a → p a) a } → Sort u_2) →
(x : { a // (fun x => ∀ (a : α), x = Except.ok a → p a) a }) →
((a : α) → (h : ∀ (a_1 : α), Except.ok a = Except.ok a_1 → p a_1) → motive ⟨Except.ok a, h⟩) →
((e : ρ) → (prope... | null | false |
MeasureTheory.Lp.instNormedAddCommGroup._proof_5 | Mathlib.MeasureTheory.Function.LpSpace.Basic | ∀ {α : Type u_1} {E : Type u_2} {m : MeasurableSpace α} {p : ENNReal} {μ : MeasureTheory.Measure α}
[inst : NormedAddCommGroup E] (r : ↥(MeasureTheory.Lp E p μ)), ‖-r‖ = ‖r‖ | null | false |
exists_pow_lt₀ | Mathlib.GroupTheory.ArchimedeanDensely | ∀ {G : Type u_1} [inst : LinearOrderedCommGroupWithZero G] [MulArchimedean G] {a : G},
a < 1 → ∀ (b : Gˣ), ∃ n, a ^ n < ↑b | null | true |
MvPolynomial.pderiv_C | Mathlib.Algebra.MvPolynomial.PDeriv | ∀ {R : Type u} {σ : Type v} {a : R} [inst : CommSemiring R] {i : σ}, (MvPolynomial.pderiv i) (MvPolynomial.C a) = 0 | null | true |
le_mul_inv_iff_mul_le._simp_2 | Mathlib.Algebra.Order.Group.Unbundled.Basic | ∀ {α : Type u} [inst : Group α] [inst_1 : LE α] [MulRightMono α] {a b c : α}, (c ≤ a * b⁻¹) = (c * b ≤ a) | null | false |
Std.Tactic.BVDecide.LRAT.Internal.Assignment.removeAssignment.eq_1 | Std.Tactic.BVDecide.LRAT.Internal.Assignment | ∀ (b : Bool) (a : Std.Tactic.BVDecide.LRAT.Internal.Assignment),
Std.Tactic.BVDecide.LRAT.Internal.Assignment.removeAssignment b a =
if b = true then a.removePosAssignment else a.removeNegAssignment | null | true |
_private.Mathlib.Order.Filter.Basic.0.Filter.not_le._simp_1_2 | Mathlib.Order.Filter.Basic | ∀ {α : Sort u_1} {p : α → Prop}, (¬∀ (x : α), p x) = ∃ x, ¬p x | null | false |
FractionalIdeal.extendedHomₐ_injective | Mathlib.RingTheory.FractionalIdeal.Extended | ∀ (A : Type u_1) (K : Type u_2) (L : Type u_3) (B : Type u_4) [inst : CommRing A] [inst_1 : IsDomain A]
[inst_2 : CommRing B] [inst_3 : IsDomain B] [inst_4 : Algebra A B] [inst_5 : Module.IsTorsionFree A B]
[inst_6 : Field K] [inst_7 : Field L] [inst_8 : Algebra A K] [inst_9 : Algebra B L] [inst_10 : IsFractionRing... | **Alias** of `FractionalIdeal.extendedHom_injective`. | true |
_private.Mathlib.Analysis.InnerProductSpace.Projection.Reflection.0.Submodule.«_aux_Mathlib_Analysis_InnerProductSpace_Projection_Reflection___macroRules__private_Mathlib_Analysis_InnerProductSpace_Projection_Reflection_0_Submodule_term⟪_,_⟫_1» | Mathlib.Analysis.InnerProductSpace.Projection.Reflection | Lean.Macro | null | false |
CategoryTheory.Monoidal.ComonFunctorCategoryEquivalence.inverseObj | 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] →
CategoryTheory.Functor C (CategoryTheory.Comon D) → CategoryTheory.Comon (CategoryTheory.Functor C D) | A functor to the category of comonoid objects can be translated as a comonoid object
in the functor category. | true |
CategoryTheory.GradedObject.Monoidal.ιTensorObj₄.congr_simp | Mathlib.CategoryTheory.GradedObject.Monoidal | ∀ {I : Type u} [inst : AddMonoid I] {C : Type u_1} [inst_1 : CategoryTheory.Category.{v_1, u_1} C]
[inst_2 : CategoryTheory.MonoidalCategory C] (X₁ X₂ X₃ X₄ : CategoryTheory.GradedObject I C)
[inst_3 : X₃.HasTensor X₄] [inst_4 : X₂.HasTensor (CategoryTheory.GradedObject.Monoidal.tensorObj X₃ X₄)]
[inst_5 :
X₁... | null | true |
_private.Mathlib.NumberTheory.Bernoulli.0.sum_bernoulli'._simp_1_1 | Mathlib.NumberTheory.Bernoulli | ∀ {G : Type u_1} [inst : Semigroup G] (a b c : G), a * (b * c) = a * b * c | null | false |
_private.Std.Http.Internal.String.0.Std.Http.Internal.UnquoteState._sizeOf_1 | Std.Http.Internal.String | Std.Http.Internal.UnquoteState✝ → ℕ | null | false |
vadd_left_cancel_iff._simp_1 | Mathlib.Algebra.Group.Action.Basic | ∀ {α : Type u_5} {β : Type u_6} [inst : AddGroup α] [inst_1 : AddAction α β] (g : α) {x y : β},
(g +ᵥ x = g +ᵥ y) = (x = y) | null | false |
FinPartOrd.instCoeSortType | Mathlib.Order.Category.FinPartOrd | CoeSort FinPartOrd (Type u_1) | null | true |
MeasureTheory.vaddInvariantMeasure_map_vadd | Mathlib.MeasureTheory.Group.Action | ∀ {M : Type uM} {N : Type uN} {α : Type uα} [inst : MeasurableSpace α] [inst_1 : VAdd M α] [inst_2 : VAdd N α]
[VAddCommClass N M α] [MeasurableConstVAdd M α] [MeasurableConstVAdd N α] (μ : MeasureTheory.Measure α)
[MeasureTheory.VAddInvariantMeasure M α μ] (n : N),
MeasureTheory.VAddInvariantMeasure M α (Measure... | null | true |
CategoryTheory.Bicategory.postcomposingCat._proof_4 | Mathlib.CategoryTheory.Bicategory.Yoneda | ∀ {B : Type u_2} [inst : CategoryTheory.Bicategory B] (a b c : B) {X Y Z : b ⟶ c} (f : X ⟶ Y) (g : Y ⟶ Z),
CategoryTheory.NatTrans.toCatHom₂
((CategoryTheory.Bicategory.postcomposing a b c).map (CategoryTheory.CategoryStruct.comp f g)) =
CategoryTheory.CategoryStruct.comp
(CategoryTheory.NatTrans.toCa... | null | false |
List.fixedLengthDigits.congr_simp | Mathlib.Data.Nat.Digits.Lemmas | ∀ {b b_1 : ℕ} (e_b : b = b_1) (hb : 1 < b) (l l_1 : ℕ),
l = l_1 → List.fixedLengthDigits hb l = List.fixedLengthDigits ⋯ l_1 | null | true |
CategoryTheory.Limits.Types.coneOfSection | Mathlib.CategoryTheory.Limits.Types.Limits | {J : Type v} →
[inst : CategoryTheory.Category.{w, v} J] →
{F : CategoryTheory.Functor J (Type u)} → {s : (j : J) → F.obj j} → s ∈ F.sections → CategoryTheory.Limits.Cone F | Given a section of a functor F into `Type*`,
construct a cone over F with `PUnit` as the cone point. | true |
CategoryTheory.Iso.toIsometryEquiv_toFun | Mathlib.LinearAlgebra.QuadraticForm.QuadraticModuleCat | ∀ {R : Type u} [inst : CommRing R] {X Y : QuadraticModuleCat R} (i : X ≅ Y) (a : ↑X.toModuleCat),
i.toIsometryEquiv a = (QuadraticModuleCat.Hom.toIsometry i.hom) a | null | true |
Lean.Elab.Tactic.Conv.evalLiftLets | Lean.Elab.Tactic.Conv.Lets | Lean.Elab.Tactic.Tactic | null | true |
StieltjesFunction.add_apply | Mathlib.MeasureTheory.Measure.Stieltjes | ∀ {R : Type u_1} [inst : LinearOrder R] [inst_1 : TopologicalSpace R] (f g : StieltjesFunction R) (x : R),
↑(f + g) x = ↑f x + ↑g x | null | true |
Pi.monotoneCurry | Mathlib.Control.LawfulFix | (α : Type u_1) →
(β : α → Type u_2) →
(γ : (a : α) → β a → Type u_3) →
[inst : (x : α) → (y : β x) → Preorder (γ x y)] →
((x : (a : α) × β a) → γ x.fst x.snd) →o (a : α) → (b : β a) → γ a b | `Sigma.curry` as a monotone function. | true |
Array.instLE | Init.Data.Array.Basic | {α : Type u} → [LT α] → LE (Array α) | null | true |
Commute.natCast_mul_self | Mathlib.Data.Nat.Cast.Commute | ∀ {α : Type u_1} [inst : Semiring α] (a : α) (n : ℕ), Commute (↑n * a) a | null | true |
MeasureTheory.Measure.regular_of_isAddLeftInvariant | Mathlib.MeasureTheory.Measure.Haar.Basic | ∀ {G : Type u_1} [inst : AddGroup G] [inst_1 : TopologicalSpace G] [IsTopologicalAddGroup G]
[inst_3 : MeasurableSpace G] [BorelSpace G] [SecondCountableTopology G] {μ : MeasureTheory.Measure G}
[MeasureTheory.SigmaFinite μ] [μ.IsAddLeftInvariant] {K : Set G},
IsCompact K → (interior K).Nonempty → μ K ≠ ⊤ → μ.Reg... | To show that an invariant σ-finite measure is regular it is sufficient to show that it is
finite on some compact set with non-empty interior. | true |
ULift.inv.eq_1 | Mathlib.Algebra.Group.ULift | ∀ {α : Type u} [inst : Inv α], ULift.inv = { inv := fun f => { down := f.down⁻¹ } } | null | true |
Nat.not_dvd_ordCompl | Mathlib.Data.Nat.Factorization.Basic | ∀ {n p : ℕ}, Nat.Prime p → n ≠ 0 → ¬p ∣ n / p ^ n.factorization p | null | true |
_private.Mathlib.Analysis.Calculus.DifferentialForm.VectorField.0.extDeriv_apply_vectorField_of_pairwise_commute._simp_1_1 | Mathlib.Analysis.Calculus.DifferentialForm.VectorField | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : AddCommGroup E] [inst_2 : Module 𝕜 E]
[inst_3 : TopologicalSpace E] {F : Type u_3} [inst_4 : AddCommGroup F] [inst_5 : Module 𝕜 F]
[inst_6 : TopologicalSpace F] {f : E → F} {x : E}, DifferentiableAt 𝕜 f x = DifferentiableWithinAt 𝕜 f... | null | false |
Lean.PersistentHashMap.Node.casesOn | Lean.Data.PersistentHashMap | {α : Type u} →
{β : Type v} →
{motive_1 : Lean.PersistentHashMap.Node α β → Sort u_1} →
(t : Lean.PersistentHashMap.Node α β) →
((es : Array (Lean.PersistentHashMap.Entry α β (Lean.PersistentHashMap.Node α β))) →
motive_1 (Lean.PersistentHashMap.Node.entries es)) →
((ks : Array... | null | false |
TrivSqZeroExt.addGroupWithOne._proof_5 | Mathlib.Algebra.TrivSqZeroExt.Basic | ∀ {R : Type u_1} {M : Type u_2} [inst : AddGroupWithOne R] [inst_1 : AddGroup M] (a : TrivSqZeroExt R M), -a + a = 0 | null | false |
Aesop.FIFOQueue.casesOn | Aesop.Search.Queue | {motive : Aesop.FIFOQueue → Sort u} →
(t : Aesop.FIFOQueue) → ((goals : Array Aesop.GoalRef) → (pos : ℕ) → motive { goals := goals, pos := pos }) → motive t | null | false |
_private.Lean.Meta.Basic.0.Lean.Meta.isClassQuick?.match_3 | Lean.Meta.Basic | (motive : Lean.Expr → Sort u_1) →
(x : Lean.Expr) →
((n : Lean.Name) → (us : List Lean.Level) → motive (Lean.Expr.const n us)) → ((x : Lean.Expr) → motive x) → motive x | null | false |
_private.Init.Data.String.Lemmas.Pattern.TakeDrop.Basic.0.String.skipSuffixWhile_eq_endPos._simp_1_1 | Init.Data.String.Lemmas.Pattern.TakeDrop.Basic | ∀ {ρ : Type} {pat : ρ} [inst : String.Slice.Pattern.BackwardPattern pat] {s : String},
s.endsWith pat = s.toSlice.endsWith pat | null | false |
FreeAlgebra.Pre.hasZero | Mathlib.Algebra.FreeAlgebra | (R : Type u_1) → (X : Type u_2) → [CommSemiring R] → Zero (FreeAlgebra.Pre R X) | Zero in `Pre R X` defined as the image of `0` from `R`. Note: Used for notation only. | true |
add_le_add_add_tsub | Mathlib.Algebra.Order.Sub.Defs | ∀ {α : Type u_1} [inst : Preorder α] [inst_1 : AddCommSemigroup α] [inst_2 : Sub α] [OrderedSub α] {a b c : α}
[AddLeftMono α], a + b ≤ a + c + (b - c) | null | true |
MulLEAddHomClass.rec | Mathlib.Algebra.Order.Hom.Basic | {F : Type u_7} →
{α : Type u_8} →
{β : Type u_9} →
[inst : Mul α] →
[inst_1 : Add β] →
[inst_2 : LE β] →
[inst_3 : FunLike F α β] →
{motive : MulLEAddHomClass F α β → Sort u} →
((map_mul_le_add : ∀ (f : F) (a b : α), f (a * b) ≤ f a + f b) → motive... | null | false |
Std.LawfulRightIdentity.mk | Init.Core | ∀ {α : Sort u} {β : Sort u_1} {op : α → β → α} {o : outParam β} [toRightIdentity : Std.RightIdentity op o],
(∀ (a : α), op a o = a) → Std.LawfulRightIdentity op o | null | true |
ChainComplex.of._proof_3 | Mathlib.Algebra.Homology.HomologicalComplex | ∀ {V : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} V] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms V]
{α : Type u_3} [inst_2 : AddRightCancelSemigroup α] [inst_3 : One α] [inst_4 : DecidableEq α] (X : α → V)
(d : (n : α) → X (n + 1) ⟶ X n),
(∀ (n : α), CategoryTheory.CategoryStruct.comp (d (n + 1)) (... | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.