name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11.5k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
CategoryTheory.Limits.Types.chosenEnd_def | Mathlib.CategoryTheory.Limits.Types.End | ∀ {J : Type u} [inst : CategoryTheory.Category.{v, u} J]
{F : CategoryTheory.Functor Jᵒᵖ (CategoryTheory.Functor J (Type (max w u)))},
CategoryTheory.Limits.chosenEnd F = CategoryTheory.Limits.Types.end_ F | null | true |
Function.Surjective.comp_left | Mathlib.Logic.Function.Basic | ∀ {α : Sort u} {β : Sort v} {γ : Sort w} {g : β → γ}, Function.Surjective g → Function.Surjective fun x => g ∘ x | Composition by a surjective function on the left is itself surjective. | true |
Rep.standardComplex.forget₂ToModuleCat | Mathlib.RepresentationTheory.Homological.Resolution | (k G : Type u) → [inst : CommRing k] → [Monoid G] → HomologicalComplex (ModuleCat k) (ComplexShape.down ℕ) | The standard resolution of `k` as a trivial representation as a complex of `k`-modules. | true |
Lean.Widget.instInhabitedStrictOrLazy | Lean.Widget.InteractiveDiagnostic | {a : Type} → [Inhabited a] → {a_1 : Type} → Inhabited (Lean.Widget.StrictOrLazy a a_1) | null | true |
_private.Mathlib.Analysis.BoxIntegral.Partition.Additive.0.Option.elim'.match_1.eq_2 | Mathlib.Analysis.BoxIntegral.Partition.Additive | ∀ {α : Type u_1} (motive : Option α → Sort u_2) (h_1 : (a : α) → motive (some a)) (h_2 : Unit → motive none),
(match none with
| some a => h_1 a
| none => h_2 ()) =
h_2 () | null | true |
Std.DTreeMap.Internal.Impl.Const.entryAtIdxD_eq_getD_entryAtIdx? | Std.Data.DTreeMap.Internal.Model | ∀ {α : Type u} {β : Type v} {t : Std.DTreeMap.Internal.Impl α fun x => β} {i : ℕ} {fallback : α × β},
Std.DTreeMap.Internal.Impl.Const.entryAtIdxD t i fallback =
(Std.DTreeMap.Internal.Impl.Const.entryAtIdx? t i).getD fallback | null | true |
Int64.le_minValue_iff | Init.Data.SInt.Lemmas | ∀ {a : Int64}, a ≤ Int64.minValue ↔ a = Int64.minValue | null | true |
TensorProduct.instInner | Mathlib.Analysis.InnerProductSpace.TensorProduct | {𝕜 : Type u_1} →
{E : Type u_2} →
{F : Type u_3} →
[inst : RCLike 𝕜] →
[inst_1 : NormedAddCommGroup E] →
[inst_2 : InnerProductSpace 𝕜 E] →
[inst_3 : NormedAddCommGroup F] → [inst_4 : InnerProductSpace 𝕜 F] → Inner 𝕜 (TensorProduct 𝕜 E F) | null | true |
MeasureTheory.integral_union_ae | Mathlib.MeasureTheory.Integral.Bochner.Set | ∀ {X : Type u_1} {E : Type u_3} {mX : MeasurableSpace X} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E]
{f : X → E} {s t : Set X} {μ : MeasureTheory.Measure X},
MeasureTheory.AEDisjoint μ s t →
MeasureTheory.NullMeasurableSet t μ →
MeasureTheory.IntegrableOn f s μ →
MeasureTheory.Integra... | **Alias** of `MeasureTheory.setIntegral_union₀`. | true |
List.headD.eq_2 | Init.Data.List.Lemmas | ∀ {α : Type u} (x a : α) (as : List α), (a :: as).headD x = a | null | true |
Set.biUnion_union | Mathlib.Data.Set.Lattice | ∀ {α : Type u_1} {β : Type u_2} (s t : Set α) (u : α → Set β), ⋃ x ∈ s ∪ t, u x = (⋃ x ∈ s, u x) ∪ ⋃ x ∈ t, u x | null | true |
Mathlib.Tactic.Choose.mkSometimes | Mathlib.Tactic.Choose | Lean.Level →
Lean.Expr → Lean.Expr → Lean.Expr → List Lean.Expr → Lean.Expr × Lean.Expr → Lean.MetaM (Lean.Expr × Lean.Expr) | Given `α : Sort u`, `nonemp : Nonempty α`, `p : α → Prop`, a context of free variables
`ctx`, and a pair of an element `val : α` and `spec : p val`,
`mkSometimes u α nonemp p ctx (val, spec)` produces another pair `val', spec'`
such that `val'` does not have any free variables from elements of `ctx` whose types are
pro... | true |
_private.Lean.Meta.LetToHave.0.Lean.Meta.LetToHave.State.mk | Lean.Meta.LetToHave | ℕ → Std.HashMap Lean.ExprStructEq Lean.Meta.LetToHave.Result✝ → Lean.Meta.LetToHave.State✝ | null | true |
MaximalSpectrum.recOn | Mathlib.RingTheory.Spectrum.Maximal.Defs | {R : Type u_1} →
[inst : CommSemiring R] →
{motive : MaximalSpectrum R → Sort u} →
(t : MaximalSpectrum R) →
((asIdeal : Ideal R) →
(isMaximal : asIdeal.IsMaximal) → motive { asIdeal := asIdeal, isMaximal := isMaximal }) →
motive t | null | false |
CategoryTheory.PreGaloisCategory.PointedGaloisObject.incl.match_1 | Mathlib.CategoryTheory.Galois.Prorepresentability | {C : Type u_2} →
[inst : CategoryTheory.Category.{u_1, u_2} C] →
[inst_1 : CategoryTheory.GaloisCategory C] →
(F : CategoryTheory.Functor C FintypeCat) →
{X Y : CategoryTheory.PreGaloisCategory.PointedGaloisObject F} →
(motive : (X ⟶ Y) → Sort u_4) →
(x : X ⟶ Y) →
... | null | false |
_private.Lean.Meta.Sym.Arith.Poly.0.Lean.Grind.CommRing.Mon.toExpr.go._f | Lean.Meta.Sym.Arith.Poly | (m : Lean.Grind.CommRing.Mon) →
Lean.Grind.CommRing.Mon.below (motive := fun m => Lean.Grind.CommRing.Expr → Lean.Grind.CommRing.Expr) m →
Lean.Grind.CommRing.Expr → Lean.Grind.CommRing.Expr | null | false |
Lean.DeclNameGenerator.mk.inj | Lean.CoreM | ∀ {namePrefix : Lean.Name} {idx : ℕ} {parentIdxs : List ℕ} {namePrefix_1 : Lean.Name} {idx_1 : ℕ}
{parentIdxs_1 : List ℕ},
{ namePrefix := namePrefix, idx := idx, parentIdxs := parentIdxs } =
{ namePrefix := namePrefix_1, idx := idx_1, parentIdxs := parentIdxs_1 } →
namePrefix = namePrefix_1 ∧ idx = idx_1... | null | true |
Nat.le.below.refl | Init.Prelude | ∀ {n : ℕ} {motive : (a : ℕ) → n.le a → Prop}, Nat.le.below ⋯ | null | true |
SSet.horn₂₀.ι₀₂._proof_1 | Mathlib.AlgebraicTopology.SimplicialSet.HornColimits | 1 ≠ 0 | null | false |
ProperCone.toPointedCone_bot | Mathlib.Analysis.Convex.Cone.Basic | ∀ {R : Type u_2} {E : Type u_3} [inst : Semiring R] [inst_1 : PartialOrder R] [inst_2 : IsOrderedRing R]
[inst_3 : AddCommMonoid E] [inst_4 : TopologicalSpace E] [inst_5 : Module R E] [inst_6 : T1Space E], ↑⊥ = ⊥ | null | true |
Batteries.PairingHeapImp.Heap.foldTreeM._unsafe_rec | Batteries.Data.PairingHeap | {m : Type u_1 → Type u_2} →
{β : Type u_1} → {α : Type u_3} → [Monad m] → β → (α → β → β → m β) → Batteries.PairingHeapImp.Heap α → m β | null | false |
Mathlib.Linter.TextBased.UnicodeLinter.replaceDisallowed | Mathlib.Tactic.Linter.TextBased.UnicodeLinter | Char → Option String | Provide default replacement (`String`) for a disallowed character, or `none` if none defined | true |
_private.Mathlib.NumberTheory.Divisors.0.Nat.filter_dvd_eq_properDivisors._simp_1_5 | Mathlib.NumberTheory.Divisors | ∀ {a c b : Prop}, (a ∧ c ↔ b ∧ c) = (c → (a ↔ b)) | null | false |
invMonoidHom.eq_1 | Mathlib.Algebra.Group.Hom.Basic | ∀ {α : Type u_1} [inst : DivisionCommMonoid α], invMonoidHom = { toFun := Inv.inv, map_one' := ⋯, map_mul' := ⋯ } | null | true |
_private.Mathlib.Data.Nat.Prime.Defs.0.Nat.prime_iff_not_exists_mul_eq._simp_1_6 | Mathlib.Data.Nat.Prime.Defs | ∀ {α : Type u_1} [inst : LinearOrder α] {a b : α}, (¬a < b) = (b ≤ a) | null | false |
Equiv.decidableEq | Mathlib.Logic.Equiv.Defs | {α : Sort u} → {β : Sort v} → α ≃ β → [DecidableEq β] → DecidableEq α | Transfer `DecidableEq` across an equivalence. | true |
MulOpposite.instNonUnitalCommCStarAlgebra._proof_2 | Mathlib.Analysis.CStarAlgebra.Classes | ∀ {A : Type u_1} [inst : NonUnitalCommCStarAlgebra A], CStarRing Aᵐᵒᵖ | null | false |
LeanSearchClient.LoogleResult.recOn | LeanSearchClient.LoogleSyntax | {motive : LeanSearchClient.LoogleResult → Sort u} →
(t : LeanSearchClient.LoogleResult) →
motive LeanSearchClient.LoogleResult.empty →
((a : Array LeanSearchClient.SearchResult) → motive (LeanSearchClient.LoogleResult.success a)) →
((error : String) →
(suggestions : Option (List String))... | null | false |
Lean.Parser.Command.namespace.parenthesizer | Lean.Parser.Command | Lean.PrettyPrinter.Parenthesizer | null | true |
Std.Tactic.BVDecide.BVPred.rec | Std.Tactic.BVDecide.Bitblast.BVExpr.Basic | {motive : Std.Tactic.BVDecide.BVPred → Sort u} →
({w : ℕ} →
(lhs : Std.Tactic.BVDecide.BVExpr w) →
(op : Std.Tactic.BVDecide.BVBinPred) →
(rhs : Std.Tactic.BVDecide.BVExpr w) → motive (Std.Tactic.BVDecide.BVPred.bin lhs op rhs)) →
({w : ℕ} →
(expr : Std.Tactic.BVDecide.BVExpr w) → ... | null | false |
RelIso.apply_eq_iff_eq | Mathlib.Order.RelIso.Basic | ∀ {α : Type u_1} {β : Type u_2} {r : α → α → Prop} {s : β → β → Prop} (f : r ≃r s) {x y : α}, f x = f y ↔ x = y | null | true |
MonoidAlgebra.instCoalgebra | Mathlib.RingTheory.Coalgebra.MonoidAlgebra | (R : Type u_1) →
[inst : CommSemiring R] →
(A : Type u_2) →
[inst_1 : Semiring A] → (X : Type u_3) → [inst_2 : Module R A] → [Coalgebra R A] → Coalgebra R (MonoidAlgebra A X) | null | true |
RCLike.instPosMulReflectLE | Mathlib.Analysis.RCLike.Basic | ∀ {K : Type u_1} [inst : RCLike K], PosMulReflectLE K | null | true |
IsOpen.exists_eq_add_of_deriv_eq | Mathlib.Analysis.Calculus.MeanValue | ∀ {𝕜 : Type u_3} {G : Type u_4} [inst : RCLike 𝕜] [inst_1 : NormedAddCommGroup G] [inst_2 : NormedSpace 𝕜 G] {s : Set 𝕜}
{f g : 𝕜 → G},
IsOpen s →
IsPreconnected s →
DifferentiableOn 𝕜 f s →
DifferentiableOn 𝕜 g s → Set.EqOn (deriv f) (deriv g) s → ∃ a, Set.EqOn f (fun x => g x + a) s | null | true |
_private.Batteries.Data.List.Lemmas.0.List.take_succ_drop._proof_1 | Batteries.Data.List.Lemmas | ∀ {α : Type u_1} {l : List α} {n stop : ℕ}, n < l.length - stop → ¬stop + n < l.length → False | null | false |
AlgebraicGeometry.Scheme.Modules.pseudofunctor._proof_7 | Mathlib.AlgebraicGeometry.Modules.Sheaf | ∀ {b₀ b₁ b₂ b₃ : AlgebraicGeometry.Schemeᵒᵖ} (f : b₀ ⟶ b₁) (g : b₁ ⟶ b₂) (h : b₂ ⟶ b₃),
CategoryTheory.CategoryStruct.comp
(CategoryTheory.Bicategory.Adj.iso₂Mk
(CategoryTheory.Cat.Hom.isoMk
(AlgebraicGeometry.Scheme.Modules.pullbackComp h.unop (CategoryTheory.CategoryStruct.comp f g).unop... | null | false |
instCircularOrderZMod._proof_8 | Mathlib.Order.Circular.ZMod | ∀ {a b c d : ZMod 0}, sbtw a b c → sbtw b d c → sbtw a d c | null | false |
_private.Mathlib.Algebra.Category.Ring.Basic.0.RingCat.Hom.mk | Mathlib.Algebra.Category.Ring.Basic | {R S : RingCat} → (↑R →+* ↑S) → R.Hom S | null | true |
NonUnitalSubsemiring.map_equiv_eq_comap_symm | Mathlib.RingTheory.NonUnitalSubsemiring.Basic | ∀ {R : Type u} {S : Type v} [inst : NonUnitalNonAssocSemiring R] [inst_1 : NonUnitalNonAssocSemiring S] (f : R ≃+* S)
(K : NonUnitalSubsemiring R), NonUnitalSubsemiring.map (↑f) K = NonUnitalSubsemiring.comap f.symm K | null | true |
Polynomial.trailingDegree_eq_iff_natTrailingDegree_eq_of_pos | Mathlib.Algebra.Polynomial.Degree.TrailingDegree | ∀ {R : Type u} [inst : Semiring R] {p : Polynomial R} {n : ℕ}, n ≠ 0 → (p.trailingDegree = ↑n ↔ p.natTrailingDegree = n) | null | true |
Topology.IsUpperSet.topology_eq_upperSetTopology | Mathlib.Topology.Order.UpperLowerSetTopology | ∀ {α : Type u_4} {t : TopologicalSpace α} {inst : Preorder α} [self : Topology.IsUpperSet α], t = Topology.upperSet α | null | true |
ContinuousLinearMap.IsPositive.inner_nonneg_right | Mathlib.Analysis.InnerProductSpace.Positive | ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : RCLike 𝕜] [inst_1 : NormedAddCommGroup E] [inst_2 : InnerProductSpace 𝕜 E]
{T : E →L[𝕜] E}, T.IsPositive → ∀ (x : E), 0 ≤ inner 𝕜 x (T x) | null | true |
_private.Mathlib.GroupTheory.Perm.Cycle.Basic.0.Equiv.Perm.IsCycle.of_pow._simp_1_1 | Mathlib.GroupTheory.Perm.Cycle.Basic | ∀ {α : Type u_1} [inst : DecidableEq α] [inst_1 : Fintype α] {f : Equiv.Perm α} {x : α}, (f x ≠ x) = (x ∈ f.support) | null | false |
_private.Mathlib.Data.Set.Finite.Basic.0.Set.finite_of_forall_not_lt_lt._simp_1_1 | Mathlib.Data.Set.Finite.Basic | ∀ {α : Type u} {s : Set α} {p : (x : α) → x ∈ s → Prop}, (∀ (x : α) (h : x ∈ s), p x h) = ∀ (x : ↑s), p ↑x ⋯ | null | false |
Batteries.Tactic.Lint.SimpTheoremInfo.rec | Batteries.Tactic.Lint.Simp | {motive : Batteries.Tactic.Lint.SimpTheoremInfo → Sort u} →
((hyps : Array Lean.Expr) → (lhs rhs : Lean.Expr) → motive { hyps := hyps, lhs := lhs, rhs := rhs }) →
(t : Batteries.Tactic.Lint.SimpTheoremInfo) → motive t | null | false |
_private.Init.Data.UInt.Lemmas.0.USize.pos_iff_ne_zero._simp_1_2 | Init.Data.UInt.Lemmas | ∀ {α : Sort u_1} {a b : α}, (a = b) = (b = a) | null | false |
Vector.back? | Init.Data.Vector.Basic | {α : Type u_1} → {n : ℕ} → Vector α n → Option α | The last element of a vector, or `none` if the vector is empty. | true |
Equiv.sigmaCongrRight_trans | Mathlib.Logic.Equiv.Defs | ∀ {α : Type u_4} {β₁ : α → Type u_1} {β₂ : α → Type u_2} {β₃ : α → Type u_3} (F : (a : α) → β₁ a ≃ β₂ a)
(G : (a : α) → β₂ a ≃ β₃ a),
(Equiv.sigmaCongrRight F).trans (Equiv.sigmaCongrRight G) = Equiv.sigmaCongrRight fun a => (F a).trans (G a) | null | true |
Units.val_le_val._simp_2 | Mathlib.Algebra.Order.Monoid.Units | ∀ {α : Type u_1} [inst : Monoid α] [inst_1 : Preorder α] {a b : αˣ}, (↑a ≤ ↑b) = (a ≤ b) | null | false |
_private.Mathlib.Tactic.LinearCombinationPrime.0.Mathlib.Tactic.LinearCombinationPrime.expandLinearCombo.match_1 | Mathlib.Tactic.LinearCombinationPrime | (motive : Mathlib.Tactic.LinearCombinationPrime.Expanded → Mathlib.Tactic.LinearCombinationPrime.Expanded → Sort u_1) →
(__do_lift __do_lift_1 : Mathlib.Tactic.LinearCombinationPrime.Expanded) →
((c₁ c₂ : Lean.Term) →
motive (Mathlib.Tactic.LinearCombinationPrime.Expanded.const c₁)
(Mathlib.Tact... | null | false |
instReprVector | Init.Data.Vector.Basic | {α : Type u_1} → {n : ℕ} → [Repr α] → Repr (Vector α n) | null | true |
Std.TreeMap.getElem!_diff_of_mem_right | Std.Data.TreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t₁ t₂ : Std.TreeMap α β cmp} [Std.TransCmp cmp] {k : α}
[inst : Inhabited β], k ∈ t₂ → (t₁ \ t₂)[k]! = default | null | true |
Int.le_emod_self_add_one_iff | Init.Data.Int.DivMod.Lemmas | ∀ {a b : ℤ}, 0 < b → (b ≤ a % b + 1 ↔ b ∣ a + 1) | null | true |
CategoryTheory.MonoidalCategory.IsPushout.whiskerLeft_w | Mathlib.CategoryTheory.Monoidal.Limits.Shapes.Pullback | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.MonoidalCategory C] {Z X Y P : C}
{f : Z ⟶ X} {g : Z ⟶ Y} {inl : X ⟶ P} {inr : Y ⟶ P},
CategoryTheory.IsPushout f g inl inr →
∀ {Q : C},
CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategoryStruct.whiskerLeft Q... | null | true |
Lean.Grind.CommSemiring.casesOn | Init.Grind.Ring.Basic | {α : Type u} →
{motive : Lean.Grind.CommSemiring α → Sort u_1} →
(t : Lean.Grind.CommSemiring α) →
([toSemiring : Lean.Grind.Semiring α] →
(mul_comm : ∀ (a b : α), a * b = b * a) → motive { toSemiring := toSemiring, mul_comm := mul_comm }) →
motive t | null | false |
Topology.instIsLowerSet | Mathlib.Topology.Order.UpperLowerSetTopology | ∀ {α : Type u_1} [inst : Preorder α], Topology.IsLowerSet α | null | true |
pointedToBipointedSndBipointedToPointedSndAdjunction | Mathlib.CategoryTheory.Category.Bipointed | pointedToBipointedSnd ⊣ bipointedToPointedSnd | The free/forgetful adjunction between `PointedToBipointed_snd` and `BipointedToPointed_snd`.
| true |
RatFunc.instDiv | Mathlib.FieldTheory.RatFunc.Basic | {K : Type u} → [inst : CommRing K] → [IsDomain K] → Div (RatFunc K) | null | true |
_private.Mathlib.Data.List.Basic.0.List.dropLast_append_getLast.match_1_1 | Mathlib.Data.List.Basic | ∀ {α : Type u_1} (motive : (x : List α) → x ≠ [] → Prop) (x : List α) (x_1 : x ≠ []),
(∀ (h : [] ≠ []), motive [] h) →
(∀ (head : α) (x : [head] ≠ []), motive [head] x) →
(∀ (a b : α) (l : List α) (h : a :: b :: l ≠ []), motive (a :: b :: l) h) → motive x x_1 | null | false |
StandardEtalePair.instCommRingRing._aux_8 | Mathlib.RingTheory.Etale.StandardEtale | {R : Type u_1} → [inst : CommRing R] → (P : StandardEtalePair R) → ℕ → P.Ring → P.Ring | null | false |
_private.Lean.Parser.Term.0.Lean.Parser.Term.withDeclName._regBuiltin.Lean.Parser.Term.withDeclName_1 | Lean.Parser.Term | IO Unit | null | false |
_private.Mathlib.AlgebraicTopology.SimplicialSet.NerveNondegenerate.0.PartialOrder.mem_nerve_nonDegenerate_iff_strictMono._simp_1_1 | Mathlib.AlgebraicTopology.SimplicialSet.NerveNondegenerate | ∀ {X : Type u_1} [inst : PartialOrder X] {n : ℕ} (s : (CategoryTheory.nerve X).obj (Opposite.op { len := n + 1 }))
(i : Fin (n + 1)),
(s ∈
Set.range ⇑(CategoryTheory.ConcreteCategory.hom (CategoryTheory.SimplicialObject.σ (CategoryTheory.nerve X) i))) =
(s.obj i.castSucc = s.obj i.succ) | null | false |
Nat.iSup_le_succ | Mathlib.Order.Lattice.Nat | ∀ {α : Type u_1} [inst : CompleteLattice α] (u : ℕ → α) (n : ℕ),
⨆ k, ⨆ (_ : k ≤ n + 1), u k = (⨆ k, ⨆ (_ : k ≤ n), u k) ⊔ u (n + 1) | null | true |
ContinuousMap.compMonoidHom'._proof_1 | Mathlib.Topology.ContinuousMap.Algebra | ∀ {α : Type u_1} {β : Type u_3} [inst : TopologicalSpace α] [inst_1 : TopologicalSpace β] {γ : Type u_2}
[inst_2 : TopologicalSpace γ] [inst_3 : MulOneClass γ] (g : C(α, β)), ContinuousMap.comp 1 g = 1 | null | false |
HomotopicalAlgebra.cofibration_iff | Mathlib.AlgebraicTopology.ModelCategory.CategoryWithCofibrations | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y : C} (f : X ⟶ Y)
[inst_1 : HomotopicalAlgebra.CategoryWithCofibrations C],
HomotopicalAlgebra.Cofibration f ↔ HomotopicalAlgebra.cofibrations C f | null | true |
CategoryTheory.Pseudofunctor.ObjectProperty.ι | Mathlib.CategoryTheory.Bicategory.Functor.Cat.ObjectProperty | {B : Type u} →
[inst : CategoryTheory.Bicategory B] →
{F : CategoryTheory.Pseudofunctor B CategoryTheory.Cat} →
(P : F.ObjectProperty) → [inst_1 : P.IsClosedUnderMapObj] → P.fullsubcategory.StrongTrans F | The inclusion of `P.fullsubcategory` in `F`. | true |
Function.mulSupport_fun_curry | Mathlib.Algebra.Notation.Support | ∀ {ι : Type u_1} {κ : Type u_2} {M : Type u_3} [inst : One M] (f : ι × κ → M),
(Function.mulSupport fun i j => f (i, j)) = Prod.fst '' Function.mulSupport f | null | true |
Lean.MonadRecDepth.getRecDepth | Lean.Exception | {m : Type → Type} → [self : Lean.MonadRecDepth m] → m ℕ | null | true |
List.le_sum_of_subadditive_on_pred | Mathlib.Algebra.Order.BigOperators.Group.List | ∀ {α : Type u_5} {β : Type u_6} [inst : AddMonoid α] [inst_1 : AddCommMonoid β] [inst_2 : Preorder β]
[IsOrderedAddMonoid β] (f : α → β) (p : α → Prop),
f 0 ≤ 0 →
p 0 →
(∀ (a b : α), p a → p b → f (a + b) ≤ f a + f b) →
(∀ (a b : α), p a → p b → p (a + b)) → ∀ (l : List α), (∀ a ∈ l, p a) → f l.su... | null | true |
Units.ofPow._proof_1 | Mathlib.Algebra.Group.Commute.Units | ∀ {M : Type u_1} [inst : Monoid M] (u : Mˣ) (x : M) {n : ℕ}, n ≠ 0 → x ^ n = ↑u → x * x ^ (n - 1) = ↑u | null | false |
Array.exists_mem_empty | Init.Data.Array.Lemmas | ∀ {α : Type u_1} (p : α → Prop), ¬∃ x, ∃ (_ : x ∈ #[]), p x | null | true |
Function.Injective.unique | Mathlib.Logic.Unique | {α : Sort u_1} → {β : Sort u_2} → {f : α → β} → [Inhabited α] → [Subsingleton β] → Function.Injective f → Unique α | If `α` is inhabited and admits an injective map to a subsingleton type, then `α` is `Unique`. | true |
InnerProductSpace.Core.inner_smul_left | Mathlib.Analysis.InnerProductSpace.Defs | ∀ {𝕜 : Type u_1} {F : Type u_3} [inst : RCLike 𝕜] [inst_1 : AddCommGroup F] [inst_2 : Module 𝕜 F]
[c : PreInnerProductSpace.Core 𝕜 F] (x y : F) {r : 𝕜}, inner 𝕜 (r • x) y = (starRingEnd 𝕜) r * inner 𝕜 x y | null | true |
_private.Mathlib.RingTheory.PrincipalIdealDomain.0.Ideal.nonPrincipals_eq_empty_iff._simp_1_1 | Mathlib.RingTheory.PrincipalIdealDomain | ∀ {α : Type u} {s : Set α}, (s = ∅) = ∀ (x : α), x ∉ s | null | false |
_private.Mathlib.Analysis.SpecialFunctions.Complex.LogBounds.0.Complex.norm_log_sub_logTaylor_le._simp_1_8 | Mathlib.Analysis.SpecialFunctions.Complex.LogBounds | ∀ {M₀ : Type u_1} [inst : Mul M₀] [inst_1 : Zero M₀] [NoZeroDivisors M₀] {a b : M₀}, a ≠ 0 → b ≠ 0 → (a * b = 0) = False | null | false |
Lean.Lsp.DeclInfo.mk | Lean.Data.Lsp.Internal | ℕ → ℕ → ℕ → ℕ → ℕ → ℕ → ℕ → ℕ → Lean.Lsp.DeclInfo | null | true |
AddSubgroup.le_normalClosure | Mathlib.Algebra.Group.Subgroup.Basic | ∀ {G : Type u_1} [inst : AddGroup G] {H : AddSubgroup G}, H ≤ AddSubgroup.normalClosure ↑H | null | true |
Order.exists_series_of_le_coheight | Mathlib.Order.KrullDimension | ∀ {α : Type u_1} [inst : Preorder α] (a : α) {n : ℕ}, ↑n ≤ Order.coheight a → ∃ p, RelSeries.head p = a ∧ p.length = n | null | true |
Mathlib.Tactic.Bicategory.evalWhiskerRight_cons_of_of | Mathlib.Tactic.CategoryTheory.Bicategory.Normalize | ∀ {B : Type u} [inst : CategoryTheory.Bicategory B] {a b c : B} {f g h i : a ⟶ b} {j : b ⟶ c} {α : f ≅ g} {η : g ⟶ h}
{ηs : h ⟶ i} {ηs₁ : CategoryTheory.CategoryStruct.comp h j ⟶ CategoryTheory.CategoryStruct.comp i j}
{η₁ : CategoryTheory.CategoryStruct.comp g j ⟶ CategoryTheory.CategoryStruct.comp h j}
{η₂ : Ca... | null | true |
MeasureTheory.tendsto_of_uncrossing_lt_top | Mathlib.Probability.Martingale.Convergence | ∀ {Ω : Type u_1} {f : ℕ → Ω → ℝ} {ω : Ω},
Filter.liminf (fun n => ↑‖f n ω‖₊) Filter.atTop < ⊤ →
(∀ (a b : ℚ), a < b → MeasureTheory.upcrossings (↑a) (↑b) f ω < ⊤) →
∃ c, Filter.Tendsto (fun n => f n ω) Filter.atTop (nhds c) | A realization of a stochastic process with bounded upcrossings and bounded limit inferiors is
convergent.
We use the spelling `< ∞` instead of the standard `≠ ∞` in the assumptions since it is not as easy
to change `<` to `≠` under binders. | true |
Mathlib.Tactic.RingNF.RingMode.recOn | Mathlib.Tactic.Ring.RingNF | {motive : Mathlib.Tactic.RingNF.RingMode → Sort u} →
(t : Mathlib.Tactic.RingNF.RingMode) →
motive Mathlib.Tactic.RingNF.RingMode.SOP → motive Mathlib.Tactic.RingNF.RingMode.raw → motive t | null | false |
AddCommute.op | Mathlib.Algebra.Group.Opposite | ∀ {α : Type u_1} [inst : Add α] {x y : α}, AddCommute x y → AddCommute (AddOpposite.op x) (AddOpposite.op y) | null | true |
Algebra.Generators.toExtendScalars._proof_2 | Mathlib.RingTheory.Extension.Generators | ∀ {R : Type u_4} {S : Type u_3} {ι : Type u_2} [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S]
{T : Type u_1} [inst_3 : CommRing T] [inst_4 : Algebra R T] [inst_5 : Algebra S T] [inst_6 : IsScalarTower R S T]
(P : Algebra.Generators R T ι) (i : ι),
(MvPolynomial.aeval (Algebra.Generators.extendSc... | null | false |
Polynomial.natDegree_pow_X_add_C | Mathlib.Algebra.Polynomial.Monic | ∀ {R : Type u} [inst : Semiring R] [Nontrivial R] (n : ℕ) (r : R), ((Polynomial.X + Polynomial.C r) ^ n).natDegree = n | null | true |
MeasureTheory.Lp.instModule._proof_5 | Mathlib.MeasureTheory.Function.LpSpace.Basic | ∀ {α : Type u_1} {𝕜 : Type u_3} {E : Type u_2} {m : MeasurableSpace α} {p : ENNReal} {μ : MeasureTheory.Measure α}
[inst : NormedAddCommGroup E] [inst_1 : NormedRing 𝕜] [inst_2 : Module 𝕜 E] [inst_3 : IsBoundedSMul 𝕜 E] (r s : 𝕜)
(x : ↥(MeasureTheory.Lp E p μ)), (r + s) • x = r • x + s • x | null | false |
CategoryTheory.Limits.Cone.fromStructuredArrow._proof_2 | Mathlib.CategoryTheory.Limits.ConeCategory | ∀ {J : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} J] {C : Type u_6}
[inst_1 : CategoryTheory.Category.{u_5, u_6} C] {D : Type u_4} [inst_2 : CategoryTheory.Category.{u_3, u_4} D]
(F : CategoryTheory.Functor C D) {X : D} (G : CategoryTheory.Functor J (CategoryTheory.StructuredArrow X F))
⦃X_1 Y : J⦄ (f :... | null | false |
_private.Mathlib.Order.Disjoint.0.disjoint_assoc._proof_1_1 | Mathlib.Order.Disjoint | ∀ {α : Type u_1} [inst : SemilatticeInf α] [inst_1 : OrderBot α] {a b c : α}, Disjoint (a ⊓ b) c ↔ Disjoint a (b ⊓ c) | null | false |
Substring.Raw.ValidFor.isEmpty | Batteries.Data.String.Lemmas | ∀ {l m r : List Char} {s : Substring.Raw}, Substring.Raw.ValidFor l m r s → (s.isEmpty = true ↔ m = []) | null | true |
_private.Std.Data.Iterators.Lemmas.Combinators.Zip.0.Std.Iter.step_intermediateZip.match_1.eq_2 | Std.Data.Iterators.Lemmas.Combinators.Zip | ∀ {α₁ β₁ : Type u_1} [inst : Std.Iterator α₁ Id β₁] {it₁ : Std.Iter β₁} (motive : it₁.Step → Sort u_2)
(it₁' : Std.Iter β₁) (hp : it₁.IsPlausibleStep (Std.IterStep.skip it₁'))
(h_1 :
(it₁' : Std.Iter β₁) →
(out : β₁) → (hp : it₁.IsPlausibleStep (Std.IterStep.yield it₁' out)) → motive ⟨Std.IterStep.yield i... | null | true |
AlgebraicGeometry.IsFinite.rec | Mathlib.AlgebraicGeometry.Morphisms.Finite | {X Y : AlgebraicGeometry.Scheme} →
{f : X ⟶ Y} →
{motive : AlgebraicGeometry.IsFinite f → Sort u} →
([toIsAffineHom : AlgebraicGeometry.IsAffineHom f] →
(finite_app :
∀ (U : Y.Opens),
AlgebraicGeometry.IsAffineOpen U →
(CommRingCat.Hom.hom (Algebraic... | null | false |
Num.toZNum_inj | Mathlib.Data.Num.Lemmas | ∀ {m n : Num}, m.toZNum = n.toZNum ↔ m = n | null | true |
Std.DTreeMap.Internal.Impl.getEntryLT | Std.Data.DTreeMap.Internal.Queries | {α : Type u} →
{β : α → Type v} →
[inst : Ord α] →
[Std.TransOrd α] →
(k : α) →
(t : Std.DTreeMap.Internal.Impl α β) → t.Ordered → (∃ a ∈ t, compare a k = Ordering.lt) → (a : α) × β a | Implementation detail of the tree map | true |
Batteries.instOrientedCmpCompareOnOfOrientedOrd | Batteries.Classes.Deprecated | ∀ {β : Type u_1} {α : Sort u_2} [inst : Ord β] [Batteries.OrientedOrd β] (f : α → β),
Batteries.OrientedCmp (compareOn f) | null | true |
PFun.prodMap_id_id | Mathlib.Data.PFun | ∀ {α : Type u_1} {β : Type u_2}, (PFun.id α).prodMap (PFun.id β) = PFun.id (α × β) | null | true |
ModularForm.mk.noConfusion | Mathlib.NumberTheory.ModularForms.Basic | {Γ : Subgroup (GL (Fin 2) ℝ)} →
{k : ℤ} →
{P : Sort u} →
{toSlashInvariantForm : SlashInvariantForm Γ k} →
{holo' : MDiff ⇑toSlashInvariantForm} →
{bdd_at_cusps' : ∀ {c : OnePoint ℝ}, IsCusp c Γ → c.IsBoundedAt toSlashInvariantForm.toFun k} →
{toSlashInvariantForm' : SlashInvar... | null | false |
Lean.Meta.Grind.Arith.Cutsat.LeCnstr.brecOn.eq | Lean.Meta.Tactic.Grind.Arith.Cutsat.Types | ∀ {motive_1 : Lean.Meta.Grind.Arith.Cutsat.EqCnstr → Sort u}
{motive_2 : Lean.Meta.Grind.Arith.Cutsat.EqCnstrProof → Sort u}
{motive_3 : Lean.Meta.Grind.Arith.Cutsat.DvdCnstr → Sort u}
{motive_4 : Lean.Meta.Grind.Arith.Cutsat.CooperSplitPred → Sort u}
{motive_5 : Lean.Meta.Grind.Arith.Cutsat.CooperSplit → Sort ... | null | true |
Fin.foldr_congr | Init.Data.Fin.Fold | ∀ {α : Sort u_1} {n k : ℕ} (w : n = k) (f : Fin n → α → α), Fin.foldr n f = Fin.foldr k fun i => f (Fin.cast ⋯ i) | null | true |
topologicalGroup_of_lieGroup | Mathlib.Geometry.Manifold.Algebra.LieGroup | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {H : Type u_2} [inst_1 : TopologicalSpace H] {E : Type u_3}
[inst_2 : NormedAddCommGroup E] [inst_3 : NormedSpace 𝕜 E] (I : ModelWithCorners 𝕜 E H) (n : WithTop ℕ∞)
{G : Type u_4} [inst_4 : TopologicalSpace G] [inst_5 : ChartedSpace H G] [inst_6 : Group G] [Li... | A Lie group is a topological group. This is not an instance for technical reasons,
see note [Design choices about smooth algebraic structures]. | true |
_private.Mathlib.Data.Finset.Prod.0.Finset.subset_product_image_fst._simp_1_1 | Mathlib.Data.Finset.Prod | ∀ {α : Type u_1} {β : Type u_2} [inst : DecidableEq β] {f : α → β} {s : Finset α} {b : β},
(b ∈ Finset.image f s) = ∃ a ∈ s, f a = b | null | false |
Finset.prod_bij' | Mathlib.Algebra.BigOperators.Group.Finset.Defs | ∀ {ι : Type u_1} {κ : Type u_2} {M : Type u_3} [inst : CommMonoid M] {s : Finset ι} {t : Finset κ} {f : ι → M}
{g : κ → M} (i : (a : ι) → a ∈ s → κ) (j : (a : κ) → a ∈ t → ι) (hi : ∀ (a : ι) (ha : a ∈ s), i a ha ∈ t)
(hj : ∀ (a : κ) (ha : a ∈ t), j a ha ∈ s),
(∀ (a : ι) (ha : a ∈ s), j (i a ha) ⋯ = a) →
(∀ (a... | Reorder a product.
The difference with `Finset.prod_bij` is that the bijection is specified with an inverse, rather
than as a surjective injection.
The difference with `Finset.prod_nbij'` is that the bijection and its inverse are allowed to use
membership of the domains of the products, rather than being non-dependen... | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.