name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11.5k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
gaugeSeminormFamily_ball | Mathlib.Analysis.LocallyConvex.AbsConvexOpen | ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : RCLike 𝕜] [inst_1 : AddCommGroup E] [inst_2 : TopologicalSpace E]
[inst_3 : Module 𝕜 E] [inst_4 : Module ℝ E] [inst_5 : IsScalarTower ℝ 𝕜 E] [inst_6 : ContinuousSMul ℝ E]
(s : AbsConvexOpenSets 𝕜 E), (gaugeSeminormFamily 𝕜 E s).ball 0 1 = ↑s | null | true |
InfHom.coe_mk | Mathlib.Order.Hom.Lattice | ∀ {α : Type u_2} {β : Type u_3} [inst : Min α] [inst_1 : Min β] (f : α → β) (hf : ∀ (a b : α), f (a ⊓ b) = f a ⊓ f b),
⇑{ toFun := f, map_inf' := hf } = f | null | true |
TopPair.Homotopy.trans._proof_2 | Mathlib.Topology.Category.TopPair | ∀ {X Y : TopPair} {f₀ f₁ f₂ : X ⟶ Y} (F : TopPair.Homotopy f₀ f₁) (G : TopPair.Homotopy f₁ f₂),
CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategoryStruct.whiskerRight TopPair.map TopCat.I)
(TopCat.Homotopy.h (F.fst.trans G.fst)) =
CategoryTheory.CategoryStruct.comp (TopCat.Homotopy.h (F.snd.... | null | false |
List.lawfulBEq_iff | Init.Data.List.Lemmas | ∀ {α : Type u_1} [inst : BEq α], LawfulBEq (List α) ↔ LawfulBEq α | null | true |
lie_mem_left | Mathlib.Algebra.Lie.Ideal | ∀ (R : Type u) (L : Type v) [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : LieAlgebra R L] (I : LieIdeal R L)
(x y : L), x ∈ I → ⁅x, y⁆ ∈ I | null | true |
Set.uIoc_injective_left | Mathlib.Order.Interval.Set.UnorderedInterval | ∀ {α : Type u_1} [inst : LinearOrder α] (a : α), Function.Injective (Set.uIoc a) | null | true |
_private.Batteries.Data.List.Lemmas.0.List.getElem_idxOf_eq_idxOfNth_add._proof_1_2 | Batteries.Data.List.Lemmas | ∀ {α : Type u_1} {x : α} [inst : BEq α] {n s : ℕ} (h : n + 1 ≤ (List.idxsOf x [] s).length),
(List.idxsOf x [] s)[n] - s < [].length | null | false |
Finset.sum_smul | Mathlib.Algebra.Module.BigOperators | ∀ {ι : Type u_1} {R : Type u_5} {M : Type u_6} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
{f : ι → R} {s : Finset ι} {x : M}, (∑ i ∈ s, f i) • x = ∑ i ∈ s, f i • x | null | true |
_private.Mathlib.RingTheory.RingHom.Integral.0.RingHom.isIntegral_ofLocalizationSpan._simp_1_7 | Mathlib.RingTheory.RingHom.Integral | ∀ {G : Type u_7} {H : Type u_8} {F : Type u_9} [inst : FunLike F G H] [inst_1 : Monoid G] [inst_2 : Monoid H]
[MonoidHomClass F G H] (f : F) (a : G) (n : ℕ), f a ^ n = f (a ^ n) | null | false |
_private.Mathlib.Order.RelSeries.0.LTSeries.apply_add_index_le_apply_add_index_int._proof_1_7 | Mathlib.Order.RelSeries | ∀ (p : LTSeries ℤ) (j : ℕ), j + 1 < p.length + 1 → j < p.length | null | false |
_private.Batteries.Logic.0.not_nonempty_pempty.match_1_1 | Batteries.Logic | ∀ (motive : Nonempty PEmpty.{u_1} → Prop) (x : Nonempty PEmpty.{u_1}), (∀ (h : PEmpty.{u_1}), motive ⋯) → motive x | null | false |
SuccAddOrder.toSuccOrder | Mathlib.Algebra.Order.SuccPred | {α : Type u_1} → {inst : Preorder α} → {inst_1 : Add α} → {inst_2 : One α} → [self : SuccAddOrder α] → SuccOrder α | null | true |
isGLB_singleton._simp_1 | Mathlib.Order.Bounds.Basic | ∀ {α : Type u_1} [inst : Preorder α] {a : α}, IsGLB {a} a = True | null | false |
CategoryTheory.ObjectProperty.ι_obj_lift_obj | Mathlib.CategoryTheory.ObjectProperty.FullSubcategory | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {D : Type u'} [inst_1 : CategoryTheory.Category.{v', u'} D]
(P : CategoryTheory.ObjectProperty D) (F : CategoryTheory.Functor C D) (hF : ∀ (X : C), P (F.obj X)) (X : C),
P.ι.obj ((P.lift F hF).obj X) = F.obj X | null | true |
IsOfFinAddOrder.prod_iff | Mathlib.GroupTheory.OrderOfElement | ∀ {α : Type u_4} {β : Type u_5} [inst : AddMonoid α] [inst_1 : AddMonoid β] {x : α × β},
IsOfFinAddOrder x ↔ IsOfFinAddOrder x.1 ∧ IsOfFinAddOrder x.2 | null | true |
Std.Tactic.BVDecide.LRAT.Internal.Clause.isUnit_iff | Std.Tactic.BVDecide.LRAT.Internal.Clause | ∀ {α : outParam (Type u)} {β : Type v} [self : Std.Tactic.BVDecide.LRAT.Internal.Clause α β] (c : β)
(l : Std.Sat.Literal α),
Std.Tactic.BVDecide.LRAT.Internal.Clause.isUnit c = some l ↔ Std.Tactic.BVDecide.LRAT.Internal.Clause.toList c = [l] | null | true |
RingEquiv.toSemiRingCatIso._proof_3 | Mathlib.Algebra.Category.Ring.Basic | ∀ {R S : Type u_1} [inst : Semiring R] [inst_1 : Semiring S], RingHomClass (S ≃+* R) S R | null | false |
Profinite.NobelingProof.continuous_CC'₁ | Mathlib.Topology.Category.Profinite.Nobeling.Successor | ∀ {I : Type u} (C : Set (I → Bool)) [inst : LinearOrder I] [inst_1 : WellFoundedLT I] {o : Ordinal.{u}}
(hsC : Profinite.NobelingProof.contained C (Order.succ o)) (ho : o < Ordinal.type fun x1 x2 => x1 < x2),
Continuous (Profinite.NobelingProof.CC'₁ C hsC ho) | null | true |
Equiv.eq_conj | Mathlib.Logic.Equiv.Basic | ∀ {α : Sort u_11} {α' : Sort u_12} {β : Sort u_13} {β' : Sort u_14} (ε₁ : α ≃ α') (ε₂ : β' ≃ β) (f : α → β)
(f' : α' → β'), ⇑ε₂.symm ∘ f ∘ ⇑ε₁.symm = f' ↔ f = ⇑ε₂ ∘ f' ∘ ⇑ε₁ | null | true |
AlgebraicGeometry.Scheme.Pullback.openCoverOfLeft_I₀ | Mathlib.AlgebraicGeometry.Pullbacks | ∀ {X Y Z : AlgebraicGeometry.Scheme} (𝒰 : X.OpenCover) (f : X ⟶ Z) (g : Y ⟶ Z),
(AlgebraicGeometry.Scheme.Pullback.openCoverOfLeft 𝒰 f g).I₀ = 𝒰.I₀ | null | true |
MvPowerSeries.substAlgHom_coe | Mathlib.RingTheory.MvPowerSeries.Substitution | ∀ {σ : Type u_1} {R : Type u_3} [inst : CommRing R] {τ : Type u_4} {S : Type u_5} [inst_1 : CommRing S]
[inst_2 : Algebra R S] {a : σ → MvPowerSeries τ S} (ha : MvPowerSeries.HasSubst a) (p : MvPolynomial σ R),
(MvPowerSeries.substAlgHom ha) ↑p = (MvPolynomial.aeval a) p | null | true |
Mathlib.Explode.Entry.casesOn | Mathlib.Tactic.Explode.Datatypes | {motive : Mathlib.Explode.Entry → Sort u} →
(t : Mathlib.Explode.Entry) →
((type : Lean.MessageData) →
(line : Option ℕ) →
(depth : ℕ) →
(status : Mathlib.Explode.Status) →
(thm : Lean.MessageData) →
(deps : List (Option ℕ)) →
(useAsDep... | null | false |
Algebra.Extension.h1Cotangentι_ext | Mathlib.RingTheory.Extension.Cotangent.Basic | ∀ {R : Type u} {S : Type v} [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S] {P : Algebra.Extension R S}
(x y : P.H1Cotangent), ↑x = ↑y → x = y | null | true |
GenContFract.nextDen | Mathlib.Algebra.ContinuedFractions.Basic | {K : Type u_2} → [DivisionRing K] → K → K → K → K → K | Returns the next denominator `Bₙ = bₙ₋₁ * Bₙ₋₁ + aₙ₋₁ * Bₙ₋₂`, where `predB` is `Bₙ₋₁` and
`ppredB` is `Bₙ₋₂`, `a` is `aₙ₋₁`, and `b` is `bₙ₋₁`.
| true |
_private.Lean.Meta.Match.MatchEqs.0.Lean.Meta.Match.initFn._@.Lean.Meta.Match.MatchEqs.3248161880._hygCtx._hyg.2 | Lean.Meta.Match.MatchEqs | IO Unit | null | false |
EuclideanDomain.mul_div_cancel' | Mathlib.Algebra.EuclideanDomain.Basic | ∀ {R : Type u} [inst : EuclideanDomain R] {a b : R}, b ≠ 0 → b ∣ a → b * (a / b) = a | null | true |
Lean.Parser.Term.optConfig.parenthesizer | Lean.Parser.Term | Lean.PrettyPrinter.Parenthesizer | null | true |
Nat.or_mod_two_eq_one | Init.Data.Nat.Bitwise.Lemmas | ∀ {a b : ℕ}, (a ||| b) % 2 = 1 ↔ a % 2 = 1 ∨ b % 2 = 1 | null | true |
Turing.Dir.left.sizeOf_spec | Mathlib.Computability.TuringMachine.Tape | sizeOf Turing.Dir.left = 1 | null | true |
_private.Lean.Meta.Tactic.Grind.Types.0.Lean.Meta.Grind.SolverExtension.mk.injEq | Lean.Meta.Tactic.Grind.Types | ∀ {σ : Type} (id : ℕ) (mkInitial : IO σ) (internalize : Lean.Expr → Option Lean.Expr → Lean.Meta.Grind.GoalM Unit)
(newEq newDiseq : Lean.Expr → Lean.Expr → Lean.Meta.Grind.GoalM Unit) (mbtc : Lean.Meta.Grind.GoalM Bool)
(action : Lean.Meta.Grind.Action) (check : Lean.Meta.Grind.GoalM Bool) (checkInv : Lean.Meta.Gr... | null | true |
Submodule.one_mem_div._simp_1 | Mathlib.Algebra.Algebra.Operations | ∀ {R : Type u} [inst : CommSemiring R] {A : Type v} [inst_1 : CommSemiring A] [inst_2 : Algebra R A]
{I J : Submodule R A}, (1 ∈ I / J) = (J ≤ I) | null | false |
_private.Mathlib.Data.Nat.Factorial.Basic.0.Nat.descFactorial_self.match_1_1 | Mathlib.Data.Nat.Factorial.Basic | ∀ (motive : ℕ → Prop) (x : ℕ), (∀ (a : Unit), motive 0) → (∀ (n : ℕ), motive n.succ) → motive x | null | false |
_private.Mathlib.GroupTheory.Perm.Cycle.Type.0.Equiv.Perm.IsThreeCycle.nodup_iff_mem_support._proof_1_40 | Mathlib.GroupTheory.Perm.Cycle.Type | ∀ {α : Type u_1} [inst_1 : DecidableEq α] (w : α),
List.idxOfNth w [] 0 + 1 ≤ (List.filter (fun x => decide (x = w)) []).length →
List.idxOfNth w [] 0 < (List.filter (fun x => decide (x = w)) []).length | null | false |
_private.Mathlib.Data.Set.Card.0.Set.Finite.exists_injOn_of_encard_le._simp_1_12 | Mathlib.Data.Set.Card | ∀ {b a : Prop}, (∃ (_ : a), b) = (a ∧ b) | null | false |
Associates | Mathlib.Algebra.GroupWithZero.Associated | (M : Type u_2) → [Monoid M] → Type u_2 | The quotient of a monoid by the `Associated` relation. Two elements `x` and `y`
are associated iff there is a unit `u` such that `x * u = y`. There is a natural
monoid structure on `Associates M`. | true |
Lean.ParametricAttribute.mk._flat_ctor | Lean.Attributes | {α : Type} →
Lean.AttributeImpl →
Lean.PersistentEnvExtension (Lean.Name × α) (Lean.Name × α) (List Lean.Name × Lean.NameMap α) →
Bool → Lean.ParametricAttribute α | null | false |
eventually_nhdsWithin_iff | Mathlib.Topology.NhdsWithin | ∀ {α : Type u_1} [inst : TopologicalSpace α] {a : α} {s : Set α} {p : α → Prop},
(∀ᶠ (x : α) in nhdsWithin a s, p x) ↔ ∀ᶠ (x : α) in nhds a, x ∈ s → p x | null | true |
Polynomial.Chebyshev.T_derivative_mem_span_T | Mathlib.RingTheory.Polynomial.Chebyshev | ∀ {R : Type u_1} [inst : CommRing R] (n : ℕ),
Polynomial.derivative (Polynomial.Chebyshev.T R ↑n) ∈
Submodule.span ℕ ((fun m => Polynomial.Chebyshev.T R ↑m) '' Set.Ico 0 n) | null | true |
Qq.Impl.UnquoteState.exprBackSubst | Qq.Macro | Qq.Impl.UnquoteState → Std.HashMap Lean.Expr Qq.Impl.ExprBackSubstResult | Maps free variables in the new context to expressions in the old context (of type Expr) | true |
Matrix.Fin.circulant_mul_comm | Mathlib.LinearAlgebra.Matrix.Circulant | ∀ {α : Type u_1} [inst : CommMagma α] [inst_1 : AddCommMonoid α] {n : ℕ} (v w : Fin n → α),
Matrix.circulant v * Matrix.circulant w = Matrix.circulant w * Matrix.circulant v | null | true |
SimpleGraph.ConnectedComponent.even_card_of_isPerfectMatching | Mathlib.Combinatorics.SimpleGraph.Matching | ∀ {V : Type u_1} {G : SimpleGraph V} {M : G.Subgraph} [inst : Fintype V] [inst_1 : DecidableEq V]
[inst_2 : DecidableRel G.Adj] (c : G.ConnectedComponent), M.IsPerfectMatching → Even (Fintype.card ↑c.supp) | null | true |
MulOpposite.instInvolutiveNeg | Mathlib.Algebra.Opposites | {α : Type u_1} → [InvolutiveNeg α] → InvolutiveNeg αᵐᵒᵖ | null | true |
Fin.predAbove._proof_2 | Mathlib.Data.Fin.SuccPred | ∀ {n : ℕ} (p : Fin n) (i : Fin (n + 1)), p.castSucc < i → i ≠ 0 | null | false |
metricSpacePi._proof_1 | Mathlib.Topology.MetricSpace.Basic | ∀ {β : Type u_1} {X : β → Type u_2} [inst : (b : β) → MetricSpace (X b)], T0Space ((i : β) → X i) | null | false |
IsPowMul.restriction | Mathlib.Analysis.Normed.Ring.Basic | ∀ {R : Type u_5} {S : Type u_6} [inst : CommRing R] [inst_1 : Ring S] [inst_2 : Algebra R S] (A : Subalgebra R S)
{f : S → ℝ}, IsPowMul f → IsPowMul fun x => f ↑x | The restriction of a power-multiplicative function to a subalgebra is power-multiplicative. | true |
WellFoundedLT.toOrderBot._proof_3 | Mathlib.Order.WellFounded | ∀ (α : Type u_1) [inst : LinearOrder α] [h : WellFoundedLT α] (a : α), ⋯.min Set.univ ⋯ ≤ a | null | false |
_private.Mathlib.LinearAlgebra.Dimension.Free.0.FiniteDimensional.nonempty_linearEquiv_iff_finrank_eq.match_1_1 | Mathlib.LinearAlgebra.Dimension.Free | ∀ {R : Type u_3} {M : Type u_2} {M' : Type u_1} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
[inst_3 : AddCommMonoid M'] [inst_4 : Module R M'] (motive : Nonempty (M ≃ₗ[R] M') → Prop)
(x : Nonempty (M ≃ₗ[R] M')), (∀ (h : M ≃ₗ[R] M'), motive ⋯) → motive x | null | false |
Ordinal._aux_Mathlib_SetTheory_Ordinal_Veblen___macroRules_Ordinal_termε₀_1 | Mathlib.SetTheory.Ordinal.Veblen | Lean.Macro | null | false |
_private.Mathlib.Topology.IsLocalHomeomorph.0.IsLocalHomeomorphOn.discreteTopology_image_iff._simp_1_2 | Mathlib.Topology.IsLocalHomeomorph | ∀ {α : Sort u} {p : α → Prop} {a1 a2 : { x // p x }}, (a1 = a2) = (↑a1 = ↑a2) | null | false |
FiniteDimensional.basisSingleton._proof_6 | Mathlib.LinearAlgebra.FiniteDimensional.Basic | ∀ {K : Type u_1} [inst : DivisionRing K], RingHomInvPair (RingHom.id K) (RingHom.id K) | null | false |
_private.Lean.Elab.Tactic.BVDecide.Frontend.Normalize.Enums.0.Lean.Elab.Tactic.BVDecide.Frontend.Normalize.mkCondChain.go._sunfold | Lean.Elab.Tactic.BVDecide.Frontend.Normalize.Enums | {w : ℕ} → Lean.Expr → Lean.Expr → Lean.Expr → (ℕ → BitVec w) → List Lean.Expr → ℕ → Lean.Expr → Lean.MetaM Lean.Expr | null | false |
MonoidAlgebra.nonUnitalNonAssocRing._proof_2 | Mathlib.Algebra.MonoidAlgebra.Defs | ∀ {R : Type u_1} {M : Type u_2} [inst : Ring R] [inst_1 : Mul M] (a b c : MonoidAlgebra R M),
(a + b) * c = a * c + b * c | null | false |
CentroidHom.instAddCommGroup._proof_3 | Mathlib.Algebra.Ring.CentroidHom | ∀ {α : Type u_1} [inst : NonUnitalNonAssocRing α] (x y : CentroidHom α), (x + y).toEnd = x.toEnd + y.toEnd | null | false |
AlgebraicGeometry.Scheme.Hom.map_appLE'_assoc | Mathlib.AlgebraicGeometry.Scheme | ∀ {X Y : AlgebraicGeometry.Scheme} (f : X ⟶ Y) {U U' : Y.Opens} {V : X.Opens}
(e : V ≤ (TopologicalSpace.Opens.map f.base).obj U) (i : U' = U) {Z : CommRingCat}
(h : X.presheaf.obj (Opposite.op V) ⟶ Z),
CategoryTheory.CategoryStruct.comp (Y.presheaf.map (CategoryTheory.eqToHom i).op)
(CategoryTheory.Categor... | null | true |
Aesop.runTacticMAsElabM | Aesop.RuleTac.ElabRuleTerm | {α : Type} → Lean.Elab.Tactic.TacticM α → Aesop.ElabM α | null | true |
Filter.Germ.instDivisionSemiring._proof_6 | Mathlib.Order.Filter.FilterProduct | ∀ {α : Type u_2} {β : Type u_1} {φ : Ultrafilter α} [DivisionSemiring β], Nontrivial ((↑φ).Germ β) | null | false |
Cardinal.mul_natCast_le_mul_natCast._simp_1 | Mathlib.SetTheory.Cardinal.Arithmetic | ∀ {n : ℕ} {a b : Cardinal.{u_1}}, n ≠ 0 → (a * ↑n ≤ b * ↑n) = (a ≤ b) | null | false |
_private.Lean.Elab.MutualInductive.0.Lean.Elab.Command.withInductiveLocalDecls.loop._unsafe_rec | Lean.Elab.MutualInductive | {α : Type} →
Array Lean.Elab.Command.PreElabHeaderResult →
(Array Lean.Expr → Array Lean.Expr → Lean.Elab.TermElabM α) →
Array Lean.Expr → ℕ → Array Lean.Expr → Lean.Elab.TermElabM α | null | false |
Mathlib.Tactic.Choose.ElimStatus.ctorIdx | Mathlib.Tactic.Choose | Mathlib.Tactic.Choose.ElimStatus → ℕ | null | false |
_private.Lean.Meta.ExprDefEq.0.Lean.Meta.trySynthPending | Lean.Meta.ExprDefEq | Lean.Expr → Lean.MetaM Bool | null | true |
List.toList_mkSlice_roc | Init.Data.Slice.List.Lemmas | ∀ {α : Type u_1} {xs : List α} {lo hi : ℕ},
Std.Slice.toList (Std.Roc.Sliceable.mkSlice xs lo<...=hi) = List.drop (lo + 1) (List.take (hi + 1) xs) | null | true |
Option.pfilter_congr | Init.Data.Option.Lemmas | ∀ {α : Type u} {o o' : Option α} (ho : o = o') {f : (a : α) → o = some a → Bool} {g : (a : α) → o' = some a → Bool},
(∀ (a : α) (ha : o' = some a), f a ⋯ = g a ha) → o.pfilter f = o'.pfilter g | null | true |
CategoryTheory.RanIsSheafOfIsCocontinuous.liftAux_map | Mathlib.CategoryTheory.Sites.CoverLifting | ∀ {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] {G : CategoryTheory.Functor C D} {A : Type w}
[inst_2 : CategoryTheory.Category.{w', w} A] {J : CategoryTheory.GrothendieckTopology C}
{K : CategoryTheory.GrothendieckTopology D} [inst_3 :... | null | true |
_private.Lean.Parser.Term.0.Lean.Parser.Term.clear._regBuiltin.Lean.Parser.Term.clear.parenthesizer_13 | Lean.Parser.Term | IO Unit | null | false |
OrderType.lift_id | Mathlib.Order.Types.Defs | ∀ (o : OrderType.{u}), OrderType.lift.{u, u} o = o | An order type lifted to the same universe equals itself. | true |
MeasureTheory.ofReal_lpNorm | Mathlib.MeasureTheory.Function.LpSeminorm.LpNorm | ∀ {α : Type u_1} {E : Type u_2} {m : MeasurableSpace α} {p : ENNReal} {μ : MeasureTheory.Measure α}
[inst : NormedAddCommGroup E] {f : α → E},
MeasureTheory.MemLp f p μ → ENNReal.ofReal (MeasureTheory.lpNorm f p μ) = MeasureTheory.eLpNorm f p μ | null | true |
_private.Lean.Util.OccursCheck.0.Lean.occursCheck.visit._unsafe_rec | Lean.Util.OccursCheck | {m : Type → Type} → [Monad m] → [Lean.MonadMCtx m] → Lean.MVarId → Lean.Expr → ExceptT Unit (StateT Lean.ExprSet m) Unit | null | false |
_private.Init.Data.Nat.Lemmas.0.Nat.le_pow._proof_1_1 | Init.Data.Nat.Lemmas | ∀ {a : ℕ} {b : ℕ}, 0 < b → ¬b = b - 1 + 1 → False | null | false |
Array.pmap_ne_empty_iff | Init.Data.Array.Attach | ∀ {α : Type u_1} {β : Type u_2} {P : α → Prop} (f : (a : α) → P a → β) {xs : Array α} (H : ∀ a ∈ xs, P a),
Array.pmap f xs H ≠ #[] ↔ xs ≠ #[] | null | true |
PointedCone.dual_le_dual | Mathlib.Geometry.Convex.Cone.Dual | ∀ {R : Type u_1} [inst : CommSemiring R] [inst_1 : PartialOrder R] [inst_2 : IsOrderedRing R] {M : Type u_2}
[inst_3 : AddCommMonoid M] [inst_4 : Module R M] {N : Type u_3} [inst_5 : AddCommMonoid N] [inst_6 : Module R N]
{p : M →ₗ[R] N →ₗ[R] R} {s t : Set M}, t ⊆ s → PointedCone.dual p s ≤ PointedCone.dual p t | **Alias** of `PointedCone.dual_anti`. | true |
Std.ExtTreeMap.minKey!_insertIfNew_le_self | Std.Data.ExtTreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.ExtTreeMap α β cmp} [inst : Std.TransCmp cmp]
[inst_1 : Inhabited α] {k : α} {v : β}, (cmp (t.insertIfNew k v).minKey! k).isLE = true | null | true |
DirectSum.sigmaCurryEquiv._proof_2 | Mathlib.Algebra.DirectSum.Basic | ∀ {ι : Type u_3} [inst : DecidableEq ι] {α : ι → Type u_2} {δ : (i : ι) → α i → Type u_1}
[inst_1 : (i : ι) → (j : α i) → AddCommMonoid (δ i j)],
Function.RightInverse DFinsupp.sigmaCurryEquiv.invFun DFinsupp.sigmaCurryEquiv.toFun | null | false |
Dilation.isClosedEmbedding | Mathlib.Topology.MetricSpace.Dilation | ∀ {α : Type u_1} {β : Type u_2} {F : Type u_4} [inst : EMetricSpace α] [inst_1 : FunLike F α β] [CompleteSpace α]
[inst_3 : EMetricSpace β] [DilationClass F α β] (f : F), Topology.IsClosedEmbedding ⇑f | A dilation from a complete emetric space is a closed embedding | true |
DirectSum.instRingOfNat._proof_2 | Mathlib.Algebra.DirectSum.Ring | ∀ {ι : Type u_1} [inst : DecidableEq ι] (A : ι → Type u_2) [inst_1 : (i : ι) → AddCommGroup (A i)]
[inst_2 : AddMonoid ι], (DirectSum.of A 0) 0 = 0 | null | false |
TensorProduct.instInhabited | Mathlib.LinearAlgebra.TensorProduct.Defs | {R : Type u_1} →
[inst : CommSemiring R] →
(M : Type u_7) →
(N : Type u_8) →
[inst_1 : AddCommMonoid M] →
[inst_2 : AddCommMonoid N] → [inst_3 : Module R M] → [inst_4 : Module R N] → Inhabited (TensorProduct R M N) | null | true |
Finmap.lookup_union_right | Mathlib.Data.Finmap | ∀ {α : Type u} {β : α → Type v} [inst : DecidableEq α] {a : α} {s₁ s₂ : Finmap β},
a ∉ s₁ → Finmap.lookup a (s₁ ∪ s₂) = Finmap.lookup a s₂ | null | true |
LE.rec | Init.Prelude | {α : Type u} → {motive : LE α → Sort u_1} → ((le : α → α → Prop) → motive { le := le }) → (t : LE α) → motive t | null | false |
MulRingNorm._sizeOf_1 | Mathlib.Analysis.Normed.Unbundled.RingSeminorm | {R : Type u_2} → {inst : NonAssocRing R} → [SizeOf R] → MulRingNorm R → ℕ | null | false |
Aesop.Index.mk.inj | Aesop.Index | ∀ {α : Type} {byTarget byHyp : Lean.Meta.DiscrTree (Aesop.Rule α)} {unindexed : Lean.PHashSet (Aesop.Rule α)}
{byTarget_1 byHyp_1 : Lean.Meta.DiscrTree (Aesop.Rule α)} {unindexed_1 : Lean.PHashSet (Aesop.Rule α)},
{ byTarget := byTarget, byHyp := byHyp, unindexed := unindexed } =
{ byTarget := byTarget_1, byH... | null | true |
Nat.digits_ne_nil_iff_ne_zero | Mathlib.Data.Nat.Digits.Defs | ∀ {b n : ℕ}, b.digits n ≠ [] ↔ n ≠ 0 | null | true |
MeasureTheory.innerRegularWRT_isCompact_isOpen | Mathlib.MeasureTheory.Measure.RegularityCompacts | ∀ {α : Type u_1} [inst : MeasurableSpace α] [inst_1 : TopologicalSpace α] [SecondCountableTopology α]
[TopologicalSpace.IsCompletelyPseudoMetrizableSpace α] [OpensMeasurableSpace α] (P : MeasureTheory.Measure α)
[MeasureTheory.IsFiniteMeasure P], P.InnerRegularWRT IsCompact IsOpen | null | true |
ContinuousLinearMap.opNorm_add_le | Mathlib.Analysis.Normed.Operator.Basic | ∀ {𝕜 : Type u_1} {𝕜₂ : Type u_2} {E : Type u_4} {F : Type u_5} [inst : SeminormedAddCommGroup E]
[inst_1 : SeminormedAddCommGroup F] [inst_2 : NontriviallyNormedField 𝕜] [inst_3 : NontriviallyNormedField 𝕜₂]
[inst_4 : NormedSpace 𝕜 E] [inst_5 : NormedSpace 𝕜₂ F] {σ₁₂ : 𝕜 →+* 𝕜₂} [RingHomIsometric σ₁₂] (f g ... | The operator norm satisfies the triangle inequality. | true |
SimpleGraph.ball_two | Mathlib.Combinatorics.SimpleGraph.Metric | ∀ {V : Type u_1} {G : SimpleGraph V} {c : V}, G.ball c 2 = insert c (G.neighborSet c) | The ball of radius two consists of the center and its neighbors. | true |
hasFPowerSeriesAt_log_one_add | Mathlib.Analysis.SpecialFunctions.Complex.Analytic | HasFPowerSeriesAt (fun x => Real.log (1 + x)) (FormalMultilinearSeries.ofScalars ℝ fun n => -(-1) ^ n / ↑n) 0 | null | true |
Finset.nsmul_right_monotone | Mathlib.Algebra.Group.Pointwise.Finset.Basic | ∀ {α : Type u_2} [inst : DecidableEq α] [inst_1 : AddMonoid α] {s : Finset α}, 0 ∈ s → Monotone fun x => x • s | null | true |
IsLocalMin.add | Mathlib.Topology.Order.LocalExtr | ∀ {α : Type u} {β : Type v} [inst : TopologicalSpace α] [inst_1 : AddCommMonoid β] [inst_2 : PartialOrder β]
[IsOrderedAddMonoid β] {f g : α → β} {a : α}, IsLocalMin f a → IsLocalMin g a → IsLocalMin (fun x => f x + g x) a | null | true |
PontryaginDual.instFiniteOfDiscreteTopologyOfCompactSpace | Mathlib.Topology.Algebra.PontryaginDual | ∀ {A : Type u_1} [inst : Monoid A] [inst_1 : TopologicalSpace A] [DiscreteTopology A] [CompactSpace A],
Finite (PontryaginDual A) | null | true |
Aesop.Script.TacticBuilder.simpAllOrSimpAtStarOnly | Aesop.Script.SpecificTactics | Bool → Lean.MVarId → Option Lean.Term → Lean.Meta.Simp.UsedSimps → Aesop.Script.TacticBuilder | null | true |
CompletelyDistribLattice.MinimalAxioms.ctorIdx | Mathlib.Order.CompleteBooleanAlgebra | {α : Type u} → CompletelyDistribLattice.MinimalAxioms α → ℕ | null | false |
LinearMap.detAux.congr_simp | Mathlib.LinearAlgebra.Determinant | ∀ {M : Type u_7} [inst : AddCommGroup M] {ι : Type u_8} {inst_1 : DecidableEq ι} [inst_2 : DecidableEq ι]
[inst_3 : Fintype ι] {A : Type u_9} [inst_4 : CommRing A] [inst_5 : Module A M] (a a_1 : Trunc (Module.Basis ι A M)),
a = a_1 → LinearMap.detAux a = LinearMap.detAux a_1 | null | true |
FirstOrder.Language.LHom.substructureReduct._proof_4 | Mathlib.ModelTheory.Substructures | ∀ {L : FirstOrder.Language} {M : Type u_1} [inst : L.Structure M] {L' : FirstOrder.Language} [inst_1 : L'.Structure M]
(φ : L →ᴸ L') [inst_2 : φ.IsExpansionOn M] (S T : L'.Substructure M),
(fun S => { carrier := ↑S, fun_mem := ⋯ }) S = (fun S => { carrier := ↑S, fun_mem := ⋯ }) T → S = T | null | false |
OrderHom.le_prevFixed_iff._simp_1 | Mathlib.Order.FixedPoints | ∀ {α : Type u} [inst : CompleteLattice α] (f : α →o α) {x : α} (hx : f x ≤ x) {y : ↑(Function.fixedPoints ⇑f)},
(y ≤ f.prevFixed x hx) = (↑y ≤ x) | null | false |
CategoryTheory.ComposableArrows.Exact.cokerToKer'._proof_1 | Mathlib.Algebra.Homology.ExactSequenceFour | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Preadditive C] {n : ℕ}
{S : CategoryTheory.ComposableArrows C (n + 3)}, S.Exact → S.IsComplex | null | false |
CategoryTheory.SmallObject.SuccStruct.Iteration.mkOfLimit.inductiveSystem._proof_2 | Mathlib.CategoryTheory.SmallObject.Iteration.Nonempty | ∀ {J : Type u_1} [inst : LinearOrder J] {j : J} {i₁ : ↑(Set.Iio j)}, ↑i₁ ≤ ↑i₁ | null | false |
cmp_sub_zero | Mathlib.Algebra.Order.Group.Unbundled.Basic | ∀ {α : Type u} [inst : AddGroup α] [inst_1 : LinearOrder α] [AddRightMono α] (a b : α), cmp (a - b) 0 = cmp a b | null | true |
USize.toUInt8_ofBitVec | Init.Data.UInt.Lemmas | ∀ (b : BitVec System.Platform.numBits), { toBitVec := b }.toUInt8 = { toBitVec := BitVec.setWidth 8 b } | null | true |
ProjectiveSpectrum.mem_vanishingIdeal | Mathlib.AlgebraicGeometry.ProjectiveSpectrum.Topology | ∀ {A : Type u_1} {σ : Type u_2} [inst : CommRing A] [inst_1 : SetLike σ A] [inst_2 : AddSubmonoidClass σ A] {𝒜 : ℕ → σ}
[inst_3 : GradedRing 𝒜] (t : Set (ProjectiveSpectrum 𝒜)) (f : A),
f ∈ ProjectiveSpectrum.vanishingIdeal t ↔ ∀ x ∈ t, f ∈ x.asHomogeneousIdeal | null | true |
CategoryTheory.Pseudofunctor.DescentData'._sizeOf_1 | Mathlib.CategoryTheory.Sites.Descent.DescentDataPrime | {C : Type u} →
{inst : CategoryTheory.Category.{v, u} C} →
{F : CategoryTheory.Pseudofunctor (CategoryTheory.LocallyDiscrete Cᵒᵖ) CategoryTheory.Cat} →
{ι : Type t} →
{S : C} →
{X : ι → C} →
{f : (i : ι) → X i ⟶ S} →
{sq : (i j : ι) → CategoryTheory.Limits.ChosenP... | null | false |
NormedAddGroupHom.opNorm_le_bound | Mathlib.Analysis.Normed.Group.Hom | ∀ {V₁ : Type u_2} {V₂ : Type u_3} [inst : SeminormedAddCommGroup V₁] [inst_1 : SeminormedAddCommGroup V₂]
(f : NormedAddGroupHom V₁ V₂) {M : ℝ}, 0 ≤ M → (∀ (x : V₁), ‖f x‖ ≤ M * ‖x‖) → ‖f‖ ≤ M | If one controls the norm of every `f x`, then one controls the norm of `f`. | true |
Module.ker_algebraMap_end | Mathlib.Algebra.Algebra.Basic | ∀ (K : Type u) (V : Type v) [inst : Semifield K] [inst_1 : AddCommMonoid V] [inst_2 : Module K V] (a : K),
a ≠ 0 → LinearMap.ker ((algebraMap K (Module.End K V)) a) = ⊥ | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.