name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
Localization.AtPrime.mapPiEvalRingHom_comp_algebraMap | Mathlib.RingTheory.Localization.AtPrime.Basic | ∀ {ι : Type u_4} {R : ι → Type u_5} [inst : (i : ι) → CommSemiring (R i)] {i : ι} (I : Ideal (R i))
[inst_1 : I.IsPrime],
(Localization.AtPrime.mapPiEvalRingHom I).comp
(algebraMap ((i : ι) → R i) (Localization.AtPrime (Ideal.comap (Pi.evalRingHom R i) I))) =
(algebraMap (R i) (Localization.AtPrime I)).co... | true |
notation_class | Mathlib.Tactic.Simps.NotationClass | Lean.ParserDescr | true |
FreeRing.coe_sub | Mathlib.RingTheory.FreeCommRing | ∀ {α : Type u} (x y : FreeRing α), ↑(x - y) = ↑x - ↑y | true |
_private.Lean.Meta.ExprDefEq.0.Lean.Meta.isEtaUnassignedMVar._sparseCasesOn_1 | Lean.Meta.ExprDefEq | {α : Type u} →
{motive : Option α → Sort u_1} →
(t : Option α) → ((val : α) → motive (some val)) → (Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t | false |
CategoryTheory.ShortComplex.homologyπ | Mathlib.Algebra.Homology.ShortComplex.Homology | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
[inst_1 : CategoryTheory.Limits.HasZeroMorphisms C] →
(S : CategoryTheory.ShortComplex C) → [inst_2 : S.HasHomology] → S.cycles ⟶ S.homology | true |
Topology.IsLowerSet.closure_eq_upperClosure | Mathlib.Topology.Order.UpperLowerSetTopology | ∀ {α : Type u_1} [inst : Preorder α] [inst_1 : TopologicalSpace α] [Topology.IsLowerSet α] {s : Set α},
closure s = ↑(upperClosure s) | true |
CategoryTheory.OplaxFunctor.PseudoCore | Mathlib.CategoryTheory.Bicategory.Functor.Oplax | {B : Type u₁} →
[inst : CategoryTheory.Bicategory B] →
{C : Type u₂} → [inst_1 : CategoryTheory.Bicategory C] → CategoryTheory.OplaxFunctor B C → Type (max (max u₁ v₁) w₂) | true |
Unitary.spectrum_subset_slitPlane_iff_norm_lt_two | Mathlib.Analysis.CStarAlgebra.Unitary.Connected | ∀ {A : Type u_1} [inst : CStarAlgebra A] {u : A}, u ∈ unitary A → (spectrum ℂ u ⊆ Complex.slitPlane ↔ ‖u - 1‖ < 2) | true |
Std.TreeSet.Raw.le_min! | Std.Data.TreeSet.Raw.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t : Std.TreeSet.Raw α cmp} [Std.TransCmp cmp] [inst : Inhabited α],
t.WF → t.isEmpty = false → ∀ {k : α}, (cmp k t.min!).isLE = true ↔ ∀ k' ∈ t, (cmp k k').isLE = true | true |
MeasureTheory.isMulLeftInvariant_map | Mathlib.MeasureTheory.Group.Measure | ∀ {G : Type u_1} [inst : MeasurableSpace G] [inst_1 : Mul G] {μ : MeasureTheory.Measure G} [MeasurableMul G]
{H : Type u_3} [inst_3 : MeasurableSpace H] [inst_4 : Mul H] [MeasurableMul H] [μ.IsMulLeftInvariant] (f : G →ₙ* H),
Measurable ⇑f → Function.Surjective ⇑f → (MeasureTheory.Measure.map (⇑f) μ).IsMulLeftInvar... | true |
CategoryTheory.Limits.binaryBiconeOfIsSplitEpiOfKernel._proof_7 | Mathlib.CategoryTheory.Preadditive.Biproducts | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {X Y : C} {f : X ⟶ Y}
[inst_1 : CategoryTheory.IsSplitEpi f],
CategoryTheory.CategoryStruct.comp (CategoryTheory.section_ f) f = CategoryTheory.CategoryStruct.id Y | false |
AlgebraicGeometry.IsAffineOpen.basicOpen_basicOpen_is_basicOpen | Mathlib.AlgebraicGeometry.AffineScheme | ∀ {X : AlgebraicGeometry.Scheme} {U : X.Opens},
AlgebraicGeometry.IsAffineOpen U →
∀ (f : ↑(X.presheaf.obj (Opposite.op U))) (g : ↑(X.presheaf.obj (Opposite.op (X.basicOpen f)))),
∃ f', X.basicOpen f' = X.basicOpen g | true |
DistribLattice.ofInfSupLe | Mathlib.Order.Lattice | {α : Type u} → [inst : Lattice α] → (∀ (a b c : α), a ⊓ (b ⊔ c) ≤ a ⊓ b ⊔ a ⊓ c) → DistribLattice α | true |
KaehlerDifferential.moduleBaseChange._proof_3 | Mathlib.RingTheory.Kaehler.TensorProduct | ∀ (R : Type u_3) (S : Type u_1) (A : Type u_2) [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S]
[inst_3 : CommRing A] [inst_4 : Algebra R A] (r s : A) (x : TensorProduct R S Ω[A⁄R]), (r + s) • x = r • x + s • x | false |
instContinuousAddWeakSpace | Mathlib.Topology.Algebra.Module.WeakDual | ∀ (𝕜 : Type u_2) (E : Type u_1) [inst : CommSemiring 𝕜] [inst_1 : TopologicalSpace 𝕜] [inst_2 : ContinuousAdd 𝕜]
[inst_3 : ContinuousConstSMul 𝕜 𝕜] [inst_4 : AddCommMonoid E] [inst_5 : Module 𝕜 E] [inst_6 : TopologicalSpace E],
ContinuousAdd (WeakSpace 𝕜 E) | true |
nndist_inv_inv₀ | Mathlib.Analysis.Normed.Field.Basic | ∀ {α : Type u_2} [inst : NormedDivisionRing α] {z w : α}, z ≠ 0 → w ≠ 0 → nndist z⁻¹ w⁻¹ = nndist z w / (‖z‖₊ * ‖w‖₊) | true |
Sum.isLeft_iff | Init.Data.Sum.Lemmas | ∀ {α : Type u_1} {β : Type u_2} {x : α ⊕ β}, x.isLeft = true ↔ ∃ y, x = Sum.inl y | true |
boolAlg_dual_comp_forget_to_bddDistLat | Mathlib.Order.Category.BoolAlg | BoolAlg.dual.comp (CategoryTheory.forget₂ BoolAlg BddDistLat) =
(CategoryTheory.forget₂ BoolAlg BddDistLat).comp BddDistLat.dual | true |
NumberField.InfinitePlace.mkReal._proof_1 | Mathlib.NumberTheory.NumberField.InfinitePlace.Basic | ∀ {K : Type u_1} [inst : Field K] (w : { w // w.IsReal }),
(fun φ => ⟨NumberField.InfinitePlace.mk ↑φ, ⋯⟩) ⟨(↑w).embedding, ⋯⟩ = w | false |
_private.Batteries.Data.List.Lemmas.0.List.findIdxNth_countPBefore_of_lt_length_of_pos._proof_1_5 | Batteries.Data.List.Lemmas | ∀ {α : Type u_1} (head : α) (tail : List α) {i : ℕ} {h : i < (head :: tail).length}, ¬i = 0 → i - 1 < tail.length | false |
NonUnitalAlgHomClass | Mathlib.Algebra.Algebra.NonUnitalHom | (F : Type u_1) →
(R : outParam (Type u_2)) →
(A : outParam (Type u_3)) →
(B : outParam (Type u_4)) →
[inst : Monoid R] →
[inst_1 : NonUnitalNonAssocSemiring A] →
[inst_2 : NonUnitalNonAssocSemiring B] →
[DistribMulAction R A] → [DistribMulAction R B] → [FunLike F ... | true |
instAssociativeUInt32HMul | Init.Data.UInt.Lemmas | Std.Associative fun x1 x2 => x1 * x2 | true |
_private.Init.Data.Range.Polymorphic.Internal.SignedBitVec.0.BitVec.Signed.sle_iff_rotate_le_rotate._proof_1_11 | Init.Data.Range.Polymorphic.Internal.SignedBitVec | ∀ (n : ℕ) (x y : BitVec (n + 1)), ¬(x.toNat ≤ y.toNat ↔ x.toNat + 2 ^ n ≤ y.toNat + 2 ^ n) → False | false |
Lean.Meta.Grind.MethodsRef | Lean.Meta.Tactic.Grind.Types | Type | true |
_private.Mathlib.Topology.EMetricSpace.Lipschitz.0.continuousOn_prod_of_subset_closure_continuousOn_lipschitzOnWith.match_1_3 | Mathlib.Topology.EMetricSpace.Lipschitz | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} [inst : PseudoEMetricSpace α] [inst_1 : PseudoEMetricSpace γ]
(f : α × β → γ) {s : Set α} {t : Set β} (x : α) (y : β) (ε : ENNReal) (δ : NNReal) (x' a : α) (b : β)
(motive : (a, b) ∈ (s ∩ Metric.eball x ↑δ) ×ˢ (t ∩ {b | edist (f (x', b)) (f (x', y)) ≤ ε / 2}) → Prop)
... | false |
_private.Mathlib.Combinatorics.Enumerative.Schroder.0.Nat.smallSchroder.match_1.eq_2 | Mathlib.Combinatorics.Enumerative.Schroder | ∀ (motive : ℕ → Sort u_1) (h_1 : Unit → motive 0) (h_2 : Unit → motive 1) (h_3 : (n : ℕ) → motive n.succ),
(match 1 with
| 0 => h_1 ()
| 1 => h_2 ()
| n.succ => h_3 n) =
h_2 () | true |
_private.Mathlib.Combinatorics.Graph.Subgraph.0.Graph.IsLink.anti_of_mem | Mathlib.Combinatorics.Graph.Subgraph | ∀ {α : Type u_1} {β : Type u_2} {x y : α} {e : β} {G H : Graph α β},
G.IsLink e x y → H ≤ G → e ∈ H.edgeSet → H.IsLink e x y | true |
isGδ_induced | Mathlib.Topology.GDelta.Basic | ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] {f : X → Y} {s : Set Y},
Continuous f → IsGδ s → IsGδ (f ⁻¹' s) | true |
_private.Mathlib.Analysis.BoxIntegral.Basic.0.BoxIntegral.integrable_of_bounded_and_ae_continuousWithinAt._simp_1_5 | Mathlib.Analysis.BoxIntegral.Basic | ∀ {α : Type u_1} {ι : Sort u_5} {s : ι → Set α} {t : Set α}, (⋃ i, s i ⊆ t) = ∀ (i : ι), s i ⊆ t | false |
add_dotProduct | Mathlib.Data.Matrix.Mul | ∀ {m : Type u_2} {α : Type v} [inst : Fintype m] [inst_1 : NonUnitalNonAssocSemiring α] (u v w : m → α),
(u + v) ⬝ᵥ w = u ⬝ᵥ w + v ⬝ᵥ w | true |
WittVector.eval | Mathlib.RingTheory.WittVector.Defs | {p : ℕ} →
{R : Type u_1} → [CommRing R] → {k : ℕ} → (ℕ → MvPolynomial (Fin k × ℕ) ℤ) → (Fin k → WittVector p R) → WittVector p R | true |
SSet.Subcomplex.PairingCore.RankFunction._sizeOf_1 | Mathlib.AlgebraicTopology.SimplicialSet.AnodyneExtensions.Rank | {X : SSet} →
{A : X.Subcomplex} → {h : A.PairingCore} → {α : Type v} → {inst : PartialOrder α} → [SizeOf α] → h.RankFunction α → ℕ | false |
Std.TreeMap.getEntryGT? | Std.Data.TreeMap.Basic | {α : Type u} → {β : Type v} → {cmp : α → α → Ordering} → Std.TreeMap α β cmp → α → Option (α × β) | true |
UniformSpace.Completion.ring._proof_11 | Mathlib.Topology.Algebra.UniformRing | ∀ {α : Type u_1} [inst : Ring α] [inst_1 : UniformSpace α] [IsTopologicalRing α] [inst_3 : IsUniformAddGroup α],
Continuous (HMul.hMul 0) | false |
CentroidHom.coe_sub._simp_1 | Mathlib.Algebra.Ring.CentroidHom | ∀ {α : Type u_5} [inst : NonUnitalNonAssocRing α] (f g : CentroidHom α), ⇑f - ⇑g = ⇑(f - g) | false |
_private.Init.Data.Array.BinSearch.0.Array.binInsertAux._unary._proof_2 | Init.Data.Array.BinSearch | ∀ {α : Type u_1} (as : Array α) (lo : Fin as.size), ↑lo < as.size | false |
_private.Mathlib.Data.NNReal.Defs.0.NNReal.iSup_eq_zero._simp_1_2 | Mathlib.Data.NNReal.Defs | ∀ {α : Type u} [inst : PartialOrder α] [inst_1 : OrderBot α] {a : α}, (a = ⊥) = (a ≤ ⊥) | false |
Semiring.toGrindSemiring._proof_15 | Mathlib.Algebra.Ring.GrindInstances | ∀ (α : Type u_1) [s : Semiring α] (a : α), a * 0 = 0 | false |
Filter.Tendsto.div_const | Mathlib.Topology.Algebra.GroupWithZero | ∀ {α : Type u_1} {G₀ : Type u_3} [inst : DivInvMonoid G₀] [inst_1 : TopologicalSpace G₀] [SeparatelyContinuousMul G₀]
{f : α → G₀} {l : Filter α} {x : G₀},
Filter.Tendsto f l (nhds x) → ∀ (y : G₀), Filter.Tendsto (fun a => f a / y) l (nhds (x / y)) | true |
_private.Lean.LibrarySuggestions.Basic.0.Lean.LibrarySuggestions.Selector.intersperse._proof_5 | Lean.LibrarySuggestions.Basic | ∀ (c : Lean.LibrarySuggestions.Config) (suggestions₁ suggestions₂ : Array Lean.LibrarySuggestions.Suggestion)
(r : MProd Float (MProd Float (MProd ℕ (MProd ℕ (Array Lean.LibrarySuggestions.Suggestion))))),
r.snd.snd.fst < suggestions₁.size ∧
r.snd.snd.snd.fst < suggestions₂.size ∧ r.snd.snd.snd.snd.size < c.m... | false |
Lean.Doc.Inline.concat.sizeOf_spec | Lean.DocString.Types | ∀ {i : Type u} [inst : SizeOf i] (content : Array (Lean.Doc.Inline i)),
sizeOf (Lean.Doc.Inline.concat content) = 1 + sizeOf content | true |
Function.surjective_iff_hasRightInverse | Mathlib.Logic.Function.Basic | ∀ {α : Sort u} {β : Sort v} {f : α → β}, Function.Surjective f ↔ Function.HasRightInverse f | true |
Mathlib.Tactic.AtomM.RecurseM | Mathlib.Util.AtomM.Recurse | Type → Type | true |
SemidirectProduct.mulEquivSubgroup_symm_apply | Mathlib.GroupTheory.SemidirectProduct | ∀ {G : Type u_2} [inst : Group G] {H K : Subgroup G} [inst_1 : H.Normal] (h : H.IsComplement' K) (b : G),
(SemidirectProduct.mulEquivSubgroup h).symm b = Function.surjInv ⋯ b | true |
_private.Mathlib.RingTheory.Ideal.KrullsHeightTheorem.0.Ideal.mem_minimalPrimes_span_of_mem_minimalPrimes_span_insert.match_1_2 | Mathlib.RingTheory.Ideal.KrullsHeightTheorem | ∀ {R : Type u_1} [inst : CommRing R] (x : R) (t : Set R) (f : R →+* R ⧸ Ideal.span t) (r : Ideal (R ⧸ Ideal.span t))
(motive : r.IsPrime ∧ Ideal.map f (Ideal.span {x}) ≤ r → Prop) (x_1 : r.IsPrime ∧ Ideal.map f (Ideal.span {x}) ≤ r),
(∀ (hr : r.IsPrime) (hxr : Ideal.map f (Ideal.span {x}) ≤ r), motive ⋯) → motive x... | false |
AlgebraicGeometry.Scheme.IdealSheafData.range_glueDataObjι_ι | Mathlib.AlgebraicGeometry.IdealSheaf.Subscheme | ∀ {X : AlgebraicGeometry.Scheme} (I : X.IdealSheafData) (U : ↑X.affineOpens),
Set.range ⇑(CategoryTheory.CategoryStruct.comp (I.glueDataObjι U) (↑U).ι) = X.zeroLocus ↑(I.ideal U) ∩ ↑↑U | true |
m_Birkhoff_inequalities | Mathlib.Algebra.Order.Group.Unbundled.Abs | ∀ {α : Type u_1} [inst : Lattice α] [inst_1 : CommGroup α] [MulLeftMono α] (a b c : α),
|(a ⊔ c) / (b ⊔ c)|ₘ ⊔ |(a ⊓ c) / (b ⊓ c)|ₘ ≤ |a / b|ₘ | true |
Inv.mk | Init.Prelude | {α : Type u} → (α → α) → Inv α | true |
AddSubgroup.relIindex_dvd_two_iff' | Mathlib.GroupTheory.Index | ∀ {G : Type u_1} [inst : AddGroup G] {H K : AddSubgroup G}, H.relIndex K ∣ 2 ↔ ∃ a ∈ K, ∀ b ∈ K, a + b ∈ H ∨ b ∈ H | true |
Int.fdiv.eq_5 | Init.Data.Int.DivMod.Basic | ∀ (m n : ℕ), (Int.negSucc m).fdiv (Int.ofNat n.succ) = Int.negSucc (m / n.succ) | true |
LinearIsometryEquiv.toSpanUnitSingleton._proof_4 | Mathlib.Analysis.Normed.Module.Span | ∀ {𝕜 : Type u_1} [inst : NormedDivisionRing 𝕜], IsDomain 𝕜 | false |
Geometry.SimplicialComplex.ofAffineIndependent._proof_2 | Mathlib.Analysis.Convex.SimplicialComplex.AffineIndependentUnion | ∀ {𝕜 : Type u_2} {E : Type u_1} [inst : Field 𝕜] [inst_1 : AddCommGroup E] [inst_2 : Module 𝕜 E]
(abstract : PreAbstractSimplicialComplex E),
AffineIndependent 𝕜 Subtype.val → ∀ {s : Finset E}, s ∈ abstract.faces → AffineIndependent 𝕜 fun x => ↑x | false |
String.Slice.instDecidableEqPos.decEq | Init.Data.String.Defs | {s : String.Slice} → (x x_1 : s.Pos) → Decidable (x = x_1) | true |
_private.Lean.Util.Diff.0.Lean.Diff.diff.match_1 | Lean.Util.Diff | {α : Type} →
(motive : MProd ℕ (Array (Lean.Diff.Action × α)) → Sort u_1) →
(r : MProd ℕ (Array (Lean.Diff.Action × α))) →
((j : ℕ) → (out : Array (Lean.Diff.Action × α)) → motive ⟨j, out⟩) → motive r | false |
tsum_geometric_of_lt_one | Mathlib.Analysis.SpecificLimits.Basic | ∀ {r : ℝ}, 0 ≤ r → r < 1 → ∑' (n : ℕ), r ^ n = (1 - r)⁻¹ | true |
IsSimpleRing.exists_algEquiv_matrix_of_isAlgClosed | Mathlib.RingTheory.SimpleModule.IsAlgClosed | ∀ (F : Type u_1) (R : Type u_2) [inst : Field F] [IsAlgClosed F] [inst_2 : Ring R] [inst_3 : Algebra F R]
[IsSimpleRing R] [FiniteDimensional F R], ∃ n, ∃ (_ : NeZero n), Nonempty (R ≃ₐ[F] Matrix (Fin n) (Fin n) F) | true |
ProbabilityTheory.condExp_prod_ae_eq_integral_condDistrib₀ | Mathlib.Probability.Kernel.CondDistrib | ∀ {α : Type u_1} {β : Type u_2} {Ω : Type u_3} {F : Type u_4} [inst : MeasurableSpace Ω] [inst_1 : StandardBorelSpace Ω]
[inst_2 : Nonempty Ω] [inst_3 : NormedAddCommGroup F] {mα : MeasurableSpace α} {μ : MeasureTheory.Measure α}
[inst_4 : MeasureTheory.IsFiniteMeasure μ] {X : α → β} {Y : α → Ω} {mβ : MeasurableSpa... | true |
_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... | 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 | true |
_private.Mathlib.Algebra.Module.ZLattice.Covolume.0._auto_28 | Mathlib.Algebra.Module.ZLattice.Covolume | Lean.Syntax | 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) | true |
Turing.ListBlank.modifyNth._unsafe_rec | Mathlib.Computability.TuringMachine.Tape | {Γ : Type u_1} → [inst : Inhabited Γ] → (Γ → Γ) → ℕ → Turing.ListBlank Γ → Turing.ListBlank Γ | 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) | 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) | false |
Multiset.sym2_mono | Mathlib.Data.Multiset.Sym | ∀ {α : Type u_1} {m m' : Multiset α}, m ≤ m' → m.sym2 ≤ m'.sym2 | true |
Real.Angle.toReal_le_pi | Mathlib.Analysis.SpecialFunctions.Trigonometric.Angle | ∀ (θ : Real.Angle), θ.toReal ≤ Real.pi | 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 | true |
Set.inter_self | Mathlib.Data.Set.Basic | ∀ {α : Type u} (a : Set α), a ∩ a = a | 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 | 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) | true |
instIsDirectedOrder | Mathlib.Algebra.Order.Archimedean.Basic | ∀ {R : Type u_3} [inst : Semiring R] [inst_1 : PartialOrder R] [IsOrderedRing R] [Archimedean R], IsDirectedOrder R | 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) | 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 ι] →... | true |
Mathlib.Meta.FunProp.Mor.isCoeFun | Mathlib.Tactic.FunProp.Mor | Lean.Expr → Lean.MetaM Bool | 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 | 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) | true |
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 | 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 ⋯ | true |
CentroidHom.centerToCentroid_apply | Mathlib.Algebra.Ring.CentroidHom | ∀ {α : Type u_5} [inst : NonUnitalNonAssocSemiring α] (z : ↥(NonUnitalSubsemiring.center α)) (a : α),
(CentroidHom.centerToCentroid z) a = ↑z * a | 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) | 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 | 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... | true |
LinearMap.submoduleComap_apply_coe | Mathlib.Algebra.Module.Submodule.Map | ∀ {R : Type u_1} {M : Type u_5} {M₁ : Type u_6} [inst : Semiring R] [inst_1 : AddCommMonoid M]
[inst_2 : AddCommMonoid M₁] [inst_3 : Module R M] [inst_4 : Module R M₁] (f : M →ₗ[R] M₁) (q : Submodule R M₁)
(c : ↥(Submodule.comap f q)), ↑((f.submoduleComap q) c) = f ↑c | true |
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) | true |
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 | true |
isSigmaCompact_iff_isSigmaCompact_univ | Mathlib.Topology.Compactness.SigmaCompact | ∀ {X : Type u_1} [inst : TopologicalSpace X] {s : Set X}, IsSigmaCompact s ↔ IsSigmaCompact Set.univ | 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 | 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 | true |
Lean.PrettyPrinter.Formatter.checkNoWsBefore.formatter | Lean.PrettyPrinter.Formatter | Lean.PrettyPrinter.Formatter | true |
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‖ | 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 | 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 | true |
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 | 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 | false |
_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 | false |
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... | 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 | 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 | 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 | true |
Array.instLE | Init.Data.Array.Basic | {α : Type u} → [LT α] → LE (Array α) | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.