name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11.5k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
CategoryTheory.MorphismProperty.MapFactorizationData.ofIsEquivalence | Mathlib.CategoryTheory.MorphismProperty.Factorization | {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] →
{W₁ W₂ : CategoryTheory.MorphismProperty C} →
{F : CategoryTheory.Functor D C} →
[F.IsEquivalence] →
[W₁.RespectsIso] →
... | The term in `MapFactorizationData (W₁.inverseImage F) (W₂.inverseImage F) f`
deduced from `h : MapFactorizationData W₁ W₂ (F.map f)` when `F` is an equivalence
of categories and both `W₁` and `W₂` respect isomorphisms. | true |
MvPFunctor.M.Path._sizeOf_inst | Mathlib.Data.PFunctor.Multivariate.M | {n : ℕ} → (P : MvPFunctor.{u} (n + 1)) → (a : P.last.M) → (a_1 : Fin2 n) → SizeOf (MvPFunctor.M.Path P a a_1) | null | false |
_private.Lean.PrettyPrinter.Delaborator.Builtins.0.Lean.PrettyPrinter.Delaborator.delabLit.match_1 | Lean.PrettyPrinter.Delaborator.Builtins | (motive : Lean.Literal → Sort u_1) →
(l : Lean.Literal) →
((n : ℕ) → motive (Lean.Literal.natVal n)) → ((s : String) → motive (Lean.Literal.strVal s)) → motive l | null | false |
MulHom.coeFn | Mathlib.Algebra.Group.Pi.Lemmas | (α : Type u_5) → (β : Type u_6) → [inst : Mul α] → [inst_1 : CommSemigroup β] → (α →ₙ* β) →ₙ* α → β | Coercion of a `MulHom` into a function is itself a `MulHom`.
See also `MulHom.eval`. | true |
Polynomial.Chebyshev.roots_U_real_nodup | Mathlib.Analysis.SpecialFunctions.Trigonometric.Chebyshev.RootsExtrema | ∀ (n : ℕ), (Multiset.map (fun k => Real.cos ((↑k + 1) * Real.pi / (↑n + 1))) (Multiset.range n)).Nodup | null | true |
TopCat.Sheaf.objSupIsoProdEqLocus_inv_fst | Mathlib.Topology.Sheaves.CommRingCat | ∀ {X : TopCat} (F : TopCat.Sheaf CommRingCat X) (U V : TopologicalSpace.Opens ↑X)
(x :
↑(CommRingCat.of
↥(((CommRingCat.Hom.hom (F.obj.map (CategoryTheory.homOfLE ⋯).op)).comp
(RingHom.fst ↑(F.obj.obj (Opposite.op U)) ↑(F.obj.obj (Opposite.op V)))).eqLocus
((CommRingCat.Hom.hom... | null | true |
IsPrimitiveRoot.subOneIntegralPowerBasis_gen | Mathlib.NumberTheory.NumberField.Cyclotomic.Basic | ∀ {n : ℕ} {K : Type u} [inst : Field K] {ζ : K} [inst_1 : NeZero n] [inst_2 : CharZero K]
[inst_3 : IsCyclotomicExtension {n} ℚ K] (hζ : IsPrimitiveRoot ζ n), hζ.subOneIntegralPowerBasis.gen = ⟨ζ - 1, ⋯⟩ | null | true |
Lean.Doc.Parser.bold | Lean.DocString.Parser | Lean.Doc.Parser.InlineCtxt → Lean.Parser.ParserFn | Parses bold: a matched pair of one or more `*`.
| true |
CategoryTheory.GrothendieckTopology.uliftYonedaIsoYoneda._proof_2 | Mathlib.CategoryTheory.Sites.Canonical | ∀ {C : Type u_3} [inst : CategoryTheory.Category.{max u_2 u_1, u_3} C] (J : CategoryTheory.GrothendieckTopology C)
[inst_1 : J.Subcanonical] {X Y : C} (f : X ⟶ Y),
CategoryTheory.CategoryStruct.comp ((CategoryTheory.GrothendieckTopology.uliftYoneda.{u_2, max u_1 u_2, u_3} J).map f)
((CategoryTheory.fullyFaith... | null | false |
ContinuousMap.toAEEqFunLinearMap._proof_3 | Mathlib.MeasureTheory.Function.AEEqFun | ∀ {α : Type u_1} {γ : Type u_2} [inst : MeasurableSpace α] (μ : MeasureTheory.Measure α) [inst_1 : TopologicalSpace α]
[BorelSpace α] {𝕜 : Type u_3} [inst_3 : Semiring 𝕜] [inst_4 : TopologicalSpace γ]
[TopologicalSpace.PseudoMetrizableSpace γ] [inst_6 : AddCommGroup γ] [inst_7 : Module 𝕜 γ] [ContinuousConstSMul ... | null | false |
Std.DHashMap.Internal.List.HashesTo.mk._flat_ctor | Std.Data.DHashMap.Internal.Defs | ∀ {α : Type u} {β : α → Type v} [inst : BEq α] [inst_1 : Hashable α] {l : List ((a : α) × β a)} {i size : ℕ},
(∀ (h : 0 < size), ∀ p ∈ l, (↑(Std.DHashMap.Internal.mkIdx size h (hash p.fst))).toNat = i) →
Std.DHashMap.Internal.List.HashesTo l i size | null | false |
Lean.Meta.Grind.ENode.proof?._default | Lean.Meta.Tactic.Grind.Types | Option Lean.Expr | null | false |
ProbabilityTheory.integrable_rpow_abs_mul_exp_add_of_integrable_exp_mul | Mathlib.Probability.Moments.IntegrableExpMul | ∀ {Ω : Type u_1} {m : MeasurableSpace Ω} {X : Ω → ℝ} {μ : MeasureTheory.Measure Ω} {t v x : ℝ},
MeasureTheory.Integrable (fun ω => Real.exp ((v + t) * X ω)) μ →
MeasureTheory.Integrable (fun ω => Real.exp ((v - t) * X ω)) μ →
0 ≤ x →
x < |t| → ∀ {p : ℝ}, 0 ≤ p → MeasureTheory.Integrable (fun a => |X... | If `exp ((v + t) * X)` and `exp ((v - t) * X)` are integrable
then for nonnegative `p : ℝ` and any `x ∈ [0, |t|)`,
`|X| ^ p * exp (v * X + x * |X|)` is integrable. | true |
Set.infinite_union._simp_1 | Mathlib.Data.Set.Finite.Basic | ∀ {α : Type u} {s t : Set α}, (s ∪ t).Infinite = (s.Infinite ∨ t.Infinite) | null | false |
Primcodable.ofDenumerable._proof_2 | Mathlib.Computability.Primrec.Basic | ∀ (α : Type u_1) [inst : Denumerable α], Nat.Primrec fun n => Encodable.encode (Encodable.decode n) | null | false |
Real.logb_lt_logb_iff_of_base_lt_one._simp_1 | Mathlib.Analysis.SpecialFunctions.Log.Base | ∀ {b x y : ℝ}, 0 < b → b < 1 → 0 < x → 0 < y → (Real.logb b x < Real.logb b y) = (y < x) | null | false |
Std.DHashMap.Internal.Raw₀.Const.size_le_size_insertMany | Std.Data.DHashMap.Internal.RawLemmas | ∀ {α : Type u} [inst : BEq α] [inst_1 : Hashable α] {β : Type v} (m : Std.DHashMap.Internal.Raw₀ α fun x => β)
{ρ : Type w} [inst_2 : ForIn Id ρ (α × β)] [EquivBEq α] [LawfulHashable α],
(↑m).WF → ∀ {l : ρ}, (↑m).size ≤ (↑↑(Std.DHashMap.Internal.Raw₀.Const.insertMany m l)).size | null | true |
GenContFract.IntFractPair.of_inv_fr_num_lt_num_of_pos | Mathlib.Algebra.ContinuedFractions.Computation.TerminatesIffRat | ∀ {q : ℚ}, 0 < q → (GenContFract.IntFractPair.of q⁻¹).fr.num < q.num | Shows that for any `q : ℚ` with `0 < q < 1`, the numerator of the fractional part of
`IntFractPair.of q⁻¹` is smaller than the numerator of `q`.
| true |
Batteries.Tactic.CollectOpaques.M | Batteries.Tactic.PrintOpaques | Type → Type | The monad used by `CollectOpaques`. | true |
ProfiniteGrp.ofFiniteGrp._proof_2 | Mathlib.Topology.Algebra.Category.ProfiniteGrp.Basic | ∀ (G : FiniteGrp.{u_1}), CompactSpace ↑G.toGrp | null | false |
_private.Lean.Meta.Tactic.Grind.Action.0.Lean.Meta.Grind.Action.loop.match_1.eq_1 | Lean.Meta.Tactic.Grind.Action | ∀ (motive : ℕ → Sort u_1) (h_1 : Unit → motive 0) (h_2 : (n : ℕ) → motive n.succ),
(match 0 with
| 0 => h_1 ()
| n.succ => h_2 n) =
h_1 () | null | true |
_private.Lean.Meta.SizeOf.0.Lean.Meta.initFn._@.Lean.Meta.SizeOf.3942519336._hygCtx._hyg.4 | Lean.Meta.SizeOf | IO (Lean.Option Bool) | null | false |
differentiable_pow | Mathlib.Analysis.Calculus.FDeriv.Pow | ∀ {𝕜 : Type u_1} {𝔸 : Type u_2} [inst : NontriviallyNormedField 𝕜] [inst_1 : NormedRing 𝔸] [inst_2 : NormedAlgebra 𝕜 𝔸]
(n : ℕ), Differentiable 𝕜 fun x => x ^ n | null | true |
_private.Mathlib.Topology.Algebra.Valued.WithVal.0.WithVal.valueGroupOrderIso₀_restrict._simp_1_1 | Mathlib.Topology.Algebra.Valued.WithVal | ∀ {R : Type u_1} {Γ₀ : Type u_2} [inst : LinearOrderedCommGroupWithZero Γ₀] [inst_1 : Ring R] (v : Valuation R Γ₀)
(x : WithVal v), v x.ofVal = (WithVal.valuation v) x | null | false |
CauchySeq.isBounded_range | Mathlib.Topology.MetricSpace.Bounded | ∀ {α : Type u} [inst : PseudoMetricSpace α] {f : ℕ → α}, CauchySeq f → Bornology.IsBounded (Set.range f) | null | true |
_private.Std.Sat.AIG.CNF.0.Std.Sat.AIG.toCNF.State | Std.Sat.AIG.CNF | Std.Sat.AIG ℕ → Type | The state to accumulate CNF clauses as we run our Tseitin transformation on the AIG.
| true |
Function.invFunOn_apply_mem._simp_1 | Mathlib.Data.Set.Function | ∀ {α : Type u_1} {β : Type u_2} {s : Set α} {f : α → β} {a : α} [inst : Nonempty α],
a ∈ s → (Function.invFunOn f s (f a) ∈ s) = True | null | false |
Std.Roo.size.eq_1 | Init.Data.Range.Polymorphic.Lemmas | ∀ {α : Type u} [inst : Std.Rxo.HasSize α] [inst_1 : Std.PRange.UpwardEnumerable α] (r : Std.Roo α),
r.size =
match Std.PRange.succ? r.lower with
| none => 0
| some lower => Std.Rxo.HasSize.size lower r.upper | null | true |
Std.HashMap.foldM_eq_foldlM_keys | Std.Data.HashMap.Lemmas | ∀ {α : Type u} {β : Type v} {x : BEq α} {x_1 : Hashable α} {m : Std.HashMap α β} {δ : Type w} {m' : Type w → Type w'}
[inst : Monad m'] [LawfulMonad m'] {f : δ → α → m' δ} {init : δ},
Std.HashMap.foldM (fun d a x => f d a) init m = List.foldlM f init m.keys | null | true |
_private.Init.Control.Lawful.Instances.0.StateT.seqLeft_eq._simp_1_1 | Init.Control.Lawful.Instances | ∀ {m : Type u → Type v} {inst : Monad m} [self : LawfulMonad m] {α β : Type u} (f : α → β) (x : m α),
f <$> x = do
let a ← x
pure (f a) | null | false |
CategoryTheory.ComposableArrows.sc'._proof_4 | Mathlib.Algebra.Homology.ExactSequence | ∀ {n : ℕ} (i j k : ℕ), j + 1 = k → k ≤ n → j ≤ n | null | false |
BitVec.intMin.eq_1 | Init.Data.BitVec.Lemmas | ∀ (w : ℕ), BitVec.intMin w = BitVec.twoPow w (w - 1) | null | true |
Ordinal.log_zero_left | Mathlib.SetTheory.Ordinal.Exponential | ∀ (x : Ordinal.{u_1}), Ordinal.log 0 x = 0 | null | true |
_private.Mathlib.Analysis.Analytic.IteratedFDeriv.0.HasFPowerSeriesOnBall.iteratedFDeriv_eq_sum_of_completeSpace._simp_1_2 | Mathlib.Analysis.Analytic.IteratedFDeriv | ∀ {𝕜 : Type u_1} {E : Type u_2} {F : Type u_3} [inst : NontriviallyNormedField 𝕜] [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {f : E → F}
{p : FormalMultilinearSeries 𝕜 E F} {x : E} {r : ENNReal},
HasFPowerSeriesOnBall f p x r = HasFPo... | null | false |
MonotoneOn.countable_setOf_two_preimages | Mathlib.Topology.Order.Monotone | ∀ {α : Type u_1} {β : Type u_2} [inst : LinearOrder α] [inst_1 : TopologicalSpace α] [OrderTopology α]
[inst_3 : LinearOrder β] {s : Set α} {f : α → β} [SecondCountableTopology α],
MonotoneOn f s → {c | ∃ x y, x ∈ s ∧ y ∈ s ∧ x < y ∧ f x = c ∧ f y = c}.Countable | If a function is monotone on a set in a second countable topological space, then there
are only countably many points that have several preimages. | true |
CategoryTheory.Functor.PullbackObjObj.ofIsTerminal_π | Mathlib.CategoryTheory.Limits.Shapes.Pullback.PullbackObjObj | ∀ {C₁ : Type u₁} {C₂ : Type u₂} {C₃ : Type u₃} [inst : CategoryTheory.Category.{v₁, u₁} C₁]
[inst_1 : CategoryTheory.Category.{v₂, u₂} C₂] [inst_2 : CategoryTheory.Category.{v₃, u₃} C₃]
(G : CategoryTheory.Functor C₁ᵒᵖ (CategoryTheory.Functor C₃ C₂)) {X₁ Y₁ : C₁} (f₁ : X₁ ⟶ Y₁) {X₃ Y₃ : C₃}
(f₃ : X₃ ⟶ Y₃)
[inst... | null | true |
MeasureTheory.ProbabilityMeasure.continuous_iff_forall_continuous_lintegral | Mathlib.MeasureTheory.Measure.ProbabilityMeasure | ∀ {Ω : Type u_1} [inst : MeasurableSpace Ω] [inst_1 : TopologicalSpace Ω] [inst_2 : OpensMeasurableSpace Ω]
{X : Type u_2} [inst_3 : TopologicalSpace X] {μs : X → MeasureTheory.ProbabilityMeasure Ω},
Continuous μs ↔ ∀ (f : BoundedContinuousFunction Ω NNReal), Continuous fun x => ∫⁻ (ω : Ω), ↑(f ω) ∂↑(μs x) | The characterization of weak convergence of probability measures by the condition that the
integrals of every continuous bounded nonnegative function are continuous. | true |
CategoryTheory.Bicategory.Prod.sectR._proof_2 | Mathlib.CategoryTheory.Bicategory.Product | ∀ {B : Type u_6} [inst : CategoryTheory.Bicategory B] (b : B) (C : Type u_2) [inst_1 : CategoryTheory.Bicategory C]
{a b_1 : C} (f : a ⟶ b_1),
CategoryTheory.Prod.mkHom (CategoryTheory.CategoryStruct.id (CategoryTheory.CategoryStruct.id b))
(CategoryTheory.CategoryStruct.id f) =
CategoryTheory.CategoryStr... | null | false |
_private.Init.Grind.ToIntLemmas.0.Lean.Grind.ToInt.isNonempty._proof_1_2 | Init.Grind.ToIntLemmas | ∀ {α : Type u_1} (a : α) (lo hi : ℤ) [inst : Lean.Grind.ToInt α (Lean.Grind.IntInterval.co lo hi)],
lo ≤ ↑a ∧ ↑a < hi → ¬lo < hi → False | null | false |
LinearMap.singularValues_antitone | Mathlib.Analysis.InnerProductSpace.SingularValues | ∀ {𝕜 : Type u_1} [inst : RCLike 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E] [inst_2 : InnerProductSpace 𝕜 E]
[inst_3 : FiniteDimensional 𝕜 E] {F : Type u_3} [inst_4 : NormedAddCommGroup F] [inst_5 : InnerProductSpace 𝕜 F]
[inst_6 : FiniteDimensional 𝕜 F] (T : E →ₗ[𝕜] F), Antitone ⇑T.singularValues | null | true |
Std.PRange.UpwardEnumerable.Map.lt_iff | Init.Data.Range.Polymorphic.Map | ∀ {α : Type u_1} {β : Type u_2} [inst : Std.PRange.UpwardEnumerable α] [inst_1 : Std.PRange.UpwardEnumerable β]
(f : Std.PRange.UpwardEnumerable.Map α β) {a b : α},
Std.PRange.UpwardEnumerable.LT a b ↔ Std.PRange.UpwardEnumerable.LT (f.toFun a) (f.toFun b) | null | true |
SupBotHom.instInhabited.eq_1 | Mathlib.Order.Hom.BoundedLattice | ∀ (α : Type u_2) [inst : Max α] [inst_1 : Bot α], SupBotHom.instInhabited α = { default := SupBotHom.id α } | null | true |
CategoryTheory.comp_toNatTrans | Mathlib.CategoryTheory.Monad.Basic | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {T₁ T₂ T₃ : CategoryTheory.Comonad C} (f : T₁ ⟶ T₂)
(g : T₂ ⟶ T₃),
(CategoryTheory.CategoryStruct.comp f g).toNatTrans = CategoryTheory.CategoryStruct.comp f.toNatTrans g.toNatTrans | null | true |
ProbabilityTheory.Kernel.fst | Mathlib.Probability.Kernel.Composition.MapComap | {α : Type u_1} →
{β : Type u_2} →
{γ : Type u_3} →
{mα : MeasurableSpace α} →
{mβ : MeasurableSpace β} →
{mγ : MeasurableSpace γ} → ProbabilityTheory.Kernel α (β × γ) → ProbabilityTheory.Kernel α β | Define a `Kernel α β` from a `Kernel α (β × γ)` by taking the map of the first projection.
We use `mapOfMeasurable` for better defeqs. | true |
_private.Batteries.Data.List.Lemmas.0.List.idxOfNth_cons_succ._proof_1_1 | Batteries.Data.List.Lemmas | ∀ {α : Type u_1} {xs : List α} {x : α} {n : ℕ} [inst : BEq α] {a : α},
List.idxOfNth x (a :: xs) (n + 1) =
if (a == x) = true then List.idxOfNth x xs n + 1 else List.idxOfNth x xs (n + 1) + 1 | null | false |
Nat.smoothNumbers_zero | Mathlib.NumberTheory.SmoothNumbers | Nat.smoothNumbers 0 = {1} | null | true |
Order.Frame.MinimalAxioms.inf_sSup_eq | Mathlib.Order.CompleteBooleanAlgebra | ∀ {α : Type u} (minAx : Order.Frame.MinimalAxioms α) {s : Set α} {a : α}, a ⊓ sSup s = ⨆ b ∈ s, a ⊓ b | null | true |
_private.Init.Data.SInt.Lemmas.0.Int64.ne_of_lt._simp_1_2 | Init.Data.SInt.Lemmas | ∀ {x y : Int64}, (x = y) = (x.toInt = y.toInt) | null | false |
_private.Std.Data.DHashMap.Internal.WF.0.Std.DHashMap.Internal.Raw₀.Const.alterₘ.match_1.eq_1 | Std.Data.DHashMap.Internal.WF | ∀ {β : Type u_1} (motive : Option β → Sort u_2) (h_1 : Unit → motive none) (h_2 : (b : β) → motive (some b)),
(match none with
| none => h_1 ()
| some b => h_2 b) =
h_1 () | null | true |
CategoryTheory.MorphismProperty.isColocal_iff | Mathlib.CategoryTheory.ObjectProperty.Local | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (W : CategoryTheory.MorphismProperty C) (X : C),
W.isColocal X ↔ ∀ ⦃Y Z : C⦄ (g : Y ⟶ Z), W g → Function.Bijective fun f => CategoryTheory.CategoryStruct.comp f g | null | true |
FirstOrder.Ring.compatibleRingOfRing._proof_4 | Mathlib.ModelTheory.Algebra.Ring.Basic | ∀ (R : Type u_1) [inst : Add R] [inst_1 : Mul R] [inst_2 : Neg R] [inst_3 : One R] [inst_4 : Zero R] (x : Fin 2 → R),
(match (motive := (n : ℕ) → FirstOrder.Language.ring.Functions n → (Fin n → R) → R) 2, FirstOrder.Ring.mulFunc with
| .(2), FirstOrder.ringFunc.add => fun x => x 0 + x 1
| .(2), FirstOrder... | null | false |
Complex.mul_angle_le_norm_sub | Mathlib.Analysis.Complex.Angle | ∀ {x y : ℂ}, ‖x‖ = 1 → ‖y‖ = 1 → 2 / Real.pi * InnerProductGeometry.angle x y ≤ ‖x - y‖ | Chord-length is always greater than a multiple of arc-length. | true |
iInf_iSup_eq | Mathlib.Order.CompleteBooleanAlgebra | ∀ {α : Type u} {ι : Sort w} {κ : ι → Sort w'} [inst : CompletelyDistribLattice α] {f : (a : ι) → κ a → α},
⨅ a, ⨆ b, f a b = ⨆ g, ⨅ a, f a (g a) | null | true |
Commute.units_val_iff | Mathlib.Algebra.Group.Commute.Units | ∀ {M : Type u_1} [inst : Monoid M] {u₁ u₂ : Mˣ}, Commute ↑u₁ ↑u₂ ↔ Commute u₁ u₂ | null | true |
CategoryTheory.Abelian.AbelianStruct.imageι_π._autoParam | Mathlib.CategoryTheory.Abelian.Basic | Lean.Syntax | null | false |
CategoryTheory.ObjectProperty.shift | Mathlib.CategoryTheory.ObjectProperty.Shift | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
CategoryTheory.ObjectProperty C →
{A : Type u_2} → [inst_1 : AddMonoid A] → [CategoryTheory.HasShift C A] → A → CategoryTheory.ObjectProperty C | Given a predicate `P : C → Prop` on objects of a category equipped with a shift by `A`,
this is the predicate which is satisfied by `X` if `P (X⟦a⟧)`. | true |
SemiRingCat.HasLimits.limitConeIsLimit._simp_1 | Mathlib.Algebra.Category.Ring.Limits | ∀ {α : Type u_2} [inst : Small.{v, u_2} α] [inst_1 : Mul α] (x y : α),
(equivShrink α) x * (equivShrink α) y = (equivShrink α) (x * y) | null | false |
Lean.Linter.MissingDocs.checkMixfix | Lean.Linter.MissingDocs | Lean.Linter.MissingDocs.SimpleHandler | null | true |
Set.add_subset_add_left | Mathlib.Algebra.Group.Pointwise.Set.Basic | ∀ {α : Type u_2} [inst : Add α] {s t₁ t₂ : Set α}, t₁ ⊆ t₂ → s + t₁ ⊆ s + t₂ | null | true |
Lean.Meta.Grind.State.instanceMap._default | Lean.Meta.Tactic.Grind.Types | Std.HashMap Lean.Name Lean.Meta.Grind.EMatchTheorem | null | false |
Std.DHashMap.Internal.Raw₀.size_eq_of_equiv | Std.Data.DHashMap.Internal.RawLemmas | ∀ {α : Type u} {β : α → Type v} [inst : BEq α] [inst_1 : Hashable α] (m₁ m₂ : Std.DHashMap.Internal.Raw₀ α β)
[EquivBEq α] [LawfulHashable α], (↑m₁).WF → (↑m₂).WF → (↑m₁).Equiv ↑m₂ → (↑m₁).size = (↑m₂).size | null | true |
Metric.isBounded_image_iff | Mathlib.Topology.MetricSpace.Bounded | ∀ {α : Type u} {β : Type v} [inst : PseudoMetricSpace α] {f : β → α} {s : Set β},
Bornology.IsBounded (f '' s) ↔ ∃ C, ∀ x ∈ s, ∀ y ∈ s, dist (f x) (f y) ≤ C | null | true |
AdjoinRoot.powerBasisAux'._proof_3 | Mathlib.RingTheory.AdjoinRoot | ∀ {R : Type u_1} [inst : CommRing R] {g : Polynomial R} (hg : g.Monic) (f₁ : R) (f₂ : AdjoinRoot g)
(i : Fin g.natDegree),
((AdjoinRoot.modByMonicHom hg) (f₁ • f₂)).coeff ↑i =
((RingHom.id R) f₁ • fun i => ((AdjoinRoot.modByMonicHom hg) f₂).coeff ↑i) i | null | false |
AlgebraicGeometry.instCanonicallyOverSpecStalkCommRingCatPresheaf | Mathlib.AlgebraicGeometry.Stalk | (X : AlgebraicGeometry.Scheme) → (x : ↥X) → (AlgebraicGeometry.Spec (X.presheaf.stalk x)).CanonicallyOver X | null | true |
String.Slice.Pos.not_endPos_lt._simp_1 | Init.Data.String.Lemmas.Order | ∀ {s : String.Slice} {p : s.Pos}, (s.endPos < p) = False | null | false |
CategoryTheory.Functor.Elements.isInitialElementsMkShrinkYonedaObjObjEquivId._proof_1 | Mathlib.CategoryTheory.Limits.Presheaf | ∀ {C : Type u_3} [inst : CategoryTheory.Category.{u_2, u_3} C] [inst_1 : CategoryTheory.LocallySmall.{u_1, u_2, u_3} C]
(X : C) (u : (CategoryTheory.shrinkYoneda.{u_1, u_2, u_3}.flip.obj (Opposite.op X)).Elements),
(CategoryTheory.ConcreteCategory.hom
((CategoryTheory.shrinkYoneda.{u_1, u_2, u_3}.flip.obj (... | null | false |
Subfield.comap_top | Mathlib.Algebra.Field.Subfield.Basic | ∀ {K : Type u} {L : Type v} [inst : DivisionRing K] [inst_1 : DivisionRing L] (f : K →+* L), Subfield.comap f ⊤ = ⊤ | null | true |
Equiv.Perm.prod_list_swap_mem_alternatingGroup_iff_even_length | Mathlib.GroupTheory.SpecificGroups.Alternating | ∀ {α : Type u_1} [inst : Fintype α] [inst_1 : DecidableEq α] {l : List (Equiv.Perm α)},
(∀ g ∈ l, g.IsSwap) → (l.prod ∈ alternatingGroup α ↔ Even l.length) | null | true |
Mathlib.Tactic.Order.orderCoreImp | Mathlib.Tactic.Order | Bool → Array Lean.Expr → Lean.Expr → Lean.MVarId → Mathlib.Tactic.AtomM Unit | Implementation of `orderCore` in `AtomM`. | true |
_private.Mathlib.Combinatorics.SimpleGraph.Ends.Properties.0.SimpleGraph.instIsEmptyElemForallObjOppositeFinsetComponentComplFunctorEndOfFinite._simp_1 | Mathlib.Combinatorics.SimpleGraph.Ends.Properties | ∀ {α : Type u} (x : α), (x ∈ Set.univ) = True | null | false |
«_aux_Mathlib_Topology_Algebra_InfiniteSum_Defs___macroRules_term∑'[_]_,__1» | Mathlib.Topology.Algebra.InfiniteSum.Defs | Lean.Macro | null | false |
Lean.instFromJsonLeanOptionValue.match_1 | Lean.Util.LeanOptions | (motive : Lean.Json → Sort u_1) →
(x : Lean.Json) →
((s : String) → motive (Lean.Json.str s)) →
((b : Bool) → motive (Lean.Json.bool b)) →
((n : ℕ) → motive (Lean.Json.num { mantissa := Int.ofNat n, exponent := 0 })) →
((x : Lean.Json) → motive x) → motive x | null | false |
CategoryTheory.MonoidalCategory.DayConvolution.braidingInvCorepresenting._proof_1 | Mathlib.CategoryTheory.Monoidal.DayConvolution.Braided | ∀ {C : Type u_4} [inst : CategoryTheory.Category.{u_3, u_4} C] {V : Type u_2}
[inst_1 : CategoryTheory.Category.{u_1, u_2} V] [inst_2 : CategoryTheory.MonoidalCategory C]
[inst_3 : CategoryTheory.BraidedCategory C] [inst_4 : CategoryTheory.MonoidalCategory V]
[inst_5 : CategoryTheory.BraidedCategory V] (F G : Cat... | null | false |
Std.ExtHashMap.getKey?_alter | Std.Data.ExtHashMap.Lemmas | ∀ {α : Type u} {β : Type v} {x : BEq α} {x_1 : Hashable α} {m : Std.ExtHashMap α β} [inst : EquivBEq α]
[inst_1 : LawfulHashable α] {k k' : α} {f : Option β → Option β},
(m.alter k f).getKey? k' = if (k == k') = true then if (f m[k]?).isSome = true then some k else none else m.getKey? k' | null | true |
SSet.OneTruncation₂.ofNerve₂ | Mathlib.AlgebraicTopology.SimplicialSet.HomotopyCat | (C : Type u) →
[inst : CategoryTheory.Category.{u, u} C] →
CategoryTheory.ReflQuiv.of (SSet.OneTruncation₂ ((SSet.truncation 2).obj (CategoryTheory.nerve C))) ≅
CategoryTheory.ReflQuiv.of C | The refl quiver underlying a nerve is isomorphic to the refl quiver underlying the category. | true |
Set.pairwise_univ | Mathlib.Data.Set.Pairwise.Basic | ∀ {α : Type u_1} {r : α → α → Prop}, Set.univ.Pairwise r ↔ Pairwise r | null | true |
MultilinearMap.instZero._proof_1 | Mathlib.LinearAlgebra.Multilinear.Basic | ∀ {M₂ : Type u_1} [inst : AddCommMonoid M₂], 0 = 0 + 0 | null | false |
NNReal.tendsto_coe' | Mathlib.Topology.Instances.NNReal.Lemmas | ∀ {α : Type u_2} {f : Filter α} [f.NeBot] {m : α → NNReal} {x : ℝ},
Filter.Tendsto (fun a => ↑(m a)) f (nhds x) ↔ ∃ (hx : 0 ≤ x), Filter.Tendsto m f (nhds ⟨x, hx⟩) | null | true |
CategoryTheory.MorphismProperty.IsLocalAtSource.mk._flat_ctor | Mathlib.CategoryTheory.MorphismProperty.Local | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {P : CategoryTheory.MorphismProperty C}
{K : CategoryTheory.Precoverage C},
(∀ {X Y Z : C} (i : X ⟶ Y),
CategoryTheory.MorphismProperty.isomorphisms C i →
∀ (f : Y ⟶ Z), P f → P (CategoryTheory.CategoryStruct.comp i f)) →
(∀ {X Y Z : C} (i :... | null | false |
StarSubalgebra.mem_top | Mathlib.Algebra.Star.Subalgebra | ∀ {R : Type u_2} {A : Type u_3} [inst : CommSemiring R] [inst_1 : StarRing R] [inst_2 : Semiring A]
[inst_3 : Algebra R A] [inst_4 : StarRing A] [inst_5 : StarModule R A] {x : A}, x ∈ ⊤ | null | true |
Std.ExtTreeMap.instDecidableEqOfLawfulEqCmpOfTransCmpOfLawfulBEq | Std.Data.ExtTreeMap.Basic | {α : Type u} →
{β : Type v} →
{cmp : α → α → Ordering} →
[Std.LawfulEqCmp cmp] → [Std.TransCmp cmp] → [inst : BEq β] → [LawfulBEq β] → DecidableEq (Std.ExtTreeMap α β cmp) | null | true |
neg_iff_pos_of_mul_neg | Mathlib.Algebra.Order.Ring.Unbundled.Basic | ∀ {R : Type u} [inst : Semiring R] [inst_1 : LinearOrder R] {a b : R} [ExistsAddOfLE R] [PosMulMono R] [MulPosMono R]
[AddRightMono R] [AddRightReflectLE R], a * b < 0 → (a < 0 ↔ 0 < b) | null | true |
FirstOrder.Language.Substructure.instInhabited_fg | Mathlib.ModelTheory.FinitelyGenerated | {L : FirstOrder.Language} → {M : Type u_1} → [inst : L.Structure M] → Inhabited { S // S.FG } | null | true |
LatticeCon.mk | Mathlib.Order.Lattice.Congruence | {α : Type u_2} →
[inst : Lattice α] →
(toSetoid : Setoid α) →
(∀ {w x y z : α}, toSetoid w x → toSetoid y z → toSetoid (w ⊓ y) (x ⊓ z)) →
(∀ {w x y z : α}, toSetoid w x → toSetoid y z → toSetoid (w ⊔ y) (x ⊔ z)) → LatticeCon α | null | true |
Std.Do.PredTrans.instLE | Std.Do.PredTrans | {ps : Std.Do.PostShape} → {α : Type u} → LE (Std.Do.PredTrans ps α) | null | true |
Nat.gcd_sub_self_right | Init.Data.Nat.Gcd | ∀ {m n : ℕ}, m ≤ n → m.gcd (n - m) = m.gcd n | null | true |
_private.Std.Async.Basic.0.Std.Async.MaybeTask.toTask.match_1 | Std.Async.Basic | {α : Type} →
(motive : Std.Async.MaybeTask α → Sort u_1) →
(x : Std.Async.MaybeTask α) →
((a : α) → motive (Std.Async.MaybeTask.pure a)) →
((t : Task α) → motive (Std.Async.MaybeTask.ofTask t)) → motive x | null | false |
MeasureTheory.SimpleFunc.ctorIdx | Mathlib.MeasureTheory.Function.SimpleFunc | {α : Type u} → {inst : MeasurableSpace α} → {β : Type v} → MeasureTheory.SimpleFunc α β → ℕ | null | false |
Lean.Meta.Simp.NormCastConfig.singlePass._inherited_default | Init.MetaTypes | Bool | null | false |
LinearMap.mk₂' | Mathlib.LinearAlgebra.BilinearMap | (R : Type u_1) →
(S : Type u_3) →
[inst : Semiring R] →
[inst_1 : Semiring S] →
{M : Type u_5} →
{N : Type u_7} →
{Pₗ : Type u_11} →
[inst_2 : AddCommMonoid M] →
[inst_3 : AddCommMonoid N] →
[inst_4 : AddCommMonoid Pₗ] →
... | Create a bilinear map from a function that is linear in each component.
See `mk₂` for the special case where both arguments come from modules over the same ring. | true |
WeierstrassCurve.Jacobian.Y_eq_of_Y_ne | Mathlib.AlgebraicGeometry.EllipticCurve.Jacobian.Formula | ∀ {R : Type r} [inst : CommRing R] {W' : WeierstrassCurve.Jacobian R} [NoZeroDivisors R] {P Q : Fin 3 → R},
W'.Equation P →
W'.Equation Q → P 0 * Q 2 ^ 2 = Q 0 * P 2 ^ 2 → P 1 * Q 2 ^ 3 ≠ Q 1 * P 2 ^ 3 → P 1 * Q 2 ^ 3 = W'.negY Q * P 2 ^ 3 | null | true |
NonUnitalAlgebra.range_id | Mathlib.Algebra.Algebra.NonUnitalSubalgebra | ∀ {R : Type u} {A : Type v} [inst : CommSemiring R] [inst_1 : NonUnitalNonAssocSemiring A] [inst_2 : Module R A]
[inst_3 : IsScalarTower R A A] [inst_4 : SMulCommClass R A A], NonUnitalAlgHom.range (NonUnitalAlgHom.id R A) = ⊤ | null | true |
Filter.Tendsto.finCons | Mathlib.Topology.Constructions | ∀ {Y : Type v} {n : ℕ} {A : Fin (n + 1) → Type u_9} [inst : (i : Fin (n + 1)) → TopologicalSpace (A i)] {f : Y → A 0}
{g : Y → (j : Fin n) → A j.succ} {l : Filter Y} {x : A 0} {y : (j : Fin n) → A j.succ},
Filter.Tendsto f l (nhds x) →
Filter.Tendsto g l (nhds y) → Filter.Tendsto (fun a => Fin.cons (f a) (g a))... | null | true |
Bundle.Pretrivialization.domExtend._proof_5 | Mathlib.Topology.FiberBundle.Trivialization | ∀ {B : Type u_1} {F : Type u_2} {Z : Type u_3} [inst : TopologicalSpace B] [inst_1 : TopologicalSpace F] {proj : Z → B}
{s : Set B} (e : Bundle.Pretrivialization F fun z => proj ↑z), e.target = e.baseSet ×ˢ Set.univ | null | false |
WithTop.untop.congr_simp | Mathlib.Order.WithBot | ∀ {α : Type u_1} (x x_1 : WithTop α) (e_x : x = x_1) (a : x ≠ ⊤), x.untop a = x_1.untop ⋯ | null | true |
CategoryTheory.ObjectProperty.instIsClosedUnderSubobjectsInverseImageOfPreservesMonomorphisms | Mathlib.CategoryTheory.ObjectProperty.EpiMono | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {D : Type u'} [inst_1 : CategoryTheory.Category.{v', u'} D]
(P : CategoryTheory.ObjectProperty C) [P.IsClosedUnderSubobjects] (F : CategoryTheory.Functor D C)
[F.PreservesMonomorphisms], (P.inverseImage F).IsClosedUnderSubobjects | null | true |
CategoryTheory.ComonadicLeftAdjoint.R | Mathlib.CategoryTheory.Monad.Adjunction | {C : Type u₁} →
{inst : CategoryTheory.Category.{v₁, u₁} C} →
{D : Type u₂} →
{inst_1 : CategoryTheory.Category.{v₂, u₂} D} →
(L : CategoryTheory.Functor C D) → [self : CategoryTheory.ComonadicLeftAdjoint L] → CategoryTheory.Functor D C | a choice of right adjoint for `L` | true |
RootPairing.rootForm_symmetric | Mathlib.LinearAlgebra.RootSystem.Finite.CanonicalBilinear | ∀ {ι : Type u_1} {R : Type u_2} {M : Type u_3} {N : Type u_4} [inst : CommRing R] [inst_1 : AddCommGroup M]
[inst_2 : Module R M] [inst_3 : AddCommGroup N] [inst_4 : Module R N] (P : RootPairing ι R M N) [inst_5 : Fintype ι],
LinearMap.IsSymm P.RootForm | null | true |
Mathlib.Tactic.Ring.Common.ExProdNat.mul.inj | Mathlib.Tactic.Ring.Common | ∀ {x e b : Q(ℕ)} {a : Mathlib.Tactic.Ring.Common.ExBaseNat x} {a_1 : Mathlib.Tactic.Ring.Common.ExProdNat e}
{a_2 : Mathlib.Tactic.Ring.Common.ExProdNat b} {a_3 : Mathlib.Tactic.Ring.Common.ExBaseNat x}
{a_4 : Mathlib.Tactic.Ring.Common.ExProdNat e} {a_5 : Mathlib.Tactic.Ring.Common.ExProdNat b},
Mathlib.Tactic.R... | null | true |
_private.Mathlib.LinearAlgebra.RootSystem.GeckConstruction.Relations.0.RootPairing.GeckConstruction.lie_h_e._simp_1_6 | Mathlib.LinearAlgebra.RootSystem.GeckConstruction.Relations | ∀ {M : Type u_4} [inst : AddMonoid M] [IsRightCancelAdd M] {a b : M}, (b = a + b) = (a = 0) | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.