name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
_private.Mathlib.Order.SuccPred.Archimedean.0.Set.OrdConnected.isSuccArchimedean._proof_2 | Mathlib.Order.SuccPred.Archimedean | ∀ {α : Type u_1} [inst : PartialOrder α] [inst_1 : SuccOrder α] [IsSuccArchimedean α] (s : Set α)
[inst_3 : s.OrdConnected], IsSuccArchimedean ↑s | null | false |
Module.Free.rank_eq_card_chooseBasisIndex | Mathlib.LinearAlgebra.Dimension.Free | ∀ (R : Type u) (M : Type v) [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
[inst_3 : Module.Free R M] [StrongRankCondition R], Module.rank R M = Cardinal.mk (Module.Free.ChooseBasisIndex R M) | The rank of a free module `M` over `R` is the cardinality of `ChooseBasisIndex R M`. | true |
Polynomial.instCommRingUniversalFactorizationRing._proof_31 | Mathlib.RingTheory.Polynomial.UniversalFactorizationRing | ∀ {R : Type u_1} [inst : CommRing R] {n : ℕ} (m k : ℕ) (hn : n = m + k) (p : Polynomial.MonicDegreeEq R n),
autoParam (∀ (n_1 : ℕ), ↑(n_1 + 1) = ↑n_1 + 1) AddMonoidWithOne.natCast_succ._autoParam | null | false |
CategoryTheory.Functor.leibnizPushout._proof_1 | Mathlib.CategoryTheory.Limits.Shapes.Pullback.PullbackObjObj | ∀ {C₁ : Type u_6} {C₂ : Type u_4} {C₃ : Type u_2} [inst : CategoryTheory.Category.{u_5, u_6} C₁]
[inst_1 : CategoryTheory.Category.{u_3, u_4} C₂] [inst_2 : CategoryTheory.Category.{u_1, u_2} C₃]
(F : CategoryTheory.Functor C₁ (CategoryTheory.Functor C₂ C₃)) [CategoryTheory.Limits.HasPushouts C₃]
(f₁ : CategoryThe... | null | false |
equicontinuousOn_finite | Mathlib.Topology.UniformSpace.Equicontinuity | ∀ {ι : Type u_1} {X : Type u_3} {α : Type u_6} [tX : TopologicalSpace X] [uα : UniformSpace α] [Finite ι]
{F : ι → X → α} {S : Set X}, EquicontinuousOn F S ↔ ∀ (i : ι), ContinuousOn (F i) S | null | true |
LinearEquiv.coord | Mathlib.LinearAlgebra.Span.Basic | (R : Type u_1) →
(M : Type u_4) →
[inst : Ring R] →
[IsDomain R] →
[inst_2 : AddCommGroup M] →
[inst_3 : Module R M] → [Module.IsTorsionFree R M] → (x : M) → x ≠ 0 → ↥(R ∙ x) ≃ₗ[R] R | Given a nonzero element `x` of a torsion-free module `M` over a ring `R`, the natural
isomorphism from the span of `x` to `R` given by $r \cdot x \mapsto r$. | true |
Stream'.Seq.length.congr_simp | Mathlib.Data.Seq.Basic | ∀ {α : Type u} (s s_1 : Stream'.Seq α) (e_s : s = s_1) (h : s.Terminates), s.length h = s_1.length ⋯ | null | true |
_private.Mathlib.Analysis.SpecialFunctions.Elliptic.Weierstrass.0.PeriodPair.coeff_weierstrassPExceptSeries._simp_1_4 | Mathlib.Analysis.SpecialFunctions.Elliptic.Weierstrass | ∀ {G : Type u_1} [inst : DivInvMonoid G] (a : G) (n : ℕ), a ^ n = a ^ ↑n | null | false |
Submodule.IsAssociatedPrime.recOn | Mathlib.RingTheory.Ideal.AssociatedPrime.Basic | {R : Type u_1} →
{M : Type u_2} →
[inst : CommSemiring R] →
[inst_1 : AddCommMonoid M] →
[inst_2 : Module R M] →
{N : Submodule R M} →
{I : Ideal R} →
{motive : N.IsAssociatedPrime I → Sort u} →
(t : N.IsAssociatedPrime I) →
((toI... | null | false |
CochainComplex.HomComplex.Cocycle.equivHom_apply | Mathlib.Algebra.Homology.HomotopyCategory.HomComplex | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Preadditive C]
(F G : CochainComplex C ℤ) (φ : F ⟶ G),
(CochainComplex.HomComplex.Cocycle.equivHom F G) φ = CochainComplex.HomComplex.Cocycle.ofHom φ | null | true |
Lean.Parser.Term.doSeqItem | Lean.Parser.Do | Lean.Parser.Parser | null | true |
_private.Lean.PrivateName.0.Lean.privatePrefixAux._unsafe_rec | Lean.PrivateName | Lean.Name → Lean.Name | null | false |
_private.Mathlib.NumberTheory.Padics.Measure.AmiceTransform.0.AbstractMeasure.amiceTransformEquiv._proof_1 | Mathlib.NumberTheory.Padics.Measure.AmiceTransform | ∀ {p : ℕ} [inst : Fact (Nat.Prime p)], IsTopologicalAddGroup ℤ_[p] | null | false |
RingCon.instAddGroupQuotient._proof_9 | Mathlib.RingTheory.Congruence.Defs | ∀ {R : Type u_1} [inst : AddGroup R] [inst_1 : Mul R] (c : RingCon R) (n : ℕ) (a : c.Quotient),
Int.negSucc n • a = -(↑n.succ • a) | null | false |
AddOpposite.unop_sub | Mathlib.Algebra.Group.Opposite | ∀ {α : Type u_1} [inst : SubNegMonoid α] (x y : αᵃᵒᵖ),
AddOpposite.unop (x - y) = -AddOpposite.unop y + AddOpposite.unop x | null | true |
Std.ExtHashMap.get?.congr_simp | Std.Data.ExtHashMap.Lemmas | ∀ {α : Type u} {β : Type v} {x : BEq α} {x_1 : Hashable α} [inst : EquivBEq α] [inst_1 : LawfulHashable α]
(m m_1 : Std.ExtHashMap α β), m = m_1 → ∀ (a a_1 : α), a = a_1 → m.get? a = m_1.get? a_1 | null | true |
CategoryTheory.functorialSurjectiveInjectiveFactorizationData._proof_6 | Mathlib.CategoryTheory.MorphismProperty.Concrete | ∀ (f : CategoryTheory.Arrow (Type u_1)),
CategoryTheory.MorphismProperty.surjective (Type u_1)
({ app := fun f => TypeCat.ofHom fun x => ⟨(CategoryTheory.ConcreteCategory.hom f.hom) x, ⋯⟩, naturality := ⋯ }.app
f) | null | false |
_private.Mathlib.Combinatorics.SimpleGraph.Connectivity.Subgraph.0.SimpleGraph.Walk.IsPath.neighborSet_toSubgraph_internal._proof_1_1 | Mathlib.Combinatorics.SimpleGraph.Connectivity.Subgraph | ∀ {i : ℕ}, i ≠ 0 → i - 1 + 1 = i | null | false |
_private.Mathlib.Util.Notation3.0.Mathlib.Notation3.mkExprMatcher.match_1 | Mathlib.Util.Notation3 | (motive : Lean.LocalContext × Std.HashMap Lean.FVarId Lean.Name → Sort u_1) →
(x : Lean.LocalContext × Std.HashMap Lean.FVarId Lean.Name) →
((lctx : Lean.LocalContext) → (boundFVars : Std.HashMap Lean.FVarId Lean.Name) → motive (lctx, boundFVars)) →
motive x | null | false |
LocalizedModule.instSemiring._proof_5 | Mathlib.Algebra.Module.LocalizedModule.Basic | ∀ {R : Type u_1} [inst : CommSemiring R] {A : Type u_2} [inst_1 : Semiring A] [inst_2 : Algebra R A] {S : Submonoid R}
(a b c : LocalizedModule S A), (a + b) * c = a * c + b * c | null | false |
VectorPrebundle.continuousOn_coordChange | Mathlib.Topology.VectorBundle.Basic | ∀ {R : Type u_1} {B : Type u_2} {F : Type u_3} {E : B → Type u_4} [inst : NontriviallyNormedField R]
[inst_1 : (x : B) → AddCommMonoid (E x)] [inst_2 : (x : B) → Module R (E x)] [inst_3 : NormedAddCommGroup F]
[inst_4 : NormedSpace R F] [inst_5 : TopologicalSpace B] [inst_6 : (x : B) → TopologicalSpace (E x)]
(a ... | null | true |
_private.Mathlib.Topology.Algebra.Module.Spaces.WeakBilin.0.WeakBilin.instIsScalarTower._proof_1 | Mathlib.Topology.Algebra.Module.Spaces.WeakBilin | ∀ {𝕜 : Type u_2} {𝕝 : Type u_1} {E : Type u_3} {F : Type u_4} [inst : CommSemiring 𝕜] [inst_1 : CommSemiring 𝕝]
[inst_2 : AddCommMonoid E] [inst_3 : Module 𝕜 E] [inst_4 : AddCommMonoid F] [inst_5 : Module 𝕜 F] [inst_6 : SMul 𝕝 𝕜]
[inst_7 : Module 𝕝 E] [IsScalarTower 𝕝 𝕜 E] (B : E →ₗ[𝕜] F →ₗ[𝕜] 𝕜), IsS... | null | false |
Std.WP.Assertion.NondetFun.evalsTo_apply_3 | Std.WP.Assertion | ∀ {σ₁ σ₂ σ₃ α : Type} (f : σ₁ → σ₂ → σ₃ → α) (a : α) (s₁ : σ₁) (s₂ : σ₂) (s₃ : σ₃),
Std.WP.Assertion.NondetFun.EvalsTo f a s₁ s₂ s₃ = (f s₁ s₂ s₃ = a) | null | true |
Finset.univ_nontrivial_iff | Mathlib.Data.Finset.BooleanAlgebra | ∀ {α : Type u_1} [inst : Fintype α], Finset.univ.Nontrivial ↔ Nontrivial α | null | true |
tendstoLocallyUniformlyOn_iff_tendstoLocallyUniformly_comp_coe | Mathlib.Topology.UniformSpace.LocallyUniformConvergence | ∀ {α : Type u_1} {β : Type u_2} {ι : Type u_4} [inst : TopologicalSpace α] [inst_1 : UniformSpace β] {F : ι → α → β}
{f : α → β} {s : Set α} {p : Filter ι},
TendstoLocallyUniformlyOn F f p s ↔ TendstoLocallyUniformly (fun i x => F i ↑x) (f ∘ Subtype.val) p | null | true |
CategoryTheory.Functor.IsCoverDense.Types.presheafHom_app | Mathlib.CategoryTheory.Sites.DenseSubsite.Basic | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {D : Type u_2}
[inst_1 : CategoryTheory.Category.{v_2, u_2} D] {K : CategoryTheory.GrothendieckTopology D}
{G : CategoryTheory.Functor C D} {ℱ : CategoryTheory.Functor Dᵒᵖ (Type v)} {ℱ' : CategoryTheory.Sheaf K (Type v)}
[inst_2 : G.IsCoverDense K] [i... | null | true |
_private.Mathlib.ModelTheory.Syntax.0.FirstOrder.Language.Term.varFinsetLeft.match_1.eq_2 | Mathlib.ModelTheory.Syntax | ∀ {L : FirstOrder.Language} {α : Type u_4} {β : Type u_3} (motive : L.Term (α ⊕ β) → Sort u_5) (_i : β)
(h_1 : (i : α) → motive (FirstOrder.Language.var (Sum.inl i)))
(h_2 : (_i : β) → motive (FirstOrder.Language.var (Sum.inr _i)))
(h_3 : (l : ℕ) → (_f : L.Functions l) → (ts : Fin l → L.Term (α ⊕ β)) → motive (Fi... | null | true |
CategoryTheory.MorphismProperty.pullback_snd_iff | Mathlib.CategoryTheory.MorphismProperty.Descent | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {P Q : CategoryTheory.MorphismProperty C} {X Y Z : C}
{f : X ⟶ Z} {g : Y ⟶ Z} [P.IsStableUnderBaseChange] [P.DescendsAlong Q]
[inst_3 : CategoryTheory.Limits.HasPullback f g], Q g → (P (CategoryTheory.Limits.pullback.snd f g) ↔ P f) | null | true |
Polynomial.sylveserMap_comp_adjSylvester | Mathlib.RingTheory.Polynomial.Resultant.Basic | ∀ {m n : ℕ} {R : Type u_1} [inst : CommRing R] (f g : Polynomial R) (hf : f.natDegree ≤ m) (hg : g.natDegree ≤ n),
f.sylvesterMap g hf hg ∘ₗ f.adjSylvester g = f.resultant g m n • LinearMap.id | **Alias** of `Polynomial.sylvesterMap_comp_adjSylvester`. | true |
Polynomial.mahlerMeasure_const | Mathlib.Analysis.Polynomial.MahlerMeasure | ∀ (z : ℂ), (Polynomial.C z).mahlerMeasure = ‖z‖ | null | true |
Std.TreeMap.getKey?_map | Std.Data.TreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {γ : Type w} {cmp : α → α → Ordering} {t : Std.TreeMap α β cmp} [Std.TransCmp cmp]
{f : α → β → γ} {k : α}, (Std.TreeMap.map f t).getKey? k = t.getKey? k | null | true |
CategoryTheory.FreeMonoidalCategory.HomEquiv.below.tensorHom_comp_tensorHom | Mathlib.CategoryTheory.Monoidal.Free.Basic | ∀ {C : Type u}
{motive :
{X Y : CategoryTheory.FreeMonoidalCategory C} →
(a a_1 : X.Hom Y) → CategoryTheory.FreeMonoidalCategory.HomEquiv a a_1 → Prop}
{X₁ Y₁ Z₁ X₂ Y₂ Z₂ : CategoryTheory.FreeMonoidalCategory C} (f₁ : X₁.Hom Y₁) (f₂ : X₂.Hom Y₂) (g₁ : Y₁.Hom Z₁)
(g₂ : Y₂.Hom Z₂), CategoryTheory.FreeMono... | null | true |
_private.Lean.Compiler.LCNF.Simp.InlineProj.0.Lean.Compiler.LCNF.Simp.inlineProjInst?.visit.match_3 | Lean.Compiler.LCNF.Simp.InlineProj | (motive : List ℕ → Sort u_1) →
(projs : List ℕ) → ((i : ℕ) → (projs : List ℕ) → motive (i :: projs)) → ((x : List ℕ) → motive x) → motive projs | null | false |
_private.Mathlib.Data.Vector3.0.Fin2.insertPerm.match_1.eq_3 | Mathlib.Data.Vector3 | ∀ (motive : (x : ℕ) → Fin2 x → Fin2 x → Sort u_1) (a : ℕ) (a_1 : Fin2 a.succ)
(h_1 : (n : ℕ) → motive (n + 1) Fin2.fz Fin2.fz) (h_2 : (n : ℕ) → (j : Fin2 n) → motive (n + 1) Fin2.fz j.fs)
(h_3 : (a : ℕ) → (a_2 : Fin2 a.succ) → motive (a.succ + 1) a_2.fs Fin2.fz)
(h_4 : (a : ℕ) → (i : Fin2 a.succ) → (j : Fin2 (a +... | null | true |
Lean.Compiler.LCNF.SpecEntry.mk.noConfusion | Lean.Compiler.LCNF.SpecInfo | {P : Sort u} →
{declName : Lean.Name} →
{paramsInfo : Array Lean.Compiler.LCNF.SpecParamInfo} →
{alreadySpecialized : Bool} →
{declName' : Lean.Name} →
{paramsInfo' : Array Lean.Compiler.LCNF.SpecParamInfo} →
{alreadySpecialized' : Bool} →
{ declName := declName, ... | null | false |
CategoryTheory.RingObjCat.Hom.mk.inj | Mathlib.CategoryTheory.Monoidal.Ring | ∀ {C : Type u} {inst : CategoryTheory.Category.{v, u} C} {inst_1 : CategoryTheory.CartesianMonoidalCategory C}
{inst_2 : CategoryTheory.BraidedCategory C} {R₁ R₂ : CategoryTheory.RingObjCat C} {hom : R₁.X ⟶ R₂.X}
{isRingHom : CategoryTheory.IsRingHom hom} {hom_1 : R₁.X ⟶ R₂.X} {isRingHom_1 : CategoryTheory.IsRingHo... | null | true |
Subring.mk.injEq | Mathlib.Algebra.Ring.Subring.Defs | ∀ {R : Type u} [inst : NonAssocRing R] (toSubsemiring : Subsemiring R)
(neg_mem' : ∀ {x : R}, x ∈ toSubsemiring.carrier → -x ∈ toSubsemiring.carrier) (toSubsemiring_1 : Subsemiring R)
(neg_mem'_1 : ∀ {x : R}, x ∈ toSubsemiring_1.carrier → -x ∈ toSubsemiring_1.carrier),
({ toSubsemiring := toSubsemiring, neg_mem' ... | null | true |
Lean.Meta.AuxLemmas.mk.sizeOf_spec | Lean.Meta.Tactic.AuxLemma | ∀ (lemmas : Lean.PHashMap Lean.Meta.AuxLemmaKey (Lean.Name × List Lean.Name)),
sizeOf { lemmas := lemmas } = 1 + sizeOf lemmas | null | true |
Lean.PrettyPrinter.Delaborator.delabSort | Lean.PrettyPrinter.Delaborator.Builtins | Lean.PrettyPrinter.Delaborator.Delab | null | true |
AddLocalization.decidableEq.eq_1 | Mathlib.GroupTheory.MonoidLocalization.Basic | ∀ {α : Type u_1} [inst : AddCommMonoid α] [inst_1 : IsCancelAdd α] {s : AddSubmonoid α} [inst_2 : DecidableEq α]
(a b : AddLocalization s),
a.decidableEq b = a.recOnSubsingleton₂ b fun x x_1 x_2 x_3 => decidable_of_iff' (↑x_3 + x = ↑x_2 + x_1) ⋯ | null | true |
Filter.eventually_and | Mathlib.Order.Filter.Basic | ∀ {α : Type u} {p q : α → Prop} {f : Filter α},
(∀ᶠ (x : α) in f, p x ∧ q x) ↔ (∀ᶠ (x : α) in f, p x) ∧ ∀ᶠ (x : α) in f, q x | null | true |
Set.range_inl | Mathlib.Data.Set.Image | ∀ {α : Type u_1} {β : Type u_2}, Set.range Sum.inl = {x | x.isLeft = true} | null | true |
NonUnitalSubsemiring.comap | Mathlib.RingTheory.NonUnitalSubsemiring.Basic | {R : Type u} →
{S : Type v} →
[inst : NonUnitalNonAssocSemiring R] →
[inst_1 : NonUnitalNonAssocSemiring S] → (R →ₙ+* S) → NonUnitalSubsemiring S → NonUnitalSubsemiring R | The preimage of a non-unital subsemiring along a non-unital ring homomorphism is a
non-unital subsemiring. | true |
FirstOrder.Language.graphRel.noConfusion | Mathlib.ModelTheory.Graph | {P : Sort u} →
{a : ℕ} →
{t : FirstOrder.Language.graphRel a} →
{a' : ℕ} →
{t' : FirstOrder.Language.graphRel a'} → a = a' → t ≍ t' → FirstOrder.Language.graphRel.noConfusionType P t t' | null | false |
smul_apply | Mathlib.Algebra.Group.IsApply | ∀ {M : Type u_1} {F : Type u_2} {α : outParam (Type u_3)} {β : outParam (Type u_4)} {inst : FunLike F α β}
{inst_1 : SMul M β} {inst_2 : SMul M F} [self : IsSMulApply M F α β] (f : F) (n : M) (x : α), (n • f) x = n • f x | **Alias** of `IsSMulApply.smul_apply`. | true |
PFunctor.M.casesOn_mk' | Mathlib.Data.PFunctor.Univariate.M | ∀ {F : PFunctor.{uA, uB}} {r : F.M → Sort u_2} {a : F.A} (x : F.B a → F.M)
(f : (a : F.A) → (f : F.B a → F.M) → r (PFunctor.M.mk (PFunctor.Obj.mk a f))),
(PFunctor.M.mk (PFunctor.Obj.mk a x)).casesOn' f = f a x | null | true |
AlgebraicGeometry.instAdditiveModuleCatCarrierModulesSpecFunctor | Mathlib.AlgebraicGeometry.Modules.Tilde | ∀ {R : CommRingCat}, (AlgebraicGeometry.tilde.functor R).Additive | null | true |
Std.Do.PostShape.noConfusion | Std.Do.PostCond | {P : Sort u_1} → {t t' : Std.Do.PostShape} → t = t' → Std.Do.PostShape.noConfusionType P t t' | null | false |
CategoryTheory.instPreadditiveArrow._proof_4 | Mathlib.CategoryTheory.Preadditive.Comma | ∀ {T : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} T] [inst_1 : CategoryTheory.Preadditive T],
autoParam
(∀ (P Q R : CategoryTheory.Arrow T) (f : P ⟶ Q) (g g' : Q ⟶ R),
CategoryTheory.CategoryStruct.comp f (g + g') =
CategoryTheory.CategoryStruct.comp f g + CategoryTheory.CategoryStruct.com... | null | false |
Subfield._sizeOf_inst | Mathlib.Algebra.Field.Subfield.Defs | (K : Type u) → {inst : DivisionRing K} → [SizeOf K] → SizeOf (Subfield K) | null | false |
_private.Mathlib.Topology.Algebra.WithZeroTopology.0.WithZeroTopology.orderClosedTopology._simp_2 | Mathlib.Topology.Algebra.WithZeroTopology | ∀ {α : Type u_1} [inst : LinearOrder α] {a b : α}, (¬a ≤ b) = (b < a) | null | false |
ContDiffAt.smulRight | Mathlib.Analysis.Calculus.ContDiff.Comp | ∀ {𝕜 : Type u_1} {E : Type u_2} {F : Type u_3} {G : Type u_4} [inst : NontriviallyNormedField 𝕜]
[inst_1 : NormedAddCommGroup E] [inst_2 : NormedSpace 𝕜 E] [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F]
[inst_5 : NormedAddCommGroup G] [inst_6 : NormedSpace 𝕜 G] {x : E} {n : WithTop ℕ∞} {f : E → Str... | null | true |
Equiv.image_swap_of_mem_of_notMem | Mathlib.Logic.Equiv.Basic | ∀ {α : Type u_8} [inst : DecidableEq α] {s : Set α} {i j : α}, i ∈ s → j ∉ s → ⇑(Equiv.swap i j) '' s = insert j s \ {i} | null | true |
CategoryTheory.Limits.PullbackCone.flipIsLimit._proof_1 | Mathlib.CategoryTheory.Limits.Shapes.Pullback.PullbackCone | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {X Y Z : C} {f : X ⟶ Z} {g : Y ⟶ Z}
{t : CategoryTheory.Limits.PullbackCone f g} (ht : CategoryTheory.Limits.IsLimit t)
(s : CategoryTheory.Limits.PullbackCone g f), CategoryTheory.CategoryStruct.comp (ht.lift s.flip) t.snd = s.fst | null | false |
Finset.image_comp_eq | Mathlib.Data.Finset.Image | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} [inst : DecidableEq β] {f : α → β} [inst_1 : DecidableEq γ] {g : β → γ},
Finset.image (g ∘ f) = Finset.image g ∘ Finset.image f | null | true |
Lean.PrettyPrinter.Parenthesizer.checkColGt.parenthesizer | Lean.PrettyPrinter.Parenthesizer | Lean.PrettyPrinter.Parenthesizer | null | true |
rootsOfUnityUnitsMulEquiv._proof_6 | Mathlib.RingTheory.RootsOfUnity.Basic | ∀ (M : Type u_1) [inst : CommMonoid M] (n : ℕ) (ζ ζ' : ↥(rootsOfUnity n Mˣ)), ⟨↑↑(ζ * ζ'), ⋯⟩ = ⟨↑↑ζ, ⋯⟩ * ⟨↑↑ζ', ⋯⟩ | null | false |
WithLp.toLp_fst | Mathlib.Analysis.Normed.Lp.ProdLp | ∀ {p : ENNReal} {α : Type u_2} {β : Type u_3} (x : α × β), (WithLp.toLp p x).fst = x.1 | null | true |
Fintype.prod_eq_mul | Mathlib.Data.Fintype.BigOperators | ∀ {α : Type u_1} {M : Type u_4} [inst : Fintype α] [inst_1 : CommMonoid M] {f : α → M} (a b : α),
a ≠ b → (∀ (x : α), x ≠ a ∧ x ≠ b → f x = 1) → ∏ x, f x = f a * f b | null | true |
_private.Lean.Meta.MethodSpecs.0.Lean.rewriteThm | Lean.Meta.MethodSpecs | Lean.Meta.Simp.Context → Lean.Meta.Simprocs → Lean.Name → Lean.Name → Lean.MetaM Unit | null | true |
Nat.reducePow | Lean.Meta.Tactic.Simp.BuiltinSimprocs.Nat | Lean.Meta.Simp.DSimproc | null | true |
geom_sum_Ico_mul_neg | Mathlib.Algebra.Ring.GeomSum | ∀ {R : Type u_1} [inst : Ring R] (x : R) {m n : ℕ}, m ≤ n → (∑ i ∈ Finset.Ico m n, x ^ i) * (1 - x) = x ^ m - x ^ n | null | true |
_private.Mathlib.FieldTheory.RatFunc.Luroth.0.RatFunc.Luroth.Φ_coeff_generatorIndex_ne_zero | Mathlib.FieldTheory.RatFunc.Luroth | ∀ {K : Type u_1} [inst : Field K] {E : IntermediateField K (RatFunc K)} (h : E ≠ ⊥),
(RatFunc.Luroth.Φ✝ E).coeff (RatFunc.Luroth.generatorIndex✝ h) ≠ 0 | null | true |
CategoryTheory.GrothendieckTopology.Point.toPresheafFiberOfIsCofiltered_naturality_assoc | Mathlib.CategoryTheory.Sites.Point.OfIsCofiltered | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.LocallySmall.{w, v, u} C]
{N : Type u'} [inst_2 : CategoryTheory.Category.{v', u'} N] (p : CategoryTheory.Functor N C)
[inst_3 : CategoryTheory.InitiallySmall N] {J : CategoryTheory.GrothendieckTopology C}
[inst_4 : CategoryTheory.I... | null | true |
Multiset.mem_filterMap | Mathlib.Data.Multiset.Filter | ∀ {α : Type u_1} {β : Type v} (f : α → Option β) (s : Multiset α) {b : β},
b ∈ Multiset.filterMap f s ↔ ∃ a ∈ s, f a = some b | null | true |
Algebra.RingHom.adjoinAlgebraMapEquiv._proof_1 | Mathlib.RingTheory.Adjoin.Singleton | ∀ {A : Type u_2} {B : Type u_1} [inst : CommSemiring A] [inst_1 : CommSemiring B] [inst_2 : Algebra A B] (b : B)
(p : Polynomial A), (Polynomial.aeval b) p ∈ A[b] | null | false |
Lean.Lsp.instToJsonMessageType | Lean.Data.Lsp.Window | Lean.ToJson Lean.Lsp.MessageType | null | true |
Std.Async.IO.AsyncWrite.write | Std.Async.IO | {α β : Type} → [self : Std.Async.IO.AsyncWrite α β] → α → β → Std.Async.Async Unit | null | true |
Polynomial.coeff_ofFinsupp | Mathlib.Algebra.Polynomial.Basic | ∀ {R : Type u} [inst : Semiring R] (p : AddMonoidAlgebra R ℕ), { toFinsupp := p }.coeff = p.coeff | null | true |
_private.Mathlib.AlgebraicTopology.SimplicialSet.KanComplex.MulStruct.0.SSet.PtSimplex.MulStruct.assocAux.α_castSucc_succ_succ._proof_1_1 | Mathlib.AlgebraicTopology.SimplicialSet.KanComplex.MulStruct | ∀ {n : ℕ} {i : Fin n}, ¬i.castSucc.succ.succ = i.castSucc.castSucc.castSucc | null | false |
AdjoinRoot.equiv'._proof_2 | Mathlib.RingTheory.AdjoinRoot | ∀ {R : Type u_2} {S : Type u_1} [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S] (g : Polynomial R)
(pb : PowerBasis R S) (h₁ : (Polynomial.aeval (AdjoinRoot.root g)) (minpoly R pb.gen) = 0)
(h₂ : (Polynomial.aeval pb.gen) g = 0) (x : S),
(AdjoinRoot.liftAlgHom g (Algebra.ofId R S) pb.gen h₂) ((pb... | null | false |
Localization.subalgebra.isFractionRing | Mathlib.RingTheory.Localization.AsSubring | ∀ {A : Type u_1} (K : Type u_2) [inst : CommRing A] (S : Submonoid A) (hS : S ≤ nonZeroDivisors A) [inst_1 : CommRing K]
[inst_2 : Algebra A K] [inst_3 : IsFractionRing A K], IsFractionRing (↥(Localization.subalgebra K S hS)) K | null | true |
Int16.toInt64_lt._simp_1 | Init.Data.SInt.Lemmas | ∀ {a b : Int16}, (a.toInt64 < b.toInt64) = (a < b) | null | false |
Ideal.Quotient.stabilizerHomSurjectiveAuxFunctor | Mathlib.RingTheory.Invariant.Profinite | {A : Type u_1} →
{B : Type u_2} →
[inst : CommRing A] →
[inst_1 : CommRing B] →
[inst_2 : Algebra A B] →
{G : Type u} →
[inst_3 : Group G] →
[inst_4 : MulSemiringAction G B] →
[SMulCommClass G A B] →
[inst_6 : TopologicalSpace G] ... | (Implementation)
The functor taking an open normal subgroup `N ≤ G` to the set of lifts of `σ` in `G ⧸ N`.
We will show that its inverse limit is nonempty to conclude that there exists a lift in `G`. | true |
SetLike.Homogeneous.smul | Mathlib.Algebra.DirectSum.Internal | ∀ {ι : Type u_1} {S : Type u_3} {R : Type u_4} [inst : CommSemiring S] [inst_1 : Semiring R] [inst_2 : Algebra S R]
{A : ι → Submodule S R} {s : S} {r : R}, SetLike.IsHomogeneousElem A r → SetLike.IsHomogeneousElem A (s • r) | null | true |
WithBot.sumHomeomorph._proof_4 | Mathlib.Topology.Order.WithTop | ∀ (ι : Type u_1) [inst : LinearOrder ι] [inst_1 : OrderBot ι] (x : WithBot ι),
(fun x =>
match x with
| Sum.inl i => ↑i
| Sum.inr PUnit.unit => ⊥)
((fun x => if h : x = ⊥ then Sum.inr () else Sum.inl x.unbotA) x) =
x | null | false |
jacobiTheta₂'_term | Mathlib.NumberTheory.ModularForms.JacobiTheta.TwoVariable | ℤ → ℂ → ℂ → ℂ | Summand in the series for the `z`-derivative of the Jacobi theta function. | true |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.Const.getD_eq_fallback_of_contains_eq_false._simp_1_1 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {x : Ord α} {x_1 : BEq α} [Std.LawfulBEqOrd α] {a b : α}, (compare a b = Ordering.eq) = ((a == b) = true) | null | false |
HomologicalComplex.homotopyCofiber.mapHomologicalComplexObjXIso | Mathlib.Algebra.Homology.HomotopyCofiber | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
[inst_1 : CategoryTheory.Preadditive C] →
{ι : Type u_2} →
{c : ComplexShape ι} →
{F G : HomologicalComplex C c} →
(φ : F ⟶ G) →
[inst_2 : HomologicalComplex.HasHomotopyCofiber φ] →
[... | Auxiliary definition for `mapHomologicalComplexObjIso`. | true |
CategoryTheory.AB5StarOfSize.rec | Mathlib.CategoryTheory.Abelian.GrothendieckAxioms.Basic | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
[inst_1 : CategoryTheory.Limits.HasCofilteredLimitsOfSize.{w, w', v, u} C] →
{motive : CategoryTheory.AB5StarOfSize.{w, w', v, u} C → Sort u_1} →
((ofShape :
∀ (J : Type w') [inst_2 : CategoryTheory.Category.{w, w'} J] [inst_3 ... | null | false |
VectorBundleCore.trivializationAt_coordChange_eq | Mathlib.Topology.VectorBundle.Basic | ∀ {R : Type u_1} {B : Type u_2} {F : Type u_3} [inst : NontriviallyNormedField R] [inst_1 : NormedAddCommGroup F]
[inst_2 : NormedSpace R F] [inst_3 : TopologicalSpace B] {ι : Type u_5} (Z : VectorBundleCore R B F ι) {b₀ b₁ b : B},
b ∈ (trivializationAt F Z.Fiber b₀).baseSet ∩ (trivializationAt F Z.Fiber b₁).baseSe... | null | true |
Aesop.EqualUpToIds.MVarValue._sizeOf_inst | Aesop.Util.EqualUpToIds | SizeOf Aesop.EqualUpToIds.MVarValue | null | false |
Std.Net.InterfaceAddress.address | Std.Net.Addr | Std.Net.InterfaceAddress → Std.Net.IPAddr | The IP address assigned to the interface.
| true |
Lean.Doc.elabInline._unsafe_rec | Lean.Elab.DocString | Lean.TSyntax `inline → Lean.Doc.DocM (Lean.Doc.Inline Lean.ElabInline) | null | false |
AdjoinRoot.algEquivOfAssociated_symm | Mathlib.RingTheory.AdjoinRoot | ∀ {R : Type u_1} {S : Type u_2} [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S] (f g : Polynomial S)
(hfg : Associated f g), (AdjoinRoot.algEquivOfAssociated R f g hfg).symm = AdjoinRoot.algEquivOfAssociated R g f ⋯ | null | true |
Lean.MonadTrace.getTraceState | Lean.Util.Trace | {m : Type → Type} → [self : Lean.MonadTrace m] → m Lean.TraceState | null | true |
CFC.pow_eq_zero_iff | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Unital | ∀ (R : Type u_1) {A : Type u_2} {p : A → Prop} [inst : Semifield R] [inst_1 : StarRing R] [inst_2 : MetricSpace R]
[inst_3 : IsTopologicalSemiring R] [inst_4 : ContinuousStar R] [inst_5 : TopologicalSpace A] [inst_6 : Ring A]
[inst_7 : StarRing A] [inst_8 : Algebra R A] [ContinuousFunctionalCalculus R A p] (a : A) ... | null | true |
ConditionallyCompleteLinearOrder.toSuccOrder | Mathlib.Order.SuccPred.CompleteLinearOrder | {α : Type u_2} → [inst : ConditionallyCompleteLinearOrder α] → [WellFoundedLT α] → SuccOrder α | Every conditionally complete linear order with well-founded `<` is a successor order, by setting
the successor of an element to be the infimum of all larger elements. | true |
Std.TreeSet.Raw.min!_eq_default | Std.Data.TreeSet.Raw.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t : Std.TreeSet.Raw α cmp} [Std.TransCmp cmp] [inst : Inhabited α],
t.WF → t.isEmpty = true → t.min! = default | null | true |
IO.FS.createDir | Init.System.IO | System.FilePath → IO Unit | Creates a directory at the specified path. The parent directory must already exist.
Throws an exception if the directory cannot be created.
| true |
_private.Mathlib.MeasureTheory.OuterMeasure.Caratheodory.0.MeasureTheory.OuterMeasure.isCaratheodory_iUnion_lt.match_1_1 | Mathlib.MeasureTheory.OuterMeasure.Caratheodory | ∀ {α : Type u_1} (m : MeasureTheory.OuterMeasure α) {s : ℕ → Set α}
(motive : (x : ℕ) → (∀ i < x, m.IsCaratheodory (s i)) → Prop) (x : ℕ) (x_1 : ∀ i < x, m.IsCaratheodory (s i)),
(∀ (x : ∀ i < 0, m.IsCaratheodory (s i)), motive 0 x) →
(∀ (n : ℕ) (h : ∀ i < n + 1, m.IsCaratheodory (s i)), motive n.succ h) → moti... | null | false |
_private.Mathlib.MeasureTheory.Integral.SetToL1.Function.0.MeasureTheory.setToFun_mono_left'._simp_1_3 | Mathlib.MeasureTheory.Integral.SetToL1.Function | ∀ {α : Type u_1} [inst : Preorder α] {a : α}, (a ≤ a) = True | null | false |
_private.Mathlib.Geometry.Euclidean.Congruence.0.EuclideanGeometry.angle_angle_side._proof_1_2 | Mathlib.Geometry.Euclidean.Congruence | ∀ {V₁ : Type u_3} {V₂ : Type u_1} {P₁ : Type u_4} {P₂ : Type u_2} [inst : NormedAddCommGroup V₁]
[inst_1 : NormedAddCommGroup V₂] [inst_2 : InnerProductSpace ℝ V₁] [inst_3 : InnerProductSpace ℝ V₂]
[inst_4 : MetricSpace P₁] [inst_5 : MetricSpace P₂] [inst_6 : NormedAddTorsor V₁ P₁] [inst_7 : NormedAddTorsor V₂ P₂]
... | null | false |
_private.Lean.Util.LeanOptions.0.Lean.LeanOptions.toOptions.match_1 | Lean.Util.LeanOptions | (motive : Lean.Name × Lean.LeanOptionValue → Sort u_1) →
(x : Lean.Name × Lean.LeanOptionValue) →
((name : Lean.Name) → (optionValue : Lean.LeanOptionValue) → motive (name, optionValue)) → motive x | null | false |
Std.ExtDHashMap.Const.getKey!_filterMap | Std.Data.ExtDHashMap.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {β : Type v} {γ : Type w} {m : Std.ExtDHashMap α fun x => β}
[inst : EquivBEq α] [inst_1 : LawfulHashable α] [inst_2 : Inhabited α] {f : α → β → Option γ} {k : α},
(Std.ExtDHashMap.filterMap f m).getKey! k =
((m.getKey? k).pfilter fun x_2 h' => (f x_2 (Std.ExtDHashM... | null | true |
BoundedContinuousFunction.coeFn_toLp | Mathlib.MeasureTheory.Function.LpSpace.ContinuousFunctions | ∀ {α : Type u_1} {E : Type u_2} {m0 : MeasurableSpace α} (p : ENNReal) (μ : MeasureTheory.Measure α)
[inst : TopologicalSpace α] [inst_1 : BorelSpace α] [inst_2 : NormedAddCommGroup E]
[inst_3 : SecondCountableTopologyEither α E] [inst_4 : MeasureTheory.IsFiniteMeasure μ] (𝕜 : Type u_3)
[inst_5 : Fact (1 ≤ p)] [... | null | true |
Cauchy.eq_1 | Mathlib.Topology.UniformSpace.Cauchy | ∀ {α : Type u} [uniformSpace : UniformSpace α] (f : Filter α), Cauchy f = (f.NeBot ∧ f ×ˢ f ≤ uniformity α) | null | true |
CategoryTheory.Over.postAdjunctionRight._proof_6 | Mathlib.CategoryTheory.Comma.Over.Basic | ∀ {T : Type u_4} [inst : CategoryTheory.Category.{u_3, u_4} T] {D : Type u_2}
[inst_1 : CategoryTheory.Category.{u_1, u_2} D] {Y : D} {F : CategoryTheory.Functor T D}
{G : CategoryTheory.Functor D T} (a : F ⊣ G) (A : CategoryTheory.Over ((CategoryTheory.Functor.id D).obj Y)),
CategoryTheory.CategoryStruct.comp (a... | null | false |
RBTree.RBSet.find?_insert_of_eq | Batteries.Recycling.RBTree.Lemmas | ∀ {α : Type u_1} {cmp : α → α → Ordering} {v' v : α} [Std.TransCmp cmp] (t : RBTree.RBSet α cmp),
cmp v' v = Ordering.eq → (t.insert v).find? v' = some v | null | true |
Vector.mapFinIdx_append._proof_4 | Init.Data.Vector.MapIdx | ∀ {n m : ℕ}, ∀ i < m, i + n < n + m | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.