name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
_private.Mathlib.Algebra.Algebra.Subalgebra.Basic.0.AlgHom.rangeRestrict_surjective.match_1_1 | Mathlib.Algebra.Algebra.Subalgebra.Basic | ∀ {R : Type u_2} {A : Type u_3} {B : Type u_1} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A]
[inst_3 : Semiring B] [inst_4 : Algebra R B] (f : A →ₐ[R] B) (_y : B) (motive : _y ∈ f.range → Prop)
(hy : _y ∈ f.range), (∀ (x : A) (hx : f.toRingHom x = _y), motive ⋯) → motive hy | null | false |
_private.Mathlib.Algebra.Order.Interval.Set.Instances.0.Set.Ioo.one_sub_mem._simp_1_2 | Mathlib.Algebra.Order.Interval.Set.Instances | ∀ {α : Type u} [inst : AddGroup α] [inst_1 : LT α] [AddRightStrictMono α] {a b : α}, (0 < a - b) = (b < a) | null | false |
_private.Mathlib.Data.Nat.Choose.Multinomial.0.Nat.multinomial_congr_of_sdiff._proof_1_1 | Mathlib.Data.Nat.Choose.Multinomial | ∀ {α : Type u_1} [inst : DecidableEq α] {f : α → ℕ} {s t : Finset α}, s ⊆ t → ∀ a ∈ s \ t, f a = 0 | null | false |
Units.inv_eq_val_inv | Mathlib.Algebra.Group.Units.Defs | ∀ {α : Type u} [inst : Monoid α] (a : αˣ), a.inv = ↑a⁻¹ | null | true |
MeasureTheory.L2.instInnerSubtypeAEEqFunMemAddSubgroupLpOfNatENNReal | Mathlib.MeasureTheory.Function.L2Space | {α : Type u_1} →
{E : Type u_2} →
{𝕜 : Type u_4} →
[inst : RCLike 𝕜] →
{m : MeasurableSpace α} →
{μ : MeasureTheory.Measure α} →
[inst_1 : NormedAddCommGroup E] → [InnerProductSpace 𝕜 E] → Inner 𝕜 ↥(MeasureTheory.Lp E 2 μ) | null | true |
groupCohomology.mapIso._proof_5 | Mathlib.RepresentationTheory.Homological.GroupCohomology.Functoriality | ∀ {k : Type u_1} [inst : CommRing k], RingHomInvPair (RingHom.id k) (RingHom.id k) | null | false |
Nat.eq_two_pow_or_exists_odd_prime_and_dvd | Mathlib.Data.Nat.Factors | ∀ (n : ℕ), (∃ k, n = 2 ^ k) ∨ ∃ p, Nat.Prime p ∧ p ∣ n ∧ Odd p | null | true |
_private.Mathlib.Topology.EMetricSpace.BoundedVariation.0.BoundedVariationOn.tendsto_eVariationOn_Icc_zero_left._simp_1_2 | Mathlib.Topology.EMetricSpace.BoundedVariation | ∀ {α : Type u} [inst : LE α] [inst_1 : OrderBot α] {a : α}, (⊥ ≤ a) = True | null | false |
_private.Mathlib.MeasureTheory.Group.Arithmetic.0.measurable_div_const'._simp_1_1 | Mathlib.MeasureTheory.Group.Arithmetic | ∀ {M : Type u_2} {inst : MeasurableSpace M} {inst_1 : Mul M} [self : MeasurableMul M] (c : M),
(Measurable fun x => x * c) = True | null | false |
Continuous.enorm | Mathlib.Analysis.Normed.Group.Continuity | ∀ {E : Type u_7} [inst : TopologicalSpace E] [inst_1 : ContinuousENorm E] {X : Type u_8} [inst_2 : TopologicalSpace X]
{f : X → E}, Continuous f → Continuous fun x => ‖f x‖ₑ | null | true |
CompleteLat.Iso.mk | Mathlib.Order.Category.CompleteLat | {α β : CompleteLat} → ↑α ≃o ↑β → (α ≅ β) | Constructs an isomorphism of complete lattices from an order isomorphism between them. | true |
CategoryTheory.EnrichedFunctor.comp_map | Mathlib.CategoryTheory.Enriched.Basic | ∀ (V : Type v) [inst : CategoryTheory.Category.{w, v} V] [inst_1 : CategoryTheory.MonoidalCategory V] {C : Type u₁}
{D : Type u₂} {E : Type u₃} [inst_2 : CategoryTheory.EnrichedCategory V C]
[inst_3 : CategoryTheory.EnrichedCategory V D] [inst_4 : CategoryTheory.EnrichedCategory V E]
(F : CategoryTheory.EnrichedF... | null | true |
tendsto_atTop_iSup | Mathlib.Topology.Order.MonotoneConvergence | ∀ {α : Type u_1} {ι : Type u_3} [inst : Preorder ι] [inst_1 : TopologicalSpace α] [inst_2 : CompleteLattice α]
[SupConvergenceClass α] {f : ι → α}, Monotone f → Filter.Tendsto f Filter.atTop (nhds (⨆ i, f i)) | null | true |
_private.Mathlib.NumberTheory.FLT.Three.0.FermatLastTheoremForThreeGen.Solution.lambda_sq_not_dvd_a_add_eta_sq_mul_b._simp_1_3 | Mathlib.NumberTheory.FLT.Three | ∀ {M₀ : Type u_1} [inst : MulZeroClass M₀] [IsLeftCancelMulZero M₀] {a b c : M₀}, (a * b = a * c) = (b = c ∨ a = 0) | null | false |
Nucleus.coe_toInfHom | Mathlib.Order.Nucleus | ∀ {X : Type u_1} [inst : SemilatticeInf X] (n : Nucleus X), ⇑n.toInfHom = ⇑n | null | true |
ImplicitFunctionData.hasStrictFDerivAt | Mathlib.Analysis.Calculus.Implicit | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] [inst_3 : CompleteSpace E] {F : Type u_3} [inst_4 : NormedAddCommGroup F]
[inst_5 : NormedSpace 𝕜 F] [inst_6 : CompleteSpace F] {G : Type u_4} [inst_7 : NormedAddCommGroup G]
[inst_8 :... | null | true |
SchwartzMap.toLp.eq_1 | Mathlib.Analysis.Distribution.SchwartzSpace.Basic | ∀ {E : Type u_5} {F : Type u_6} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] [inst_2 : NormedAddCommGroup F]
[inst_3 : NormedSpace ℝ F] [inst_4 : MeasurableSpace E] [inst_5 : OpensMeasurableSpace E]
[inst_6 : SecondCountableTopologyEither E F] (f : SchwartzMap E F) (p : ENNReal) (μ : MeasureTheory.Measu... | null | true |
List.IsChain.induction | Mathlib.Data.List.Chain | ∀ {α : Type u_1} {r : α → α → Prop} (p : α → Prop) (l : List α),
List.IsChain r l → (∀ ⦃x y : α⦄, r x y → p x → p y) → (∀ (lne : l ≠ []), p (l.head lne)) → ∀ i ∈ l, p i | Given a chain `l`, such that a predicate `p` holds for its head if it is nonempty,
and if `r x y → p x → p y`, then the predicate is true everywhere in the chain.
That is, we can propagate the predicate down the chain.
| true |
Ideal.inertiaDeg_tower | Mathlib.RingTheory.RamificationInertia.Inertia | ∀ {R : Type u_1} {S : Type u_2} {T : Type u_3} [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : CommRing T]
[inst_3 : Algebra R S] [inst_4 : Algebra R T] [inst_5 : Algebra S T] [IsScalarTower R S T] (q : Ideal S) (r : Ideal T)
[r.LiesOver q], r.inertiaDeg R = q.inertiaDeg R * r.inertiaDeg S | null | true |
_private.Std.Data.Iterators.Lemmas.Combinators.Zip.0.Std.Iter.toList_zip_of_finite_right._simp_1_2 | Std.Data.Iterators.Lemmas.Combinators.Zip | ∀ {α : Type u_1} {a : α} {p : Prop} {x : Decidable p} {b : Option α},
((if p then b else none) = some a) = (p ∧ b = some a) | null | false |
_private.Mathlib.Topology.Algebra.InfiniteSum.SummationFilter.0.SummationFilter.conditional_filter_eq_map_range._proof_1_6 | Mathlib.Topology.Algebra.InfiniteSum.SummationFilter | ∀ (a b : ℕ), a + 1 ≤ b → a ≤ b + 1 | null | false |
SchwartzMap.instAddCommGroup._proof_3 | Mathlib.Analysis.Distribution.SchwartzSpace.Basic | ∀ {E : Type u_1} {F : Type u_2} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] [inst_2 : NormedAddCommGroup F]
[inst_3 : NormedSpace ℝ F] (a : SchwartzMap E F), a + 0 = a | null | false |
CategoryTheory.Functor.relativelyRepresentable.symmetryIso_inv | Mathlib.CategoryTheory.MorphismProperty.Representable | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
{F : CategoryTheory.Functor C D} {Y : D} {b : C} {f' : F.obj b ⟶ Y} (hf' : F.relativelyRepresentable f') {a : C}
{g : F.obj a ⟶ Y} (hg : F.relativelyRepresentable g) [inst_2 : F.Full] [inst_3 : F.... | null | true |
AddGroupExtension._sizeOf_inst | Mathlib.GroupTheory.GroupExtension.Defs | (N : Type u_1) →
(E : Type u_2) →
(G : Type u_3) →
{inst : AddGroup N} →
{inst_1 : AddGroup E} →
{inst_2 : AddGroup G} → [SizeOf N] → [SizeOf E] → [SizeOf G] → SizeOf (AddGroupExtension N E G) | null | false |
_private.Std.Data.Iterators.Combinators.Monadic.Zip.0.Std.Iterators.Types.Zip.instFinitenessRelation₂.match_3 | Std.Data.Iterators.Combinators.Monadic.Zip | ∀ {m : Type u_1 → Type u_2} {α₁ β₁ : Type u_1} [inst : Std.Iterator α₁ m β₁]
(motive : Option { out // ∃ it, it.IsPlausibleOutput out } × Std.IterM.TerminationMeasures.Productive α₁ m → Prop)
(x : Option { out // ∃ it, it.IsPlausibleOutput out } × Std.IterM.TerminationMeasures.Productive α₁ m),
(∀ (a : Option { o... | null | false |
LinearMap.quotKerEquivOfSurjective_symm_apply | Mathlib.LinearAlgebra.Isomorphisms | ∀ {R : Type u_1} {M : Type u_2} {M₂ : Type u_3} [inst : Ring R] [inst_1 : AddCommGroup M] [inst_2 : AddCommGroup M₂]
[inst_3 : Module R M] [inst_4 : Module R M₂] (f : M →ₗ[R] M₂) (hf : Function.Surjective ⇑f) (x : M),
(f.quotKerEquivOfSurjective hf).symm (f x) = Submodule.Quotient.mk x | null | true |
Quiver.IsSStronglyConnected | Mathlib.Combinatorics.Quiver.ConnectedComponent | (V : Type u_2) → [Quiver V] → Prop | Positive strong connectivity: every ordered pair of vertices is joined by a directed path
of positive length. | true |
_private.Mathlib.FieldTheory.SeparablyGenerated.0.exists_isTranscendenceBasis_and_isSeparable_of_linearIndepOn_pow_of_adjoin_eq_top.match_1_1 | Mathlib.FieldTheory.SeparablyGenerated | ∀ {k : Type u_2} {K : Type u_3} {ι : Type u_1} [inst : Field k] [inst_1 : Field K] [inst_2 : Algebra k K] {a : ι → K}
(motive :
(∃ i, (IsTranscendenceBasis k fun j => a ↑j) ∧ IsSeparable (↥(IntermediateField.adjoin k (a '' {i}ᶜ))) (a i)) →
Prop)
(x : ∃ i, (IsTranscendenceBasis k fun j => a ↑j) ∧ IsSeparab... | null | false |
StieltjesFunction.zero_apply | Mathlib.MeasureTheory.Measure.Stieltjes | ∀ {R : Type u_1} [inst : LinearOrder R] [inst_1 : TopologicalSpace R] (x : R), ↑0 x = 0 | null | true |
MulAut.instInhabited.eq_1 | Mathlib.Algebra.Group.End | ∀ (M : Type u_2) [inst : Mul M], MulAut.instInhabited M = { default := 1 } | null | true |
subsetInfSet._proof_1 | Mathlib.Order.CompleteLatticeIntervals | ∀ {α : Type u_1} (s : Set α) [inst : Preorder α] [inst_1 : InfSet α] (t : Set ↑s),
t.Nonempty ∧ BddBelow t ∧ sInf (Subtype.val '' t) ∈ s → sInf (Subtype.val '' t) ∈ s | null | false |
CategoryTheory.Grothendieck.comp.eq_1 | Mathlib.CategoryTheory.Grothendieck | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {F : CategoryTheory.Functor C CategoryTheory.Cat}
{X Y Z : CategoryTheory.Grothendieck F} (f : X.Hom Y) (g : Y.Hom Z),
CategoryTheory.Grothendieck.comp f g =
{ base := CategoryTheory.CategoryStruct.comp f.base g.base,
fiber :=
CategoryTheory... | null | true |
derivationQuotKerSq._proof_4 | Mathlib.RingTheory.Smooth.Kaehler | ∀ (R : Type u_3) (P : Type u_1) (S : Type u_2) [inst : CommRing R] [inst_1 : CommRing P] [inst_2 : CommRing S]
[inst_3 : Algebra R P] [inst_4 : Algebra P S] [inst_5 : Algebra R S] [inst_6 : IsScalarTower R P S],
LinearMap.CompatibleSMul Ω[P⁄R] (TensorProduct P S Ω[P⁄R]) R P | null | false |
_private.Init.Data.List.Erase.0.List.eraseP_filterMap.match_1.eq_2 | Init.Data.List.Erase | ∀ {β : Type u_1} (motive : Option β → Sort u_2) (h_1 : (y : β) → motive (some y)) (h_2 : Unit → motive none),
(match none with
| some y => h_1 y
| none => h_2 ()) =
h_2 () | null | true |
Lean.Meta.Grind.Arith.Linear.instMonadGetStructLinearM | Lean.Meta.Tactic.Grind.Arith.Linear.LinearM | Lean.Meta.Grind.Arith.Linear.MonadGetStruct Lean.Meta.Grind.Arith.Linear.LinearM | null | true |
MulOpposite.instAdd | Mathlib.Algebra.Opposites | {α : Type u_1} → [Add α] → Add αᵐᵒᵖ | null | true |
ContinuousOn.prodMk | Mathlib.Topology.ContinuousOn | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} [inst : TopologicalSpace α] [inst_1 : TopologicalSpace β]
[inst_2 : TopologicalSpace γ] {f : α → β} {g : α → γ} {s : Set α},
ContinuousOn f s → ContinuousOn g s → ContinuousOn (fun x => (f x, g x)) s | null | true |
PrincipalSeg.ofElement | Mathlib.Order.InitialSeg | {α : Type u_4} → (r : α → α → Prop) → (a : α) → PrincipalSeg (Subrel r fun x => r x a) r | Any element of a well order yields a principal segment. | true |
_private.Mathlib.Geometry.Euclidean.Sphere.OrthRadius.0.EuclideanGeometry.Sphere.inter_orthRadius_eq_empty_iff._simp_1_5 | Mathlib.Geometry.Euclidean.Sphere.OrthRadius | ∀ {a : Prop}, (¬¬a) = a | null | false |
Order.le_pred_iff._simp_1 | Mathlib.Order.SuccPred.Basic | ∀ {α : Type u_1} [inst : Preorder α] [inst_1 : PredOrder α] {a b : α} [NoMinOrder α], (b ≤ Order.pred a) = (b < a) | null | false |
_private.Mathlib.RingTheory.DedekindDomain.Ideal.Lemmas.0.IsDedekindDomain.quotientEquivPiOfProdEq._proof_3 | Mathlib.RingTheory.DedekindDomain.Ideal.Lemmas | ∀ {R : Type u_1} [inst : CommRing R] {ι : Type u_2} (P : ι → Ideal R), (∀ (i : ι), Prime (P i)) → ∀ (i : ι), P i ≠ 0 | null | false |
AlgebraicGeometry.Scheme.Pullback.gluedLift._proof_2 | Mathlib.AlgebraicGeometry.Pullbacks | ∀ {X Y Z : AlgebraicGeometry.Scheme} (𝒰 : X.OpenCover) (f : X ⟶ Z) (g : Y ⟶ Z)
(s : CategoryTheory.Limits.PullbackCone f g) (i : (CategoryTheory.Precoverage.ZeroHypercover.pullback₁ s.fst 𝒰).I₀),
CategoryTheory.Limits.HasPullback s.fst (𝒰.f i) | null | false |
NumberField.instCommRingRingOfIntegers._proof_7 | Mathlib.NumberTheory.NumberField.Basic | ∀ (K : Type u_1) [inst : Field K] (a : NumberField.RingOfIntegers K), a + 0 = a | null | false |
PresheafOfModules.pushforward₀._proof_3 | Mathlib.Algebra.Category.ModuleCat.Presheaf.Pushforward | ∀ {C : Type u_5} [inst : CategoryTheory.Category.{u_6, u_5} C] {D : Type u_3}
[inst_1 : CategoryTheory.Category.{u_2, u_3} D] (F : CategoryTheory.Functor C D)
(R : CategoryTheory.Functor Dᵒᵖ RingCat) (X : PresheafOfModules R),
{ app := fun X_1 => (CategoryTheory.CategoryStruct.id X).app (F.op.obj X_1), naturality... | null | false |
AddSubgroup.distribSMulToLinearMap_injective_of_isTorsionFree | Mathlib.GroupTheory.IndexNSmul | ∀ {M : Type u_1} [inst : AddCommGroup M] [Module.IsTorsionFree ℤ M] {n : ℕ},
n ≠ 0 → Function.Injective ⇑(DistribSMul.toLinearMap ℤ M n) | On an additive group that is torsion-free as a `ℤ`-module, the linear map given by
multiplication by `n : ℕ` is injective (when `n ≠ 0`). | true |
CategoryTheory.Presieve.yonedaFamilyOfElements_fromCocone | Mathlib.CategoryTheory.Sites.SheafOfTypes | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{X : C} →
(R : CategoryTheory.Presieve X) →
(s : CategoryTheory.Limits.Cocone R.diagram) →
CategoryTheory.Presieve.FamilyOfElements (CategoryTheory.yoneda.obj s.pt) R | Construct a family of elements from a cocone. | true |
AffineSubspace.smul_vsub_vadd_mem | Mathlib.LinearAlgebra.AffineSpace.AffineSubspace.Defs | ∀ {k : Type u_1} {V : Type u_2} {P : Type u_3} [inst : Ring k] [inst_1 : AddCommGroup V] [inst_2 : Module k V]
[inst_3 : AddTorsor V P] (s : AffineSubspace k P) (c : k) {p₁ p₂ p₃ : P},
p₁ ∈ s → p₂ ∈ s → p₃ ∈ s → c • (p₁ -ᵥ p₂) +ᵥ p₃ ∈ s | null | true |
Std.Iterators.Types.Flatten.IsPlausibleStep.outerYield | Init.Data.Iterators.Combinators.Monadic.FlatMap | ∀ {α α₂ β : Type w} {m : Type w → Type w'} [inst : Std.Iterator α m (Std.IterM m β)] [inst_1 : Std.Iterator α₂ m β]
{it₁ it₁' : Std.IterM m (Std.IterM m β)} {it₂' : Std.IterM m β},
it₁.IsPlausibleStep (Std.IterStep.yield it₁' it₂') →
Std.Iterators.Types.Flatten.IsPlausibleStep { internalState := { it₁ := it₁, i... | null | true |
RelSeries.ctorIdx | Mathlib.Order.RelSeries | {α : Type u_1} → {r : SetRel α α} → RelSeries r → ℕ | null | false |
CategoryTheory.IsMonHom.one_hom._autoParam | Mathlib.CategoryTheory.Monoidal.Mon | Lean.Syntax | null | false |
RingCon.finsuppProd | Mathlib.RingTheory.Congruence.BigOperators | ∀ {ι : Type u_1} {β : Type u_2} {M : Type u_3} [inst : Add M] [inst_1 : CommMonoid M] [inst_2 : Zero β] (c : RingCon M)
(h h' : ι → β → M) {f g : ι →₀ β},
(∀ (i : ι), c (h i 0) 1) →
(∀ (i : ι), c (h' i 0) 1) → (∀ (i : ι), c (h i (f i)) (h' i (g i))) → c (f.prod h) (g.prod h') | null | true |
_private.Qq.ForLean.ToExpr.0.toExprLevel.match_1 | Qq.ForLean.ToExpr | (motive : Lean.Level → Sort u_1) →
(x : Lean.Level) →
(Unit → motive Lean.Level.zero) →
((l : Lean.Level) → motive l.succ) →
((l₁ l₂ : Lean.Level) → motive (l₁.max l₂)) →
((l₁ l₂ : Lean.Level) → motive (l₁.imax l₂)) →
((n : Lean.Name) → motive (Lean.Level.param n)) →
... | null | false |
SimpleGraph.instMax | Mathlib.Combinatorics.SimpleGraph.Basic | {V : Type u} → Max (SimpleGraph V) | The supremum of two graphs `x ⊔ y` has edges where either `x` or `y` have edges. | true |
DirectSum.liftRingHom._proof_3 | Mathlib.Algebra.DirectSum.Ring | ∀ {ι : Type u_1} [inst : DecidableEq ι] {A : ι → Type u_2} {R : Type u_3} [inst_1 : (i : ι) → AddCommMonoid (A i)]
[inst_2 : AddMonoid ι] [inst_3 : DirectSum.GSemiring A] [inst_4 : Semiring R]
(f :
{ f //
f GradedMonoid.GOne.one = 1 ∧ ∀ {i j : ι} (ai : A i) (aj : A j), f (GradedMonoid.GMul.mul ai aj) = f ... | null | false |
_private.Mathlib.MeasureTheory.Measure.Haar.NormedSpace.0.MeasureTheory.Measure.setIntegral_comp_smul._simp_1_1 | Mathlib.MeasureTheory.Measure.Haar.NormedSpace | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} {f : α → β} {g : β → γ} {s : Set γ}, f ⁻¹' g ⁻¹' s = g ∘ f ⁻¹' s | null | false |
Rep.Hom.noConfusionType | Mathlib.RepresentationTheory.Rep.Basic | Sort u_1 →
{k : Type u} →
{G : Type v} →
[inst : Semiring k] →
[inst_1 : Monoid G] →
{A B : Rep.{w, u, v} k G} →
A.Hom B →
{k' : Type u} →
{G' : Type v} →
[inst' : Semiring k'] → [inst'_1 : Monoid G'] → {A' B' : Rep.{w, u, v} k' G... | null | false |
_private.Mathlib.RingTheory.PowerSeries.NoZeroDivisors.0.PowerSeries.instNoZeroDivisors._simp_1 | Mathlib.RingTheory.PowerSeries.NoZeroDivisors | ∀ {R : Type u_1} [inst : Semiring R] {φ : PowerSeries R}, (φ = 0) = (φ.order = ⊤) | null | false |
TopologicalSpace.IsTopologicalBasis.of_isOpen_of_subset | Mathlib.Topology.Bases | ∀ {α : Type u} [t : TopologicalSpace α] {s s' : Set (Set α)},
(∀ u ∈ s', IsOpen u) → TopologicalSpace.IsTopologicalBasis s → s ⊆ s' → TopologicalSpace.IsTopologicalBasis s' | null | true |
Lean.Parser.Tactic.Grind.grindAdmit | Init.Grind.Interactive | Lean.ParserDescr | `admit` is a synonym for `sorry`. | true |
_private.Std.Time.Date.ValidDate.0.Std.Time.ValidDate.ofOrdinal._proof_2 | Std.Time.Date.ValidDate | ∀ {leap : Bool} (ordinal : Std.Time.Day.Ordinal.OfYear leap) (idx : Std.Time.Month.Ordinal) (acc : ℤ),
¬acc + ↑(Std.Time.Month.Ordinal.days leap idx) - acc = ↑(Std.Time.Month.Ordinal.days leap idx) → False | null | false |
CategoryTheory.Limits.HasCountableCoproducts.casesOn | Mathlib.CategoryTheory.Limits.Shapes.Countable | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
{motive : CategoryTheory.Limits.HasCountableCoproducts C → Sort u} →
(t : CategoryTheory.Limits.HasCountableCoproducts C) →
((out : ∀ (J : Type) [Countable J], CategoryTheory.Limits.HasCoproductsOfShape J C) → motive ⋯) → motive t | null | false |
ContIntertwiningMap.mapInvariantsOfRes_apply | Mathlib.RepresentationTheory.Continuous.Basic | ∀ {R : Type u_1} {G : Type u_2} {V : Type u_3} {W : Type u_4} [inst : Monoid G] [inst_1 : Ring R]
[inst_2 : AddCommGroup V] [inst_3 : TopologicalSpace V] [inst_4 : IsTopologicalAddGroup V] [inst_5 : Module R V]
[inst_6 : AddCommGroup W] [inst_7 : TopologicalSpace W] [inst_8 : IsTopologicalAddGroup W] [inst_9 : Modu... | null | true |
_private.Mathlib.Geometry.Manifold.Instances.Real.0.modelWithCornersEuclideanHalfSpace._simp_6 | Mathlib.Geometry.Manifold.Instances.Real | ∀ (𝕜 : Type u_3) [h : RCLike 𝕜], IsRCLikeNormedField 𝕜 = True | null | false |
Multiset.prod_lt_prod | Mathlib.Algebra.Order.BigOperators.Group.Multiset | ∀ {ι : Type u_1} {α : Type u_2} [inst : CommMonoid α] [inst_1 : Preorder α] [IsOrderedCancelMonoid α]
[MulLeftStrictMono α] {s : Multiset ι} {f g : ι → α},
(∀ i ∈ s, f i ≤ g i) → (∃ i ∈ s, f i < g i) → (Multiset.map f s).prod < (Multiset.map g s).prod | null | true |
TrivSqZeroExt.invertibleFstOfInvertible._proof_2 | Mathlib.Algebra.TrivSqZeroExt.Basic | ∀ {R : Type u_1} {M : Type u_2} [inst : AddCommGroup M] [inst_1 : Semiring R] [inst_2 : Module Rᵐᵒᵖ M]
[inst_3 : Module R M] (x : TrivSqZeroExt R M) [inst_4 : Invertible x], x.fst * (⅟x).fst = 1 | null | false |
PNat.natPred_eq_pred | Mathlib.Data.PNat.Defs | ∀ {n : ℕ} (h : 0 < n), PNat.natPred ⟨n, h⟩ = n.pred | null | true |
List.modify_succ_cons | Init.Data.List.Nat.Modify | ∀ {α : Type u_1} (f : α → α) (a : α) (l : List α) (i : ℕ), (a :: l).modify (i + 1) f = a :: l.modify i f | null | true |
Finset.card_le_of_interleaved | Mathlib.Data.Finset.Max | ∀ {α : Type u_1} [inst : LinearOrder α] {s t : Finset α},
(∀ x ∈ s, ∀ y ∈ s, x < y → (∀ z ∈ s, z ∉ Set.Ioo x y) → ∃ z ∈ t, x < z ∧ z < y) → s.card ≤ t.card + 1 | If finsets `s` and `t` are interleaved, then `Finset.card s ≤ Finset.card t + 1`. | true |
_private.Mathlib.MeasureTheory.Integral.IntervalIntegral.Slope.0.IntervalIntegrable.intervalIntegrable_slope._proof_1_3 | Mathlib.MeasureTheory.Integral.IntervalIntegral.Slope | ∀ {a b c : ℝ}, a ≤ b → 0 ≤ c → Set.uIcc a b ⊆ Set.uIcc a (b + c) | null | false |
DyckWord.toTree | Mathlib.Combinatorics.Enumerative.DyckWord | DyckWord → BinaryTree Unit | Convert a Dyck word to a binary rooted tree.
`f(0) = nil`. For a nonzero word find the `D` that matches the initial `U`,
which has index `p.firstReturn`, then let `x` be everything strictly between said `U` and `D`,
and `y` be everything strictly after said `D`. `p = x.nest + y` with `x, y` (possibly empty)
Dyck words... | true |
AddEquiv.ext | Mathlib.Algebra.Group.Equiv.Defs | ∀ {M : Type u_4} {N : Type u_5} [inst : Add M] [inst_1 : Add N] {f g : M ≃+ N}, (∀ (x : M), f x = g x) → f = g | Two additive isomorphisms agree if they are defined by the same underlying function. | true |
IsLocalMax.norm_add_self | Mathlib.Analysis.Normed.Module.Extr | ∀ {X : Type u_2} {E : Type u_3} [inst : SeminormedAddCommGroup E] [NormedSpace ℝ E] [inst_2 : TopologicalSpace X]
{f : X → E} {c : X}, IsLocalMax (norm ∘ f) c → IsLocalMax (fun x => ‖f x + f c‖) c | If `f : α → E` is a function such that `norm ∘ f` has a local maximum at a point `c`, then the
function `fun x => ‖f x + f c‖` has a local maximum at `c`. | true |
Lean.Meta.Grind.Arith.Cutsat.LeCnstr.mk._flat_ctor | Lean.Meta.Tactic.Grind.Arith.Cutsat.Types | Int.Internal.Linear.Poly → Lean.Meta.Grind.Arith.Cutsat.LeCnstrProof → Lean.Meta.Grind.Arith.Cutsat.LeCnstr | null | false |
_private.Mathlib.Analysis.Normed.Module.FiniteDimension.0.continuousOn_clm_apply._simp_1_2 | Mathlib.Analysis.Normed.Module.FiniteDimension | ∀ {α : Type u_3} {p : Prop} {q : α → Prop}, (p → ∀ (x : α), q x) = ∀ (x : α), p → q x | null | false |
Aesop.UnsafeQueue.instEmptyCollection | Aesop.Tree.UnsafeQueue | EmptyCollection Aesop.UnsafeQueue | null | true |
_private.Init.Data.List.MapIdx.0.Option.getD.match_1.splitter | Init.Data.List.MapIdx | {α : Type u_1} →
(motive : Option α → Sort u_2) → (opt : Option α) → ((x : α) → motive (some x)) → (Unit → motive none) → motive opt | null | true |
_private.Std.Data.ExtDHashMap.Basic.0.Std.ExtDHashMap.filter._proof_1 | Std.Data.ExtDHashMap.Basic | ∀ {α : Type u_1} {β : α → Type u_2} {x : BEq α} {x_1 : Hashable α} (f : (a : α) → β a → Bool) (m m' : Std.DHashMap α β),
m.Equiv m' → Std.ExtDHashMap.mk (Std.DHashMap.filter f m) = Std.ExtDHashMap.mk (Std.DHashMap.filter f m') | null | false |
MeasureTheory.SimpleFunc.bind._proof_2 | Mathlib.MeasureTheory.Function.SimpleFunc | ∀ {α : Type u_1} {β : Type u_3} {γ : Type u_2} [inst : MeasurableSpace α] (f : MeasureTheory.SimpleFunc α β)
(g : β → MeasureTheory.SimpleFunc α γ) (c : γ), MeasurableSet {a | (g (f a)) a = c} | null | false |
CategoryTheory.CommGrp.forget₂CommMon_map_hom | Mathlib.CategoryTheory.Monoidal.CommGrp_ | ∀ (C : Type u₁) [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.CartesianMonoidalCategory C]
[inst_2 : CategoryTheory.BraidedCategory C] {A B : CategoryTheory.CommGrp C} (f : A ⟶ B),
((CategoryTheory.CommGrp.forget₂CommMon C).map f).hom = f.hom.hom | null | true |
CategoryTheory.prodComonad._proof_10 | Mathlib.CategoryTheory.Monad.Products | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] (X : C)
[inst_1 : CategoryTheory.Limits.HasBinaryProducts C] (X_1 : C),
CategoryTheory.CategoryStruct.comp
({
app := fun x =>
CategoryTheory.Limits.prod.lift CategoryTheory.Limits.prod.fst
(CategoryTheory.... | null | false |
UInt64.toUInt8_or | Init.Data.UInt.Bitwise | ∀ (a b : UInt64), (a ||| b).toUInt8 = a.toUInt8 ||| b.toUInt8 | null | true |
_private.Lean.Meta.Tactic.Grind.Anchor.0.Lean.Meta.Grind.getAnchor.match_4 | Lean.Meta.Tactic.Grind.Anchor | (motive : Lean.Expr → Sort u_1) →
(e : Lean.Expr) →
((declName : Lean.Name) → (us : List Lean.Level) → motive (Lean.Expr.const declName us)) →
((fvarId : Lean.FVarId) → motive (Lean.Expr.fvar fvarId)) →
((data : Lean.MData) → (b : Lean.Expr) → motive (Lean.Expr.mdata data b)) →
((n : Lean.... | null | false |
_private.Lean.Compiler.LCNF.ToLCNF.0.Lean.Compiler.LCNF.ToLCNF.State._sizeOf_inst | Lean.Compiler.LCNF.ToLCNF | SizeOf Lean.Compiler.LCNF.ToLCNF.State✝ | null | false |
Lean.SCC.State.recOn | Lean.Util.SCC | {α : Type} →
[inst : BEq α] →
[inst_1 : Hashable α] →
{motive : Lean.SCC.State α → Sort u} →
(t : Lean.SCC.State α) →
((stack : List α) →
(nextIndex : ℕ) →
(data : Std.HashMap α Lean.SCC.Data) →
(sccs : List (List α)) →
mo... | null | false |
_private.Mathlib.RingTheory.Unramified.Finite.0.Algebra.FormallyUnramified.finite_of_free_aux._simp_1_6 | Mathlib.RingTheory.Unramified.Finite | ∀ {α : Type u_1} {M : Type u_4} [inst : Zero M] {f : α →₀ M} {a : α}, (a ∈ f.support) = (f a ≠ 0) | null | false |
FirstOrder.Language.LEquiv.symm_invLHom | Mathlib.ModelTheory.LanguageMap | ∀ {L : FirstOrder.Language} {L' : FirstOrder.Language} (e : L ≃ᴸ L'), e.symm.invLHom = e.toLHom | null | true |
CommGroup.toDistribLattice.eq_1 | Mathlib.Algebra.Order.Group.Lattice | ∀ (α : Type u_2) [inst : Lattice α] [inst_1 : CommGroup α] [inst_2 : MulLeftMono α],
CommGroup.toDistribLattice α = { toLattice := inst, le_sup_inf := ⋯ } | null | true |
Ctop.Realizer.id._proof_1 | Mathlib.Data.Analysis.Topology | ∀ {α : Type u_1} [inst : TopologicalSpace α] (x x_1 : { x // IsOpen x }) (_a : α) (h : _a ∈ ↑x ∩ ↑x_1),
_a ∈
↑(match x, h with
| ⟨_x, h₁⟩, _h₃ =>
match x_1, _h₃ with
| ⟨_y, h₂⟩, _h₃ => ⟨_x ∩ _y, ⋯⟩) | null | false |
Lean.Lsp.CompletionClientCapabilities.casesOn | Lean.Data.Lsp.Capabilities | {motive : Lean.Lsp.CompletionClientCapabilities → Sort u} →
(t : Lean.Lsp.CompletionClientCapabilities) →
((completionItem? : Option Lean.Lsp.CompletionItemCapabilities) → motive { completionItem? := completionItem? }) →
motive t | null | false |
not_or._simp_3 | Mathlib.Tactic.Push | ∀ {p q : Prop}, (¬p ∧ ¬q) = ¬(p ∨ q) | null | false |
Vector.finRev?_push | Init.Data.Vector.Find | ∀ {α : Type} {n : ℕ} {p : α → Bool} {a : α} {xs : Vector α n},
Vector.findRev? p (xs.push a) = (Option.guard p a).or (Vector.findRev? p xs) | null | true |
NumberField.Units.finrank_eq | Mathlib.NumberTheory.NumberField.Units.DirichletTheorem | ∀ (K : Type u_1) [inst : Field K] [inst_1 : NumberField K],
Module.finrank ℤ (Additive (NumberField.RingOfIntegers K)ˣ) = NumberField.Units.rank K | null | true |
Finset.sup_inf_sup | Mathlib.Data.Finset.Lattice.Prod | ∀ {α : Type u_1} {ι : Type u_4} {κ : Type u_5} [inst : DistribLattice α] [inst_1 : OrderBot α] (s : Finset ι)
(t : Finset κ) (f : ι → α) (g : κ → α), s.sup f ⊓ t.sup g = (s ×ˢ t).sup fun i => f i.1 ⊓ g i.2 | null | true |
List.cons_sublist_iff | Init.Data.List.Sublist | ∀ {α : Type u_1} {a : α} {l l' : List α}, (a :: l).Sublist l' ↔ ∃ r₁ r₂, l' = r₁ ++ r₂ ∧ a ∈ r₁ ∧ l.Sublist r₂ | null | true |
Subring.toRing | Mathlib.Algebra.Ring.Subring.Defs | {R : Type u_1} → [inst : Ring R] → (s : Subring R) → Ring ↥s | A subring of a ring inherits a ring structure | true |
_private.Lean.Elab.Tactic.ElabTerm.0.Lean.Elab.Tactic.refineCore._sparseCasesOn_1 | Lean.Elab.Tactic.ElabTerm | {α : Type u} →
{motive : Option α → Sort u_1} →
(t : Option α) → ((val : α) → motive (some val)) → (Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t | null | false |
Filter.monoid._proof_1 | Mathlib.Order.Filter.Pointwise | ∀ {α : Type u_1} [inst : Monoid α] (x : Filter α), x ^ 0 = 1 | null | false |
Lean.Meta.kabstract | Lean.Meta.KAbstract | Lean.Expr → Lean.Expr → optParam Lean.Meta.Occurrences Lean.Meta.Occurrences.all → Lean.MetaM Lean.Expr | Abstract occurrences of `p` in `e`. We detect subterms equivalent to `p` using key-matching.
That is, only perform `isDefEq` tests when the head symbol of subterm is equivalent to head symbol of `p`.
By default, all occurrences are abstracted,
but this behavior can be controlled using the `occs` parameter.
All matche... | true |
AlgebraicGeometry.LocallyOfFiniteType.isLocallyNoetherian | Mathlib.AlgebraicGeometry.Noetherian | ∀ {X Y : AlgebraicGeometry.Scheme} (f : X ⟶ Y) [AlgebraicGeometry.LocallyOfFiniteType f]
[AlgebraicGeometry.IsLocallyNoetherian Y], AlgebraicGeometry.IsLocallyNoetherian X | null | true |
MDifferentiableWithinAt.clm_bundle_apply | Mathlib.Geometry.Manifold.VectorBundle.Hom | ∀ {𝕜 : Type u_1} {B : Type u_2} {F₁ : Type u_3} {F₂ : Type u_4} {M : Type u_6} [inst : NontriviallyNormedField 𝕜]
{E₁ : B → Type u_7} [inst_1 : (x : B) → AddCommGroup (E₁ x)] [inst_2 : (x : B) → Module 𝕜 (E₁ x)]
[inst_3 : NormedAddCommGroup F₁] [inst_4 : NormedSpace 𝕜 F₁] [inst_5 : TopologicalSpace (Bundle.Tota... | Consider a differentiable map `v : M → E₁` to a vector bundle, over a base map `b : M → B`, and
linear maps `ϕ m : E₁ (b m) → E₂ (b m)` depending smoothly on `m`.
One can apply `ϕ m` to `v m`, and the resulting map is differentiable.
We give here a version of this statement within a set at a point. | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.