name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
FractionalIdeal.num_zero_eq | Mathlib.RingTheory.FractionalIdeal.Basic | ∀ {R : Type u_1} [inst : CommRing R] {S : Submonoid R} {P : Type u_2} [inst_1 : CommRing P] [inst_2 : Algebra R P],
Function.Injective ⇑(algebraMap R P) → FractionalIdeal.num 0 = 0 | null | true |
PolynomialModule.ofCoeff.inj | Mathlib.Algebra.Polynomial.Module.Basic | ∀ {R : Type u_1} {M : Type u_2} {inst : CommRing R} {inst_1 : AddCommGroup M} {inst_2 : Module R M}
{coeff coeff_1 : ℕ →₀ M}, { coeff := coeff } = { coeff := coeff_1 } → coeff = coeff_1 | null | true |
smoothingFun_nonneg | Mathlib.Analysis.Normed.Unbundled.SmoothingSeminorm | ∀ {R : Type u_1} [inst : CommRing R] (μ : RingSeminorm R), μ 1 ≤ 1 → ∀ (x : R), 0 ≤ smoothingFun μ x | If `μ 1 ≤ 1`, then `smoothingFun μ x` is nonnegative. | true |
RingEquiv.sumArrowEquivProdArrow_apply | Mathlib.Algebra.Ring.Equiv | ∀ {α : Type u_2} {β : Type u_3} {R : Type u_4} [inst : NonAssocSemiring R] (x : α ⊕ β → R),
(RingEquiv.sumArrowEquivProdArrow α β R) x = (Equiv.sumArrowEquivProdArrow α β R) x | null | true |
AlgEquiv.prodUnique._proof_1 | Mathlib.Algebra.Algebra.Prod | ∀ {A : Type u_1} {B : Type u_2} [inst : Semiring A] [inst_1 : Semiring B] [inst_2 : Unique B],
Function.LeftInverse (RingEquiv.prodZeroRing A B).symm.invFun (RingEquiv.prodZeroRing A B).symm.toFun | null | false |
Mathlib.Tactic.TautoSet.specialize_all | Mathlib.Tactic.TautoSet | Lean.ParserDescr | `specialize_all x` runs `specialize h x` for all hypotheses `h` where this tactic succeeds.
| true |
CategoryTheory.Functor.LaxLeftLinear.mk._flat_ctor | Mathlib.CategoryTheory.Monoidal.Action.LinearFunctor | {D : Type u_1} →
{D' : Type u_2} →
[inst : CategoryTheory.Category.{v_1, u_1} D] →
[inst_1 : CategoryTheory.Category.{v_2, u_2} D'] →
{F : CategoryTheory.Functor D D'} →
{C : Type u_3} →
[inst_2 : CategoryTheory.Category.{v_3, u_3} C] →
[inst_3 : CategoryTheory.Mo... | null | false |
instCoeTCMulEquivOfMulEquivClass.eq_1 | Mathlib.Algebra.Group.Equiv.Defs | ∀ {F : Type u_1} {α : Type u_2} {β : Type u_3} [inst : EquivLike F α β] [inst_1 : Mul α] [inst_2 : Mul β]
[inst_3 : MulEquivClass F α β], instCoeTCMulEquivOfMulEquivClass = { coe := MulEquivClass.toMulEquiv } | null | true |
Std.Time.Day.Ordinal.ofNat._auto_1 | Std.Time.Date.Unit.Day | Lean.Syntax | null | false |
_private.Mathlib.NumberTheory.ModularForms.LevelOne.DimensionFormula.0.ModularForm.levelOne_weight_two_rank_zero._simp_1_2 | Mathlib.NumberTheory.ModularForms.LevelOne.DimensionFormula | ∀ {Γ : Subgroup (GL (Fin 2) ℝ)} {h : ℝ},
0 < h → h ∈ Γ.strictPeriods → ∀ {k : ℤ} (f : ModularForm Γ k), (UpperHalfPlane.qExpansion h ⇑f = 0) = (f = 0) | null | false |
CategoryTheory.Cat.Hom.isoMk_inv | Mathlib.CategoryTheory.Category.Cat | ∀ {C D : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Category.{v, u} D]
{F G : CategoryTheory.Functor C D} (e : F ≅ G),
(CategoryTheory.Cat.Hom.isoMk e).inv = CategoryTheory.NatTrans.toCatHom₂ e.inv | null | true |
CommRingCat.forget₂Ring_preservesLimits | Mathlib.Algebra.Category.Ring.Limits | CategoryTheory.Limits.PreservesLimits (CategoryTheory.forget₂ CommRingCat RingCat) | null | true |
eq_zero_of_neg_eq | Mathlib.Algebra.Order.Group.Defs | ∀ {α : Type u} [inst : AddCommGroup α] [inst_1 : LinearOrder α] [IsOrderedAddMonoid α] {a : α}, -a = a → a = 0 | null | true |
Chebyshev.theta_eq_zero_of_le_one | Mathlib.NumberTheory.Chebyshev | ∀ {x : ℝ}, x ≤ 1 → Chebyshev.theta x = 0 | null | true |
Besicovitch.exists_goodδ | Mathlib.MeasureTheory.Covering.BesicovitchVectorSpace | ∀ (E : Type u_1) [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] [FiniteDimensional ℝ E],
∃ δ,
0 < δ ∧
δ < 1 ∧
∀ (s : Finset E),
(∀ c ∈ s, ‖c‖ ≤ 2) → (∀ c ∈ s, ∀ d ∈ s, c ≠ d → 1 - δ ≤ ‖c - d‖) → s.card ≤ Besicovitch.multiplicity E | If `δ` is small enough, a `(1-δ)`-separated set in the ball of radius `2` also has cardinality
at most `multiplicity E`. | true |
CompleteOrthogonalIdempotents.ringEquivOfIsMulCentral._proof_2 | Mathlib.RingTheory.Idempotents | ∀ {R : Type u_1} {I : Type u_2} [inst : Fintype I] {e : I → R} [inst_1 : Semiring R]
(he : CompleteOrthogonalIdempotents e),
(∀ (i : I), IsMulCentral (e i)) →
∀ (r : R), (fun r => ∑ i, ↑(r i)) ((fun r i => ⟨(fun x => e i * x * e i) r, ⋯⟩) r) = r | null | false |
_private.Mathlib.Tactic.DepRewrite.0.Lean.MVarId.depRewrite.match_3 | Mathlib.Tactic.DepRewrite | (motive : Lean.Expr → Sort u_1) →
(eAbst : Lean.Expr) →
((binderName : Lean.Name) →
(binderType : Lean.Expr) →
(binderName_1 : Lean.Name) →
(binderType_1 eBody : Lean.Expr) →
(binderInfo binderInfo_1 : Lean.BinderInfo) →
motive
(Lean.Ex... | null | false |
_private.Batteries.Recycling.RBTree.Lemmas.0.RBTree.RBNode.del.match_1.eq_1 | Batteries.Recycling.RBTree.Lemmas | ∀ (motive : RBTree.RBColor → Sort u_1) (h_1 : Unit → motive RBTree.RBColor.black)
(h_2 : Unit → motive RBTree.RBColor.red),
(match RBTree.RBColor.black with
| RBTree.RBColor.black => h_1 ()
| RBTree.RBColor.red => h_2 ()) =
h_1 () | null | true |
RingCon.ringConGen_eq | Mathlib.RingTheory.Congruence.Basic | ∀ {R : Type u_3} [inst : Add R] [inst_1 : Mul R] (r : R → R → Prop),
ringConGen r = sInf {s | ∀ (x y : R), r x y → s x y} | The inductively defined smallest congruence relation containing a binary relation `r` equals
the infimum of the set of congruence relations containing `r`. | true |
AddGroupSeminorm.map_zero' | Mathlib.Analysis.Normed.Group.Seminorm | ∀ {G : Type u_6} [inst : AddGroup G] (self : AddGroupSeminorm G), self.toFun 0 = 0 | The image of zero is zero. | true |
CompleteLatticeHom._sizeOf_1 | Mathlib.Order.Hom.CompleteLattice | {α : Type u_8} →
{β : Type u_9} →
{inst : CompleteLattice α} → {inst_1 : CompleteLattice β} → [SizeOf α] → [SizeOf β] → CompleteLatticeHom α β → ℕ | null | false |
NonUnitalSubsemiring.instBot._proof_2 | Mathlib.RingTheory.NonUnitalSubsemiring.Defs | ∀ {R : Type u_1} [inst : NonUnitalNonAssocSemiring R] {a b : R}, a ∈ {0} → b ∈ {0} → a * b ∈ {0} | null | false |
Finmap.union.eq_1 | Mathlib.Data.Finmap | ∀ {α : Type u} {β : α → Type v} [inst : DecidableEq α] (s₁ s₂ : Finmap β),
s₁.union s₂ = s₁.liftOn₂ s₂ (fun s₁ s₂ => (s₁ ∪ s₂).toFinmap) ⋯ | null | true |
instRingCorner._proof_14 | Mathlib.RingTheory.Idempotents | ∀ {R : Type u_1} (e : R) [inst : NonUnitalRing R] (idem : IsIdempotentElem e) (a b c : idem.Corner),
(a + b) * c = a * c + b * c | null | false |
IncidenceAlgebra.instRing._proof_6 | Mathlib.Combinatorics.Enumerative.IncidenceAlgebra | ∀ {𝕜 : Type u_1} {α : Type u_2} [inst : Preorder α] [inst_1 : Ring 𝕜] (n : ℕ) (a : IncidenceAlgebra 𝕜 α),
Int.negSucc n • a = -(↑n.succ • a) | null | false |
SSet.RelativeMorphism.ofSimplex₀._proof_2 | Mathlib.AlgebraicTopology.SimplicialSet.RelativeMorphism | ∀ {X Y : SSet} (f : X ⟶ Y) (x : X.obj (Opposite.op { len := 0 })) (y : Y.obj (Opposite.op { len := 0 })),
(CategoryTheory.ConcreteCategory.hom (f.app (Opposite.op { len := 0 }))) x = y →
CategoryTheory.CategoryStruct.comp (SSet.Subcomplex.ofSimplex x).ι f =
CategoryTheory.CategoryStruct.comp (SSet.const ⟨y,... | null | false |
_private.Init.Data.List.Find.0.List.head_flatten._simp_1_1 | Init.Data.List.Find | ∀ {α : Type u_1} {a : α} {xs : List α} (h : xs ≠ []), (xs.head h = a) = (xs.head? = some a) | null | false |
SkewMonoidAlgebra.ofCoeff_eq_zero | Mathlib.Algebra.SkewMonoidAlgebra.Basic | ∀ {k : Type u_1} {G : Type u_2} [inst : AddMonoid k] {a : G →₀ k}, { coeff := a } = 0 ↔ a = 0 | null | true |
Sum.not_inr_le_inl._simp_1 | Mathlib.Order.Sum.Order | ∀ {α : Type u_1} {β : Type u_2} [inst : LE α] [inst_1 : LE β] {a : α} {b : β}, (Sum.inr b ≤ Sum.inl a) = False | null | false |
CategoryTheory.op_epi_iff | Mathlib.CategoryTheory.EpiMono | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {X Y : C} (f : X ⟶ Y),
CategoryTheory.Epi f.op ↔ CategoryTheory.Mono f | null | true |
_private.Batteries.Data.Array.Basic.0.Array.scanrMFast.loop._proof_1 | Batteries.Data.Array.Basic | ∀ {α : Type u_1} (as : Array α) (start : USize), start.toNat ≤ as.size → start - 1 < start → (start - 1).toNat < as.size | null | false |
List.cyclicPermutations_ne_nil._simp_1 | Mathlib.Data.List.Rotate | ∀ {α : Type u} (l : List α), (l.cyclicPermutations = []) = False | null | false |
CategoryTheory.MorphismProperty.ext | Mathlib.CategoryTheory.MorphismProperty.Basic | ∀ {C : Type u} [inst : CategoryTheory.CategoryStruct.{v, u} C] (W W' : CategoryTheory.MorphismProperty C),
(∀ ⦃X Y : C⦄ (f : X ⟶ Y), W f ↔ W' f) → W = W' | null | true |
measurable_from_prod_countable_left' | Mathlib.MeasureTheory.MeasurableSpace.Constructions | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} {m : MeasurableSpace α} {mβ : MeasurableSpace β} {mγ : MeasurableSpace γ}
[Countable β] {f : α × β → γ},
(∀ (y : β), Measurable fun x => f (x, y)) →
(∀ (y y' : β) (x : α), y' ∈ measurableAtom y → f (x, y') = f (x, y)) → Measurable f | See `measurable_from_prod_countable_left` for a version where we assume that singletons are
measurable instead of reasoning about `measurableAtom`. | true |
CategoryTheory.Limits.SingleObj.Types.sections.equivFixedPoints._proof_2 | Mathlib.CategoryTheory.Limits.Shapes.SingleObj | ∀ {M : Type u_2} [inst : Monoid M] (J : CategoryTheory.Functor (CategoryTheory.SingleObj M) (Type u_1)),
Function.RightInverse (fun p => ⟨fun x => ↑p, ⋯⟩) fun s => ⟨↑s (CategoryTheory.SingleObj.star M), ⋯⟩ | null | false |
Lean.Parser.withoutInfo | Lean.Parser.Basic | Lean.Parser.Parser → Lean.Parser.Parser | null | true |
mem_irreducibleComponent | Mathlib.Topology.Irreducible | ∀ {X : Type u_1} [inst : TopologicalSpace X] {x : X}, x ∈ irreducibleComponent x | [Stacks Tag 004W](https://stacks.math.columbia.edu/tag/004W) ((4)) | true |
Besicovitch.SatelliteConfig.inter | Mathlib.MeasureTheory.Covering.Besicovitch | ∀ {α : Type u_1} [inst : MetricSpace α] {N : ℕ} {τ : ℝ} (self : Besicovitch.SatelliteConfig α N τ),
∀ i < Fin.last N, dist (self.c i) (self.c (Fin.last N)) ≤ self.r i + self.r (Fin.last N) | null | true |
CategoryTheory.ProjectiveResolution.π_f_succ | Mathlib.CategoryTheory.Preadditive.Projective.Resolution | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasZeroObject C]
[inst_2 : CategoryTheory.Limits.HasZeroMorphisms C] {Z : C} (P : CategoryTheory.ProjectiveResolution Z) (n : ℕ),
P.π.f (n + 1) = 0 | null | true |
Algebra.Generators.CotangentSpace.compEquiv._proof_6 | Mathlib.RingTheory.Kaehler.JacobiZariski | ∀ {S : Type u_1} [inst : CommRing S] {T : Type u_3} [inst_1 : CommRing T] [inst_2 : Algebra S T] {ι : Type u_2}
(Q : Algebra.Generators S T ι), SMulCommClass Q.toExtension.Ring T T | null | false |
Finset.Ico_union_Ico' | Mathlib.Order.Interval.Finset.Basic | ∀ {α : Type u_2} [inst : LinearOrder α] [inst_1 : LocallyFiniteOrder α] {a b c d : α},
c ≤ b → a ≤ d → Finset.Ico a b ∪ Finset.Ico c d = Finset.Ico (min a c) (max b d) | This is a special case of `Ico_union_Ico` | true |
_private.Lean.PrettyPrinter.0.Lean.PrettyPrinter.ppConstNameWithInfos._sparseCasesOn_1 | Lean.PrettyPrinter | {α : Type u} →
{motive : Option α → Sort u_1} →
(t : Option α) → ((val : α) → motive (some val)) → (Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t | null | false |
PUnit.sub_eq | Mathlib.Algebra.Group.PUnit | ∀ (x y : PUnit.{u_1 + 1}), x - y = PUnit.unit | null | true |
Subgroup.FiniteIndex | Mathlib.GroupTheory.Index | {G : Type u_1} → [inst : Group G] → Subgroup G → Prop | Typeclass for finite index subgroups. | true |
CategoryTheory.Presieve.instHasPullbacksSingletonOfHasPullback | Mathlib.CategoryTheory.Sites.Sieves.Presieve | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {X Y Z : C} (f : Y ⟶ X) (g : Z ⟶ X)
[CategoryTheory.Limits.HasPullback g f], (CategoryTheory.Presieve.singleton g).HasPullbacks f | null | true |
Unitization.inr_mono | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Order | ∀ {A : Type u_1} [inst : NonUnitalCStarAlgebra A] [inst_1 : PartialOrder A] [StarOrderedRing A] {a b : A},
a ≤ b → ↑a ≤ ↑b | **Alias** of the reverse direction of `Unitization.inr_le_inr_iff`. | true |
Nat.toArray_rcc_eq_singleton_iff | Init.Data.Range.Polymorphic.NatLemmas | ∀ {k m n : ℕ}, (m...=n).toArray = #[k] ↔ n = m ∧ m = k | null | true |
_private.Lean.Elab.BuiltinTerm.0.Lean.Elab.Term.elabEnsureExpectedType._regBuiltin.Lean.Elab.Term.elabEnsureExpectedType.declRange_3 | Lean.Elab.BuiltinTerm | IO Unit | null | false |
FirstOrder.Language.age.fg_substructure | Mathlib.ModelTheory.Fraisse | ∀ {L : FirstOrder.Language} {M : Type w} [inst : L.Structure M] {S : L.Substructure M},
S.FG → { α := ↥S, str := inferInstance } ∈ L.age M | null | true |
Std.Tactic.BVDecide.BVPred.noConfusionType | Std.Tactic.BVDecide.Bitblast.BVExpr.Basic | Sort u → Std.Tactic.BVDecide.BVPred → Std.Tactic.BVDecide.BVPred → Sort u | null | false |
Function.Injective.completeBooleanAlgebra._proof_4 | Mathlib.Order.CompleteBooleanAlgebra | ∀ {α : Type u_1} {β : Type u_2} [inst : Max α] [inst_1 : Min α] [inst_2 : LE α] [inst_3 : LT α] [inst_4 : Top α]
[inst_5 : Bot α] [inst_6 : Compl α] [inst_7 : HImp α] [inst_8 : SDiff α] [inst_9 : CompleteBooleanAlgebra β]
(f : α → β) (hf : Function.Injective f) (le : ∀ {x y : α}, f x ≤ f y ↔ x ≤ y) (lt : ∀ {x y : α... | null | false |
Filter.mem_pi_of_mem | Mathlib.Order.Filter.Pi | ∀ {ι : Type u_1} {α : ι → Type u_2} {f : (i : ι) → Filter (α i)} (i : ι) {s : Set (α i)},
s ∈ f i → Function.eval i ⁻¹' s ∈ Filter.pi f | null | true |
CategoryTheory.ShortComplex.cyclesFunctor_obj | Mathlib.Algebra.Homology.ShortComplex.LeftHomology | ∀ (C : Type u_1) [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
[inst_2 : CategoryTheory.Limits.HasKernels C] [inst_3 : CategoryTheory.Limits.HasCokernels C]
(S : CategoryTheory.ShortComplex C), (CategoryTheory.ShortComplex.cyclesFunctor C).obj S = S.cycles | null | true |
String.Slice.pos!_eq_pos | Init.Data.String.Lemmas.Basic | ∀ {s : String.Slice} {p : String.Pos.Raw} (h : String.Pos.Raw.IsValidForSlice s p), s.pos! p = s.pos p h | null | true |
InverseSystem.pEquivOnLim._proof_2 | Mathlib.Order.DirectedInverseSystem | ∀ {ι : Type u_2} {F : ι → Type u_3} {X : ι → Type u_1} {i : ι} [inst : LinearOrder ι]
{f : ⦃i j : ι⦄ → i ≤ j → F j → F i} [inst_1 : SuccOrder ι]
{equivSucc : ⦃i : ι⦄ → ¬IsMax i → F (Order.succ i) ≃ F i × X i} [inst_2 : WellFoundedLT ι]
(hi : Order.IsSuccPrelimit i) (e : (j : ↑(Set.Iio i)) → InverseSystem.PEquivOn... | null | false |
_private.Mathlib.AlgebraicGeometry.ProjectiveSpectrum.Scheme.0.AlgebraicGeometry.termSbo_ | Mathlib.AlgebraicGeometry.ProjectiveSpectrum.Scheme | Lean.ParserDescr | basic open sets in `Spec` | true |
EReal.div_zero | Mathlib.Data.EReal.Inv | ∀ {a : EReal}, a / 0 = 0 | null | true |
Aesop.EMap.mk.sizeOf_spec | Aesop.EMap | ∀ {α : Type u_1} [inst : SizeOf α] (rep : Lean.PArray (Option (Lean.Expr × α))) (idx : Lean.Meta.DiscrTree ℕ),
sizeOf { rep := rep, idx := idx } = 1 + sizeOf rep + sizeOf idx | null | true |
ProbabilityTheory.indepSets_singleton_iff | Mathlib.Probability.Independence.Basic | ∀ {Ω : Type u_1} {_mΩ : MeasurableSpace Ω} {μ : MeasureTheory.Measure Ω} {s t : Set Ω},
ProbabilityTheory.IndepSets {s} {t} μ ↔ μ (s ∩ t) = μ s * μ t | null | true |
Set.Pairwise.insert_of_symmetric | Mathlib.Data.Set.Pairwise.Basic | ∀ {α : Type u_1} {r : α → α → Prop} {s : Set α} {a : α} [Std.Symm r],
s.Pairwise r → (∀ b ∈ s, a ≠ b → r a b) → (insert a s).Pairwise r | **Alias** of `Set.Pairwise.insert_of_symm`. | true |
_private.Mathlib.NumberTheory.FLT.Three.0.FermatLastTheoremForThreeGen.Solution.lambda_not_dvd_y | Mathlib.NumberTheory.FLT.Three | ∀ {K : Type u_1} [inst : Field K] {ζ : K} {hζ : IsPrimitiveRoot ζ 3} (S : FermatLastTheoremForThreeGen.Solution✝ hζ)
[inst_1 : NumberField K] [IsCyclotomicExtension {3} ℚ K],
¬hζ.toInteger - 1 ∣ FermatLastTheoremForThreeGen.Solution.y✝ S | null | true |
_private.Mathlib.Tactic.Tauto.0.Mathlib.Tactic.Tauto.distribNotAt.match_1 | Mathlib.Tactic.Tauto | (motive : ℕ → List Lean.Expr → Sort u_1) →
(nIters : ℕ) →
(x : List Lean.Expr) →
((x : List Lean.Expr) → motive 0 x) →
((x : ℕ) → motive x []) →
((n : ℕ) → (fv : Lean.Expr) → (fvs : List Lean.Expr) → motive n.succ (fv :: fvs)) → motive nIters x | null | false |
_private.Batteries.Data.Vector.Lemmas.0.Vector.last_cons_pop_perm._proof_1_10 | Batteries.Data.Vector.Lemmas | ∀ {α : Type u_1} {n : ℕ} {v : Vector α (n + 1)} (hne : v.toList ≠ []), [v.toArray.toList.getLast ⋯] ≠ [] | null | false |
Colex.exists._simp_1 | Mathlib.Order.Lex | ∀ {α : Type u_1} {p : Colex α → Prop}, (∃ a, p a) = ∃ a, p (toColex a) | null | false |
CategoryTheory.Limits.splitMonoOfIdempotentOfIsLimitFork_retraction | Mathlib.CategoryTheory.Limits.Shapes.Equalizers | ∀ (C : Type u) [inst : CategoryTheory.Category.{v, u} C] {X : C} {f : X ⟶ X}
(hf : CategoryTheory.CategoryStruct.comp f f = f)
{c : CategoryTheory.Limits.Fork (CategoryTheory.CategoryStruct.id X) f} (i : CategoryTheory.Limits.IsLimit c),
(CategoryTheory.Limits.splitMonoOfIdempotentOfIsLimitFork C hf i).retraction... | null | true |
MeasureTheory.AEEqFun.coeFn_add | Mathlib.MeasureTheory.Function.AEEqFun | ∀ {α : Type u_1} {γ : Type u_3} [inst : MeasurableSpace α] {μ : MeasureTheory.Measure α} [inst_1 : TopologicalSpace γ]
[inst_2 : Add γ] [inst_3 : ContinuousAdd γ] (f g : α →ₘ[μ] γ), ↑(f + g) =ᵐ[μ] ↑f + ↑g | null | true |
AlgebraicGeometry.Scheme.Modules.fromTildeΓNatTrans | Mathlib.AlgebraicGeometry.Modules.Tilde | {R : CommRingCat} →
AlgebraicGeometry.moduleSpecΓFunctor.comp (AlgebraicGeometry.tilde.functor R) ⟶
CategoryTheory.Functor.id (AlgebraicGeometry.Spec R).Modules | This is the counit of the tilde-Gamma adjunction. | true |
derivWithin_intCast | Mathlib.Analysis.Calculus.Deriv.Basic | ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {F : Type v} [inst_1 : NormedAddCommGroup F]
[inst_2 : NormedSpace 𝕜 F] (s : Set 𝕜) [inst_3 : IntCast F] (z : ℤ), derivWithin (↑z) s = 0 | null | true |
ProofWidgets.LayoutKind.inline | ProofWidgets.Data.Html | ProofWidgets.LayoutKind | null | true |
ContinuousLinearMap.flip_smul | Mathlib.Analysis.Normed.Operator.Bilinear | ∀ {𝕜 : Type u_1} {𝕜₂ : Type u_2} {𝕜₃ : Type u_3} {E' : Type u_6} {F' : Type u_10} {G' : Type u_14}
[inst : NontriviallyNormedField 𝕜] [inst_1 : NontriviallyNormedField 𝕜₂] [inst_2 : NontriviallyNormedField 𝕜₃]
{σ₂₃ : 𝕜₂ →+* 𝕜₃} {σ₁₃ : 𝕜 →+* 𝕜₃} [inst_3 : AddCommGroup E'] [inst_4 : Module 𝕜 E'] [inst_5 : ... | null | true |
AddSubgroup.Commensurable.discreteTopology_iff | Mathlib.Topology.Algebra.IsUniformGroup.DiscreteSubgroup | ∀ {G : Type u_2} [inst : AddGroup G] [inst_1 : TopologicalSpace G] [IsTopologicalAddGroup G] [T2Space G]
{H K : AddSubgroup G}, H.Commensurable K → (DiscreteTopology ↥H ↔ DiscreteTopology ↥K) | null | true |
IsPrimitiveRoot.neg_one | Mathlib.RingTheory.RootsOfUnity.PrimitiveRoots | ∀ {R : Type u_4} [inst : CommRing R] (p : ℕ) [Nontrivial R] [h : CharP R p], p ≠ 2 → IsPrimitiveRoot (-1) 2 | null | true |
AddLocalization.liftOn.eq_1 | Mathlib.GroupTheory.MonoidLocalization.Basic | ∀ {M : Type u_1} [inst : AddCommMonoid M] {S : AddSubmonoid M} {p : Sort u} (x : AddLocalization S) (f : M → ↥S → p)
(H : ∀ {a c : M} {b d : ↥S}, (AddLocalization.r S) (a, b) (c, d) → f a b = f c d),
x.liftOn f H = AddLocalization.rec f ⋯ x | null | true |
ProbabilityTheory.HasLaw.memLp_comp | Mathlib.Probability.HasLaw | ∀ {Ω : Type u_1} {𝓧 : Type u_2} {mΩ : MeasurableSpace Ω} {m𝓧 : MeasurableSpace 𝓧} {X : Ω → 𝓧}
{μ : MeasureTheory.Measure 𝓧} {P : MeasureTheory.Measure Ω} {ε : Type u_3} [inst : TopologicalSpace ε]
[inst_1 : ContinuousENorm ε],
ProbabilityTheory.HasLaw X μ P →
∀ {f : 𝓧 → ε} {p : ENNReal}, MeasureTheory.M... | null | true |
AddValuation.map._proof_3 | Mathlib.RingTheory.Valuation.Basic | ∀ {Γ₀ : Type u_1} {Γ'₀ : Type u_2} [inst : LinearOrderedAddCommMonoidWithTop Γ₀]
[inst_1 : LinearOrderedAddCommMonoidWithTop Γ'₀] (f : Γ₀ →+o Γ'₀) (x x_1 : Multiplicative Γ₀ᵒᵈ),
x ≤ x_1 → (↑f.toAddMonoidHom).toFun x_1 ≤ (↑f.toAddMonoidHom).toFun x | null | false |
RBTree.RBNode.IsStrictCut.mk._flat_ctor | Batteries.Recycling.RBTree.Lemmas | ∀ {α : Type u_1} {cmp : α → α → Ordering} {cut : α → Ordering},
(∀ {x y : α} [Std.TransCmp cmp], cmp x y ≠ Ordering.gt → cut x = Ordering.lt → cut y = Ordering.lt) →
(∀ {x y : α} [Std.TransCmp cmp], cmp x y ≠ Ordering.gt → cut y = Ordering.gt → cut x = Ordering.gt) →
(∀ {x y : α} [Std.TransCmp cmp], cut x =... | null | false |
ContinuousLinearMapWOT.ext_dual_iff | Mathlib.Analysis.LocallyConvex.WeakOperatorTopology | ∀ {𝕜₁ : Type u_1} {𝕜₂ : Type u_2} [inst : NormedField 𝕜₁] [inst_1 : NormedField 𝕜₂] {σ : 𝕜₁ →+* 𝕜₂} {E : Type u_3}
{F : Type u_4} [inst_2 : AddCommGroup E] [inst_3 : TopologicalSpace E] [inst_4 : Module 𝕜₁ E]
[inst_5 : AddCommGroup F] [inst_6 : TopologicalSpace F] [inst_7 : Module 𝕜₂ F] [H : SeparatingDual ... | null | true |
_private.Mathlib.RingTheory.TwoSidedIdeal.Operations.0.TwoSidedIdeal.mem_span_iff_mem_addSubgroup_closure_absorbing._simp_1_1 | Mathlib.RingTheory.TwoSidedIdeal.Operations | ∀ {R : Type u_1} [inst : NonUnitalNonAssocRing R] (carrier : Set R) (zero_mem : 0 ∈ carrier)
(add_mem : ∀ {x y : R}, x ∈ carrier → y ∈ carrier → x + y ∈ carrier) (neg_mem : ∀ {x : R}, x ∈ carrier → -x ∈ carrier)
(mul_mem_left : ∀ {x y : R}, y ∈ carrier → x * y ∈ carrier)
(mul_mem_right : ∀ {x y : R}, x ∈ carrier ... | null | false |
Turing.PartrecToTM2.move₂_ok | Mathlib.Computability.TuringMachine.ToPartrec | ∀ {p : Turing.PartrecToTM2.Γ' → Bool} {k₁ k₂ : Turing.PartrecToTM2.K'} {q : Turing.PartrecToTM2.Λ'}
{s : Option Turing.PartrecToTM2.Γ'} {L₁ : List Turing.PartrecToTM2.Γ'} {o : Option Turing.PartrecToTM2.Γ'}
{L₂ : List Turing.PartrecToTM2.Γ'} {S : Turing.PartrecToTM2.K' → List Turing.PartrecToTM2.Γ'},
k₁ ≠ Turing.... | null | true |
_private.Mathlib.Combinatorics.SetFamily.DualVC.0.Finset.cubeBitSlice.eq_1 | Mathlib.Combinatorics.SetFamily.DualVC | ∀ {α : Type u_1} [inst : DecidableEq α] {n : ℕ} {S : Finset (Finset α)} (cube : (Fin n → Bool) ↪ ↥S) (k : Fin n),
Finset.cubeBitSlice✝ cube k = Finset.image (fun b => ↑(cube b)) {b | b k = true} | null | true |
Lean.Elab.Tactic.RCases.RCasesPatt.noConfusion | Lean.Elab.Tactic.RCases | {P : Sort u} →
{t t' : Lean.Elab.Tactic.RCases.RCasesPatt} → t = t' → Lean.Elab.Tactic.RCases.RCasesPatt.noConfusionType P t t' | null | false |
Filter.HasBasis.cauchySeq_iff | Mathlib.Topology.UniformSpace.Cauchy | ∀ {α : Type u} {β : Type v} [uniformSpace : UniformSpace α] {γ : Sort u_1} [Nonempty β] [inst : SemilatticeSup β]
{u : β → α} {p : γ → Prop} {s : γ → SetRel α α},
(uniformity α).HasBasis p s →
(CauchySeq u ↔ ∀ (i : γ), p i → ∃ N, ∀ (m : β), N ≤ m → ∀ (n : β), N ≤ n → (u m, u n) ∈ s i) | null | true |
TypeVec.toSubtype._unsafe_rec | Mathlib.Data.TypeVec | {n : ℕ} →
{α : TypeVec.{u} n} →
(p : α.Arrow (TypeVec.repeat n Prop)) →
TypeVec.Arrow (fun i => { x // TypeVec.ofRepeat (p i x) }) (TypeVec.Subtype_ p) | null | false |
Lean.Compiler.LCNF.Code.return.noConfusion | Lean.Compiler.LCNF.Basic | {pu : Lean.Compiler.LCNF.Purity} →
{P : Sort u} →
{fvarId fvarId' : Lean.FVarId} →
Lean.Compiler.LCNF.Code.return fvarId = Lean.Compiler.LCNF.Code.return fvarId' → (fvarId = fvarId' → P) → P | null | false |
_private.Mathlib.SetTheory.ZFC.Rank.0.PSet.rank_insert._simp_1_2 | Mathlib.SetTheory.ZFC.Rank | ∀ {x y z : PSet.{u}}, (x ∈ insert y z) = (x.Equiv y ∨ x ∈ z) | null | false |
Lean.Lsp.RpcWireFormat.recOn | Lean.Server.Rpc.Basic | {motive : Lean.Lsp.RpcWireFormat → Sort u} →
(t : Lean.Lsp.RpcWireFormat) → motive Lean.Lsp.RpcWireFormat.v0 → motive Lean.Lsp.RpcWireFormat.v1 → motive t | null | false |
Equiv.Perm.IsThreeCycle | Mathlib.GroupTheory.Perm.Cycle.Type | {α : Type u_1} → [Fintype α] → [DecidableEq α] → Equiv.Perm α → Prop | A three-cycle is a cycle of length 3. | true |
WittVector.idIsPolyI' | Mathlib.RingTheory.WittVector.IsPoly | ∀ (p : ℕ), WittVector.IsPoly p fun x x_1 a => a | null | true |
Nat.Partrec.Code.pappAck.match_1 | Mathlib.Computability.Ackermann | (motive : ℕ → Sort u_1) → (x : ℕ) → (Unit → motive 0) → ((n : ℕ) → motive n.succ) → motive x | null | false |
PosPart.noConfusionType | Mathlib.Algebra.Notation | Sort u → {α : Type u_1} → PosPart α → {α' : Type u_1} → PosPart α' → Sort u | null | false |
Lean.Meta.Grind.NormalizePattern.State.recOn | Lean.Meta.Tactic.Grind.EMatchTheorem | {motive : Lean.Meta.Grind.NormalizePattern.State → Sort u} →
(t : Lean.Meta.Grind.NormalizePattern.State) →
((symbols : Array Lean.HeadIndex) →
(symbolSet : Std.HashSet Lean.HeadIndex) →
(bvarsFound : Std.HashSet ℕ) →
motive { symbols := symbols, symbolSet := symbolSet, bvarsFound :=... | null | false |
Std.ExtDHashMap.Const.get_modify_self | Std.Data.ExtDHashMap.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {β : Type v} {m : Std.ExtDHashMap α fun x => β} [inst : EquivBEq α]
[inst_1 : LawfulHashable α] {k : α} {f : β → β} {h : k ∈ Std.ExtDHashMap.Const.modify m k f},
Std.ExtDHashMap.Const.get (Std.ExtDHashMap.Const.modify m k f) k h = f (Std.ExtDHashMap.Const.get m k ⋯) | null | true |
Module.Relations.Solution.IsPresentation.desc.congr_simp | Mathlib.Algebra.Module.Presentation.Basic | ∀ {A : Type u} [inst : Ring A] {relations : Module.Relations A} {M : Type v} [inst_1 : AddCommGroup M]
[inst_2 : Module A M] {solution solution_1 : relations.Solution M} (e_solution : solution = solution_1)
(h : solution.IsPresentation) {N : Type v'} [inst_3 : AddCommGroup N] [inst_4 : Module A N]
(s s_1 : relati... | null | true |
Std.DTreeMap.Internal.Impl.Const.maxKeyD_alter!_eq_self | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {instOrd : Ord α} {β : Type v} {t : Std.DTreeMap.Internal.Impl α fun x => β} [Std.TransOrd α],
t.WF →
∀ {k : α} {f : Option β → Option β},
(Std.DTreeMap.Internal.Impl.Const.alter! k f t).isEmpty = false →
∀ {fallback : α},
(Std.DTreeMap.Internal.Impl.Const.alter! k f t).maxK... | null | true |
_private.Mathlib.NumberTheory.NumberField.Cyclotomic.Ideal.0.IsCyclotomicExtension.Rat.«term𝒑» | Mathlib.NumberTheory.NumberField.Cyclotomic.Ideal | Lean.ParserDescr | null | true |
FloatArray.map | Batteries.Data.FloatArray | FloatArray → (Float → Float) → FloatArray | `map f a` applies the function `f` to each element of the array. | true |
_private.Mathlib.Algebra.Module.ZLattice.Summable.0.ZLattice.sum_piFinset_Icc_rpow_le._simp_1_9 | Mathlib.Algebra.Module.ZLattice.Summable | ∀ {G : Type u_1} [inst : DivInvMonoid G] (a : G) (n : ℕ), a ^ n = a ^ ↑n | null | false |
CategoryTheory.Mod.Hom.mk | Mathlib.CategoryTheory.Monoidal.Mod | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
[inst_1 : CategoryTheory.MonoidalCategory C] →
{D : Type u₂} →
[inst_2 : CategoryTheory.Category.{v₂, u₂} D] →
[inst_3 : CategoryTheory.MonoidalCategory.MonoidalLeftAction C D] →
{A : C} →
[inst_4 : Cat... | null | true |
AddGroup.residuallyFinite_of_forall_exists_finite_addMonoidHom | Mathlib.GroupTheory.ResiduallyFinite | ∀ {G : Type u_1} [inst : AddGroup G],
(∀ (g : G), g ≠ 0 → ∃ H x, ∃ (_ : Finite H), ∃ f, f g ≠ 0) → AddGroup.ResiduallyFinite G | `G` is residually finite if for every element `g` not equal to `0` there exists an
additive group homomorphism `f` to a finite additive group `H` such that `f g ≠ 0`. | true |
_aux_Mathlib_Data_Fintype_Sets___elabRules_finsetStx_1 | Mathlib.Data.Fintype.Sets | Lean.Elab.Term.TermElab | `finset% t` elaborates `t` as a `Finset`.
If `t` is a `Set`, then inserts `Set.toFinset`.
Does not make use of the expected type; useful for big operators over finsets.
```
#check finset% Finset.range 2 -- Finset Nat
#check finset% (Set.univ : Set Bool) -- Finset Bool
```
| false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.