name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
EuclideanGeometry.Concyclic.subset | Mathlib.Geometry.Euclidean.Sphere.Basic | ∀ {V : Type u_1} {P : Type u_2} [inst : NormedAddCommGroup V] [inst_1 : NormedSpace ℝ V] [inst_2 : MetricSpace P]
[inst_3 : NormedAddTorsor V P] {ps₁ ps₂ : Set P},
ps₁ ⊆ ps₂ → EuclideanGeometry.Concyclic ps₂ → EuclideanGeometry.Concyclic ps₁ | A subset of a concyclic set is concyclic. | true |
Nat.toArray_roc_add_succ_right_eq_push | Init.Data.Range.Polymorphic.NatLemmas | ∀ {m n : ℕ}, (m<...=m + n + 1).toArray = (m<...=m + n).toArray.push (m + n + 1) | null | true |
Subfield.map_le_iff_le_comap | Mathlib.Algebra.Field.Subfield.Basic | ∀ {K : Type u} {L : Type v} [inst : DivisionRing K] [inst_1 : DivisionRing L] {f : K →+* L} {s : Subfield K}
{t : Subfield L}, Subfield.map f s ≤ t ↔ s ≤ Subfield.comap f t | null | true |
Complex.re_le_norm | Mathlib.Analysis.Complex.Norm | ∀ (z : ℂ), z.re ≤ ‖z‖ | null | true |
Lean.Meta.Simp.isBuiltinSimproc | Lean.Meta.Tactic.Simp.Simproc | Lean.Name → Lean.CoreM Bool | null | true |
_private.Mathlib.Data.FinEnum.Option.0.FinEnum.recEmptyOption.match_1.eq_1 | Mathlib.Data.FinEnum.Option | ∀ (motive : ℕ → Sort u_1) (h_1 : 0 = 0 → motive 0) (h_2 : (n : ℕ) → 0 = n.succ → motive n.succ),
(match cardeq : 0 with
| 0 => h_1 cardeq
| n.succ => h_2 n cardeq) =
h_1 ⋯ | null | true |
_private.Lean.Meta.Tactic.Simp.BuiltinSimprocs.Nat.0.Nat.reduceShiftRight._regBuiltin.Nat.reduceShiftRight.declare_1._@.Lean.Meta.Tactic.Simp.BuiltinSimprocs.Nat.3404948686._hygCtx._hyg.28 | Lean.Meta.Tactic.Simp.BuiltinSimprocs.Nat | IO Unit | null | false |
CategoryTheory.Limits.imageSubobject_iso_comp | Mathlib.CategoryTheory.Subobject.Limits | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y : C} [CategoryTheory.Limits.HasEqualizers C] {X' : C}
(h : X' ⟶ X) [inst_2 : CategoryTheory.IsIso h] (f : X ⟶ Y) [inst_3 : CategoryTheory.Limits.HasImage f],
CategoryTheory.Limits.imageSubobject (CategoryTheory.CategoryStruct.comp h f) = CategoryTheory.L... | Precomposing by an isomorphism does not change the image subobject. | true |
NonUnitalSubring.mk._flat_ctor | Mathlib.RingTheory.NonUnitalSubring.Defs | {R : Type u} →
[inst : NonUnitalNonAssocRing R] →
(carrier : Set R) →
(∀ {a b : R}, a ∈ carrier → b ∈ carrier → a + b ∈ carrier) →
0 ∈ carrier →
(∀ {a b : R}, a ∈ carrier → b ∈ carrier → a * b ∈ carrier) →
(∀ {x : R}, x ∈ carrier → -x ∈ carrier) → NonUnitalSubring R | null | false |
_private.Mathlib.Topology.UniformSpace.UniformConvergence.0.tendstoUniformlyOn_iff_tendstoUniformlyOnFilter._simp_1_3 | Mathlib.Topology.UniformSpace.UniformConvergence | ∀ {α : Type u_1} {β : Type u_2} {f : Filter α} {p : α × β → Prop} {s : Set β},
(∀ᶠ (x : α × β) in f ×ˢ Filter.principal s, p x) = ∀ᶠ (x : α) in f, ∀ y ∈ s, p (x, y) | null | false |
ContMDiffMap.coeFnMonoidHom.eq_1 | Mathlib.Geometry.Manifold.Algebra.SmoothFunctions | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {E' : Type u_3} [inst_3 : NormedAddCommGroup E'] [inst_4 : NormedSpace 𝕜 E'] {H : Type u_4}
[inst_5 : TopologicalSpace H] {I : ModelWithCorners 𝕜 E H} {H' : Type u_5} [inst_6 : Topologi... | null | true |
Set.forall_subset_range_iff._simp_1 | Mathlib.Data.Set.Image | ∀ {α : Type u_1} {β : Type u_2} {f : α → β} {p : Set β → Prop}, (∀ s ⊆ Set.range f, p s) = ∀ (s : Set α), p (f '' s) | null | false |
CategoryTheory.ExponentiableMorphism.OverMkHom | Mathlib.CategoryTheory.LocallyCartesianClosed.ExponentiableMorphism | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{I J : C} →
{f : I ⟶ J} →
[inst_1 : CategoryTheory.ChosenPullbacksAlong f] →
[CategoryTheory.ExponentiableMorphism f] → CategoryTheory.ExponentiableMorphism (CategoryTheory.Over.mk f).hom | null | true |
AlgebraicGeometry.Scheme.Pullback.openCoverOfBase'._proof_2 | Mathlib.AlgebraicGeometry.Pullbacks | ∀ {X Y Z : AlgebraicGeometry.Scheme} (𝒰 : Z.OpenCover) (f : X ⟶ Z) (g : Y ⟶ Z)
(i :
(AlgebraicGeometry.Scheme.Pullback.openCoverOfLeft (CategoryTheory.Precoverage.ZeroHypercover.pullback₁ f 𝒰) f
g).I₀),
CategoryTheory.Limits.HasPullback f (𝒰.f i) | null | false |
MeasureTheory.lintegral_add_mul_meas_add_le_le_lintegral | Mathlib.MeasureTheory.Integral.Lebesgue.Markov | ∀ {α : Type u_1} {mα : MeasurableSpace α} {μ : MeasureTheory.Measure α} {f g : α → ENNReal},
f ≤ᵐ[μ] g → AEMeasurable g μ → ∀ (ε : ENNReal), ∫⁻ (a : α), f a ∂μ + ε * μ {x | f x + ε ≤ g x} ≤ ∫⁻ (a : α), g a ∂μ | A version of **Markov's inequality** for two functions. It doesn't follow from the standard
Markov's inequality because we only assume measurability of `g`, not `f`. | true |
Aesop.Hyp | Aesop.Forward.State | Type | A hypothesis that was matched against a premise, or a rule pattern
substitution. | true |
Lean.LocalDecl.setNondep | Lean.LocalContext | Lean.LocalDecl → Bool → Lean.LocalDecl | Sets the `nondep` flag of an `ldecl`, otherwise returns `cdecl`s unchanged.
This is a low-level function, and it is the responsibility of the caller to ensure that
transitions of `nondep` are valid.
Rules:
- If the declaration is not under the caller's control, then setting `nondep := false` must not be done.
Gener... | true |
TopologicalSpace.NonemptyCompacts.secondCountableTopology_iff._simp_1 | Mathlib.Topology.Sets.VietorisTopology | ∀ {α : Type u_1} [inst : TopologicalSpace α],
SecondCountableTopology (TopologicalSpace.NonemptyCompacts α) = SecondCountableTopology α | null | false |
Lean.Compiler.LCNF.UnreachableBranches.Value.ctorElimType | Lean.Compiler.LCNF.ElimDeadBranches | {motive_1 : Lean.Compiler.LCNF.UnreachableBranches.Value → Sort u} → ℕ → Sort (max 1 u) | null | false |
RBTree.RBSet.foldr | Batteries.Recycling.RBTree.Basic | {α : Type u_1} → {σ : Sort u_2} → {cmp : α → α → Ordering} → (α → σ → σ) → σ → RBTree.RBSet α cmp → σ | `O(n)`. Fold a function on the values from right to left (in decreasing order). | true |
Lean.Elab.InfoTree.context.elim | Lean.Elab.InfoTree.Types | {motive_1 : Lean.Elab.InfoTree → Sort u} →
(t : Lean.Elab.InfoTree) →
t.ctorIdx = 0 →
((i : Lean.Elab.PartialContextInfo) → (t : Lean.Elab.InfoTree) → motive_1 (Lean.Elab.InfoTree.context i t)) →
motive_1 t | null | false |
Lean.Compiler.LCNF.Simp.Config.noConfusionType | Lean.Compiler.LCNF.Simp.Config | Sort u → Lean.Compiler.LCNF.Simp.Config → Lean.Compiler.LCNF.Simp.Config → Sort u | null | false |
ThreeGPFree.prod | Mathlib.Combinatorics.Additive.AP.Three.Defs | ∀ {α : Type u_2} {β : Type u_3} [inst : Monoid α] [inst_1 : Monoid β] {s : Set α} {t : Set β},
ThreeGPFree s → ThreeGPFree t → ThreeGPFree (s ×ˢ t) | null | true |
NNReal.instLinearOrder._aux_4 | Mathlib.Basic.NNReal.Defs | DecidableLE NNReal | null | false |
CategoryTheory.SimplicialObject.Splitting.toNondegComplex_fromNondegComplex | Mathlib.AlgebraicTopology.DoldKan.SplitSimplicialObject | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {X : CategoryTheory.SimplicialObject C} (s : X.Splitting)
[inst_1 : CategoryTheory.Preadditive C],
CategoryTheory.CategoryStruct.comp s.toNondegComplex s.fromNondegComplex = AlgebraicTopology.DoldKan.PInfty | null | true |
IsCompactElement.bot._simp_1 | Mathlib.Order.CompactlyGenerated.Basic | ∀ {α : Type u_2} [inst : Preorder α] [inst_1 : OrderBot α], IsCompactElement ⊥ = True | null | false |
contMDiffWithinAt_of_notMem_mulTSupport | Mathlib.Geometry.Manifold.ContMDiff.Basic | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {H : Type u_3} [inst_3 : TopologicalSpace H] {I : ModelWithCorners 𝕜 E H} {M : Type u_4}
[inst_4 : TopologicalSpace M] {E' : Type u_5} [inst_5 : NormedAddCommGroup E'] [inst_6 : NormedSp... | null | true |
_private.Init.Data.String.Lemmas.Pattern.Find.Basic.0.String.Slice.Pattern.Model.find?_eq_some_iff.match_1_2.eq_1 | Init.Data.String.Lemmas.Pattern.Find.Basic | ∀ {s : String.Slice} (motive : String.Slice.Pattern.SearchStep s → Sort u_1) (s_1 endPos : s.Pos)
(h_1 : (s_2 endPos : s.Pos) → motive (String.Slice.Pattern.SearchStep.matched s_2 endPos))
(h_2 : (startPos endPos : s.Pos) → motive (String.Slice.Pattern.SearchStep.rejected startPos endPos)),
(match String.Slice.Pa... | null | true |
Bool.beq_eq_decide_eq | Init.Data.Bool | ∀ {α : Type u_1} [inst : BEq α] [LawfulBEq α] [inst_2 : DecidableEq α] (a b : α), (a == b) = decide (a = b) | null | true |
Colex.instPow_1._aux_1 | Mathlib.Algebra.Order.Group.Synonym | {α : Type u_1} → {β : Type u_2} → [Pow α β] → Pow α (Colex β) | null | false |
Lean.NameGenerator.noConfusionType | Init.MetaTypes | Sort u → Lean.NameGenerator → Lean.NameGenerator → Sort u | null | false |
_private.Mathlib.CategoryTheory.Sites.Precoverage.Subsheaf.0.CategoryTheory.Precoverage.SmallConstruction.Witness.ctorElimType | Mathlib.CategoryTheory.Sites.Precoverage.Subsheaf | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{K : CategoryTheory.Precoverage C} →
{ι : C → Type w} →
{motive : (a : C) → CategoryTheory.Precoverage.SmallConstruction.Witness✝ K ι a → Sort u_1} →
ℕ →
Sort
(max 1 (imax (u + 1) (u + 1) (v + 1) (max (max... | null | false |
MeasureTheory.Measure.addHaar_preimage_continuousLinearEquiv | Mathlib.MeasureTheory.Measure.Lebesgue.EqHaar | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] [inst_2 : MeasurableSpace E] [BorelSpace E]
[FiniteDimensional ℝ E] (μ : MeasureTheory.Measure E) [μ.IsAddHaarMeasure] (f : E ≃L[ℝ] E) (s : Set E),
μ (⇑f ⁻¹' s) = ENNReal.ofReal |LinearMap.det ↑↑f.symm| * μ s | The preimage of a set `s` under a continuous linear equiv `f` has measure
equal to `μ s` times the absolute value of the inverse of the determinant of `f`. | true |
Lists.Equiv.decidable._mutual._proof_4 | Mathlib.SetTheory.Lists | ∀ {α : Type u_1} (b : Bool) (a : Lists' α b) (l₁ l₂ : Lists' α true),
sizeOf ⟨b, a⟩ < 1 + 1 + sizeOf a + sizeOf l₁ →
InvImage (fun x1 x2 => x1 < x2)
(fun x =>
PSum.casesOn x (fun _x => PSigma.casesOn _x fun l₁ l₂ => sizeOf l₁ + sizeOf l₂) fun _x =>
PSum.casesOn _x (fun _x => PSigma.casesOn... | null | false |
_private.Lean.Parser.Command.0.Lean.Parser.Command.declaration._regBuiltin.Lean.Parser.Command.definition.formatter_97 | Lean.Parser.Command | IO Unit | null | false |
Finpartition.sparsePairs_mono | Mathlib.Combinatorics.SimpleGraph.Regularity.Uniform | ∀ {α : Type u_1} {𝕜 : Type u_2} [inst : Field 𝕜] [inst_1 : LinearOrder 𝕜] [inst_2 : DecidableEq α] {A : Finset α}
(P : Finpartition A) (G : SimpleGraph α) [inst_3 : DecidableRel G.Adj] {ε ε' : 𝕜},
ε ≤ ε' → P.sparsePairs G ε ⊆ P.sparsePairs G ε' | null | true |
ZeroAtInftyContinuousMap.toOnePoint | Mathlib.Topology.ContinuousMap.ZeroAtInftyUnitization | {X : Type u_1} →
{R : Type u_2} →
[inst : TopologicalSpace X] →
[R1Space X] → [inst_2 : TopologicalSpace R] → [inst_3 : Zero R] → ZeroAtInftyContinuousMap X R → C(OnePoint X, R) | Extension by zero of a continuous function vanishing at infinity, as a continuous function on
the one-point compactification. | true |
Std.DHashMap.Const.mem_alter | Std.Data.DHashMap.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {β : Type v} {m : Std.DHashMap α fun x => β} [EquivBEq α]
[LawfulHashable α] {k k' : α} {f : Option β → Option β},
k' ∈ Std.DHashMap.Const.alter m k f ↔
if (k == k') = true then (f (Std.DHashMap.Const.get? m k)).isSome = true else k' ∈ m | null | true |
ApproximatesLinearOn.toHomeomorph._proof_3 | Mathlib.Analysis.Calculus.InverseFunctionTheorem.ApproximatesLinearOn | ∀ {𝕜 : Type u_3} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {F : Type u_1} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] (f : E → F)
{f' : E ≃L[𝕜] F} {c : NNReal} [inst_5 : CompleteSpace E] (hf : ApproximatesLinearOn f (↑f') Set.uni... | null | false |
Lean.Expr.binderInfoEx | Lean.Expr | Lean.Expr → Lean.BinderInfo | null | true |
CategoryTheory.IsGrothendieckAbelian.generatingMonomorphisms.transfiniteCompositionOfShapeMapFromBot | Mathlib.CategoryTheory.Abelian.GrothendieckCategory.EnoughInjectives | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{G : C} →
[inst_1 : CategoryTheory.Abelian C] →
(hG : CategoryTheory.IsSeparator G) →
{X : C} →
[inst_2 : CategoryTheory.IsGrothendieckAbelian.{w, v, u} C] →
(A₀ : CategoryTheory.Subobject X) →
... | For any `j`, the map `(functor hG A₀ J).map (homOfLE bot_le : ⊥ ⟶ j)`
is a transfinite composition of pushouts of monomorphisms in the
family `generatingMonomorphisms G`. | true |
covBy_sup_of_inf_covBy_of_inf_covBy_left | Mathlib.Order.ModularLattice | ∀ {α : Type u_1} [inst : Lattice α] [IsWeakUpperModularLattice α] {a b : α}, a ⊓ b ⋖ a → a ⊓ b ⋖ b → a ⋖ a ⊔ b | null | true |
CategoryTheory.StructuredArrow.subobjectEquiv._proof_2 | Mathlib.CategoryTheory.Subobject.Comma | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} C] {D : Type u_4}
[inst_1 : CategoryTheory.Category.{u_3, u_4} D] {S : D} {T : CategoryTheory.Functor C D}
[inst_2 : CategoryTheory.Limits.HasFiniteLimits C] [inst_3 : CategoryTheory.Limits.PreservesFiniteLimits T]
(A : CategoryTheory.StructuredArrow S T... | null | false |
LinearMap.rTensor_tmul | Mathlib.LinearAlgebra.TensorProduct.Map | ∀ {R : Type u_1} [inst : CommSemiring R] (M : Type u_4) {N : Type u_5} {P : Type u_6} [inst_1 : AddCommMonoid M]
[inst_2 : AddCommMonoid N] [inst_3 : AddCommMonoid P] [inst_4 : Module R M] [inst_5 : Module R N]
[inst_6 : Module R P] (f : N →ₗ[R] P) (m : M) (n : N), (LinearMap.rTensor M f) (n ⊗ₜ[R] m) = f n ⊗ₜ[R] m | null | true |
strictAnti_of_hasDerivAt_neg | Mathlib.Analysis.Calculus.Deriv.MeanValue | ∀ {f f' : ℝ → ℝ}, (∀ (x : ℝ), HasDerivAt f (f' x) x) → (∀ (x : ℝ), f' x < 0) → StrictAnti f | Let `f : ℝ → ℝ` be a differentiable function. If `f'` is strictly positive, then
`f` is a strictly monotone function. | true |
LieModuleHom.toLinearMap_comp._simp_1 | Mathlib.Algebra.Lie.Basic | ∀ {R : Type u} {L : Type v} {M : Type w} {N : Type w₁} {P : Type w₂} [inst : CommRing R] [inst_1 : LieRing L]
[inst_2 : AddCommGroup M] [inst_3 : AddCommGroup N] [inst_4 : AddCommGroup P] [inst_5 : Module R M]
[inst_6 : Module R N] [inst_7 : Module R P] [inst_8 : LieRingModule L M] [inst_9 : LieRingModule L N]
[i... | null | false |
Lean.Elab.Tactic.ElimApp.Alt.ctorIdx | Lean.Elab.Tactic.Induction | Lean.Elab.Tactic.ElimApp.Alt → ℕ | null | false |
Nat.Internal.SOM.Mon.denote | Init.Data.Nat.Internal.SOM | Nat.Internal.Linear.Context → Nat.Internal.SOM.Mon → ℕ | null | true |
FP.Float._sizeOf_1 | Mathlib.Data.FP.Basic | {C : FP.FloatCfg} → FP.Float → ℕ | null | false |
WithLp.unitization_addEquiv_prod | Mathlib.Analysis.Normed.Algebra.UnitizationL1 | (𝕜 : Type u_1) →
(A : Type u_2) →
[inst : NormedField 𝕜] →
[inst_1 : NonUnitalNormedRing A] → [NormedSpace 𝕜 A] → WithLp 1 (Unitization 𝕜 A) ≃+ WithLp 1 (𝕜 × A) | The natural map between `Unitization 𝕜 A` and `𝕜 × A`, transferred to their `WithLp 1`
synonyms. | true |
SimpleGraph.maxDegree.eq_1 | Mathlib.Combinatorics.SimpleGraph.Finite | ∀ {V : Type u_1} (G : SimpleGraph V) [inst : Fintype V] [inst_1 : DecidableRel G.Adj],
G.maxDegree = WithBot.unbotD 0 (Finset.image (fun v => G.degree v) Finset.univ).max | null | true |
Finset.prod_Ico_succ_div_top | Mathlib.Algebra.BigOperators.Intervals | ∀ {M : Type u_4} (f : ℕ → M) {m n : ℕ} [inst : CommGroup M],
m ≤ n → (∏ i ∈ Finset.Ico m (n + 1), f i) / f n = ∏ i ∈ Finset.Ico m n, f i | null | true |
BitVec.ushiftRight | Init.Data.BitVec.Basic | {n : ℕ} → BitVec n → ℕ → BitVec n | Shifts a bitvector to the right. This is a logical right shift - the high bits are filled with
zeros.
As a numeric operation, this is equivalent to `x / 2^s`, rounding down.
SMT-LIB name: `bvlshr` except this operator uses a `Nat` shift value.
| true |
Finset.equivOfEq | Mathlib.Data.Finset.Image | {α : Type u_1} → {s t : Finset α} → s = t → ↥s ≃ ↥t | The subtypes corresponding to equal finsets are equivalent.
See also `Set.equivOfEq`. | true |
Polygon.noConfusionType | Mathlib.Geometry.Polygon.Basic | Sort u → {P : Type u_1} → {n : ℕ} → Polygon P n → {P' : Type u_1} → {n' : ℕ} → Polygon P' n' → Sort u | null | false |
_private.Lean.Compiler.LCNF.ExtractClosed.0.Lean.Compiler.LCNF.ExtractClosed.shouldExtractLetValue.match_6 | Lean.Compiler.LCNF.ExtractClosed | (motive : Option (Lean.Compiler.LCNF.Decl Lean.Compiler.LCNF.Purity.pure) → Sort u_1) →
(__do_lift : Option (Lean.Compiler.LCNF.Decl Lean.Compiler.LCNF.Purity.pure)) →
((decl : Lean.Compiler.LCNF.Decl Lean.Compiler.LCNF.Purity.pure) → motive (some decl)) →
((x : Option (Lean.Compiler.LCNF.Decl Lean.Compiler... | null | false |
_private.Mathlib.CategoryTheory.Triangulated.TStructure.SpectralObject.0.CategoryTheory.Triangulated.TStructure.spectralObject._proof_2 | Mathlib.CategoryTheory.Triangulated.TStructure.SpectralObject | ¬1 ≤ 2 → False | null | false |
PowerSeries.order_le | Mathlib.RingTheory.PowerSeries.Order | ∀ {R : Type u_1} [inst : Semiring R] {φ : PowerSeries R} (n : ℕ), (PowerSeries.coeff n) φ ≠ 0 → φ.order ≤ ↑n | If the `n`th coefficient of a formal power series is nonzero,
then the order of the power series is less than or equal to `n`. | true |
_private.Mathlib.Data.Set.PowersetCard.0.Set.powersetCard.nonempty_iff.match_1_1 | Mathlib.Data.Set.PowersetCard | ∀ {α : Type u_1} {n : ℕ} (motive : Nonempty ↑(Set.powersetCard α n) → Prop) (x : Nonempty ↑(Set.powersetCard α n)),
(∀ (s : Finset α) (hs : s ∈ Set.powersetCard α n), motive ⋯) → motive x | null | false |
Matroid.delete_isBasis'_iff | Mathlib.Combinatorics.Matroid.Minor.Delete | ∀ {α : Type u_1} {M : Matroid α} {I D X : Set α}, (M.delete D).IsBasis' I X ↔ M.IsBasis' I (X \ D) | null | true |
_private.Mathlib.Data.List.Nodup.0.List.Nodup.eq_of_head_mem_of_getLast_mem_of_infix._proof_1_14 | Mathlib.Data.List.Nodup | ∀ {α : Type u_1} {l₂ : List α} (w : List α), l₂.length - 1 + 1 ≤ w.length → l₂.length - 1 < w.length | null | false |
String.Slice.splits_slice | Init.Data.String.Lemmas.Splits | ∀ {s : String.Slice} {p₀ p₁ : s.Pos} (h : p₀ ≤ p₁) (p : (s.slice p₀ p₁ h).Pos),
p.Splits (s.slice p₀ (String.Slice.Pos.ofSlice p) ⋯).copy (s.slice (String.Slice.Pos.ofSlice p) p₁ ⋯).copy | null | true |
NumberField.InfinitePlace.Completion.ofCompletion.noConfusion | Mathlib.NumberTheory.NumberField.Completion.InfinitePlace | {K : Type u_1} →
{inst : Field K} →
{v : NumberField.InfinitePlace K} →
{P : Sort u} →
{toCompletion toCompletion' : (↑v).Completion} →
NumberField.InfinitePlace.Completion.ofCompletion toCompletion =
NumberField.InfinitePlace.Completion.ofCompletion toCompletion' →
... | null | false |
Finset.mem_bipartiteBelow | Mathlib.Combinatorics.Enumerative.DoubleCounting | ∀ {α : Type u_2} {β : Type u_3} (r : α → β → Prop) {s : Finset α} {b : β} [inst : (a : α) → Decidable (r a b)] {a : α},
a ∈ Finset.bipartiteBelow r s b ↔ a ∈ s ∧ r a b | null | true |
Function.Surjective.valuationRing | Mathlib.RingTheory.Valuation.ValuationRing | ∀ {R : Type u_1} {S : Type u_2} [inst : NonAssocSemiring R] [PreValuationRing R] [inst_2 : CommRing S]
[inst_3 : IsDomain S] (f : R →+* S), Function.Surjective ⇑f → ValuationRing S | null | true |
_private.Mathlib.Topology.Instances.AddCircle.Defs.0.AddCircle.coe_eq_zero_iff_of_mem_Ico._simp_1_1 | Mathlib.Topology.Instances.AddCircle.Defs | ∀ {α : Type u_1} [inst : Preorder α] {a b : α}, (a ∈ Set.Ico a b) = (a < b) | null | false |
Rep.applyAsHom_apply | Mathlib.RepresentationTheory.Rep.Basic | ∀ {k : Type u} [inst : Semiring k] {G : Type v} [inst_1 : CommMonoid G] {A : Rep.{u_1, u, v} k G} (g : G) (x : ↑A),
(Rep.Hom.hom (A.applyAsHom g)) x = (A.ρ g) x | null | true |
closure_Iio' | Mathlib.Topology.Order.DenselyOrdered | ∀ {α : Type u_1} [inst : TopologicalSpace α] [inst_1 : LinearOrder α] [OrderTopology α] [DenselyOrdered α] {a : α},
(Set.Iio a).Nonempty → closure (Set.Iio a) = Set.Iic a | The closure of the interval `(-∞, a)` is the closed interval `(∞, a]`,
unless `a` is a bot element. | true |
LightProfinite.limitConeIsLimit | Mathlib.Topology.Category.LightProfinite.Basic | {J : Type v} →
[inst : CategoryTheory.SmallCategory J] →
[inst_1 : CategoryTheory.CountableCategory J] →
(F : CategoryTheory.Functor J LightProfinite) → CategoryTheory.Limits.IsLimit (LightProfinite.limitCone F) | The limit cone `LightProfinite.limitCone F` is indeed a limit cone. | true |
CategoryTheory.LiftableCocone.noConfusion | Mathlib.CategoryTheory.Limits.Creates | {P : Sort u} →
{C : Type u₁} →
{inst : CategoryTheory.Category.{v₁, u₁} C} →
{D : Type u₂} →
{inst_1 : CategoryTheory.Category.{v₂, u₂} D} →
{J : Type w} →
{inst_2 : CategoryTheory.Category.{w', w} J} →
{K : CategoryTheory.Functor J C} →
{F : Categ... | null | false |
SimpleGraph.degMatrix.congr_simp | Mathlib.Combinatorics.SimpleGraph.LapMatrix | ∀ {V : Type u_1} (R : Type u_2) [inst : Fintype V] (G G_1 : SimpleGraph V),
G = G_1 →
∀ {inst_1 : DecidableRel G.Adj} [inst_2 : DecidableRel G_1.Adj] {inst_3 : DecidableEq V} [inst_4 : DecidableEq V]
[inst_5 : AddMonoidWithOne R] (a a_1 : V),
a = a_1 → ∀ (a_2 a_3 : V), a_2 = a_3 → SimpleGraph.degMatri... | null | true |
ArchimedeanClass.orderHom_mk | Mathlib.Algebra.Order.Archimedean.Class | ∀ {M : Type u_1} [inst : AddCommGroup M] [inst_1 : LinearOrder M] [inst_2 : IsOrderedAddMonoid M] {N : Type u_2}
[inst_3 : AddCommGroup N] [inst_4 : LinearOrder N] [inst_5 : IsOrderedAddMonoid N] (f : M →+o N) (a : M),
(ArchimedeanClass.orderHom f) (ArchimedeanClass.mk a) = ArchimedeanClass.mk (f a) | null | true |
Real.sinh_add_cosh | Mathlib.Analysis.Complex.Trigonometric | ∀ (x : ℝ), Real.sinh x + Real.cosh x = Real.exp x | null | true |
CategoryTheory.Adjunction.CoreHomEquivUnitCounit.mk.congr_simp | Mathlib.CategoryTheory.Adjunction.Basic | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
{F : CategoryTheory.Functor C D} {G : CategoryTheory.Functor D C}
(homEquiv homEquiv_1 : (X : C) → (Y : D) → (F.obj X ⟶ Y) ≃ (X ⟶ G.obj Y)) (e_homEquiv : homEquiv = homEquiv_1)
(unit unit_1 : Ca... | null | true |
CategoryTheory.Functor.mapBifunctorHomologicalComplexObj | Mathlib.Algebra.Homology.Bifunctor | {C₁ : Type u_1} →
{C₂ : Type u_2} →
{D : Type u_3} →
[inst : CategoryTheory.Category.{v_1, u_1} C₁] →
[inst_1 : CategoryTheory.Category.{v_2, u_2} C₂] →
[inst_2 : CategoryTheory.Category.{v_3, u_3} D] →
[inst_3 : CategoryTheory.Limits.HasZeroMorphisms C₁] →
[inst_... | Auxiliary definition for `mapBifunctorHomologicalComplex`. | true |
MeasureTheory.IntegrableOn.add_measure | Mathlib.MeasureTheory.Integral.IntegrableOn | ∀ {α : Type u_1} {ε : Type u_3} {mα : MeasurableSpace α} {f : α → ε} {s : Set α} {μ ν : MeasureTheory.Measure α}
[inst : TopologicalSpace ε] [inst_1 : ContinuousENorm ε] [TopologicalSpace.PseudoMetrizableSpace ε],
MeasureTheory.IntegrableOn f s μ → MeasureTheory.IntegrableOn f s ν → MeasureTheory.IntegrableOn f s (... | null | true |
Polynomial.degree_freeMonic | Mathlib.RingTheory.Polynomial.UniversalFactorizationRing | ∀ (R : Type u_1) [inst : CommRing R] (n : ℕ) [Nontrivial R], (Polynomial.freeMonic R n).degree = ↑n | null | true |
IsLocalRing.ResidueField.mapEquiv._proof_6 | Mathlib.RingTheory.LocalRing.ResidueField.Basic | ∀ {R : Type u_2} {S : Type u_1} [inst : CommRing R] [inst_1 : CommRing S] (f : R ≃+* S), IsLocalHom ↑f.symm | null | false |
Circle.argEquiv | Mathlib.Analysis.SpecialFunctions.Complex.Circle | Circle ≃ ↑(Set.Ioc (-Real.pi) Real.pi) | `Complex.arg` and `Circle.exp ∘ (↑)` define an equivalence between `Circle` and `(-π, π]`. | true |
CategoryTheory.AddModObj.rec | 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] →
{M : C} →
[inst_4 : Cat... | null | false |
Mathlib.Tactic.Widget.StringDiagram.Node.id | Mathlib.Tactic.Widget.StringDiagram | Mathlib.Tactic.Widget.StringDiagram.IdNode → Mathlib.Tactic.Widget.StringDiagram.Node | null | true |
DirichletCharacter.delta_mul | Mathlib.NumberTheory.LSeries.Dirichlet | ∀ {n : ℕ} (χ : DirichletCharacter ℂ n), (LSeries.delta * fun n_1 => χ ↑n_1) = LSeries.delta | null | true |
IsManifold.instOfNatWithTopENat_2 | Mathlib.Geometry.Manifold.IsManifold.Basic | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {H : Type u_3} [inst_3 : TopologicalSpace H] {I : ModelWithCorners 𝕜 E H} {M : Type u_4}
[inst_4 : TopologicalSpace M] [inst_5 : ChartedSpace H M] [IsManifold I 3 M], IsManifold I 2 M | null | true |
_private.Mathlib.Analysis.CStarAlgebra.Fuglede.0.isStarNormal_iff_forall_exp_mul_exp_mem_unitary._simp_1_3 | Mathlib.Analysis.CStarAlgebra.Fuglede | ∀ {𝔸 : Type u_1} [inst : NormedRing 𝔸] [NormedAlgebra ℚ 𝔸] [CompleteSpace 𝔸] (x : 𝔸)
[inst_3 : Invertible (NormedSpace.exp x)], NormedSpace.exp (-x) = ⅟(NormedSpace.exp x) | null | false |
_private.Mathlib.RingTheory.MvPolynomial.Ideal.0.MvPolynomial.idealOfVars_eq_restrictSupportIdeal._simp_1_5 | Mathlib.RingTheory.MvPolynomial.Ideal | ∀ {R : Type u} {M : Type v} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] {S : AddSubmonoid M}
{x : M} (h : ∀ (c : R) {x : M}, x ∈ S.carrier → c • x ∈ S.carrier),
(x ∈ { toAddSubmonoid := S, smul_mem' := h }) = (x ∈ S) | null | false |
_private.Mathlib.Analysis.Calculus.LogDeriv.0.logDeriv_comp_neg._simp_1_2 | Mathlib.Analysis.Calculus.LogDeriv | ∀ {α : Type u_2} [inst : Zero α] [inst_1 : OfNat α 3] [NeZero 3], (3 = 0) = False | null | false |
Localization.isLocalization_range_mapToFractionRing | Mathlib.RingTheory.Localization.AsSubring | ∀ {A : Type u_1} (K : Type u_2) [inst : CommRing A] (S : Submonoid A) [inst_1 : CommRing K] [inst_2 : Algebra A K]
[inst_3 : IsFractionRing A K] (B : Type u_3) [inst_4 : CommRing B] [inst_5 : Algebra A B]
[inst_6 : IsLocalization S B] (hS : S ≤ nonZeroDivisors A),
IsLocalization S ↥(Localization.mapToFractionRing... | null | true |
RelSeries.toList_getElem | Mathlib.Order.RelSeries | ∀ {α : Type u_1} {r : SetRel α α} (p : RelSeries r) {i : ℕ} (hi : i < p.toList.length), p.toList[i] = p.toFun ⟨i, ⋯⟩ | null | true |
Std.IterM.length_map | Init.Data.Iterators.Lemmas.Combinators.Monadic.FilterMap | ∀ {α β β' : Type w} {m : Type w → Type w'} [inst : Std.Iterator α m β] [inst_1 : Monad m]
[inst_2 : Std.IteratorLoop α m m] [Std.Iterators.Finite α m] [LawfulMonad m] [Std.LawfulIteratorLoop α m m]
{it : Std.IterM m β} {f : β → β'}, (Std.IterM.map f it).length = it.length | null | true |
Ideal.gc_map_comap | Mathlib.RingTheory.Ideal.Maps | ∀ {R : Type u} {S : Type v} {F : Type u_1} [inst : Semiring R] [inst_1 : Semiring S] [inst_2 : FunLike F R S] (f : F)
[inst_3 : RingHomClass F R S], GaloisConnection (Ideal.map f) (Ideal.comap f) | null | true |
exists_mem_nhds_ball_subset_of_mem_nhds | Mathlib.Topology.UniformSpace.Defs | ∀ {α : Type ua} [inst : UniformSpace α] {a : α} {U : Set α},
U ∈ nhds a → ∃ V ∈ nhds a, ∃ t ∈ uniformity α, ∀ a' ∈ V, UniformSpace.ball a' t ⊆ U | null | true |
AddEquiv.addSubgroupCongr.eq_1 | Mathlib.Algebra.Group.Subgroup.Map | ∀ {G : Type u_1} [inst : AddGroup G] {H K : AddSubgroup G} (h : H = K),
AddEquiv.addSubgroupCongr h = { toEquiv := Set.equivOfEq ⋯, map_add' := ⋯ } | null | true |
_private.Batteries.Data.Vector.Basic.0.Vector.scanrMFast._proof_2 | Batteries.Data.Vector.Basic | ∀ {n : ℕ} (i n_usize : USize),
n_usize.toNat = n → i.toNat ≤ n → 0 < i.toNat → (i - 1).toNat = i.toNat - 1 → ¬(i - 1).toNat ≤ n → False | null | false |
_private.Init.Data.BitVec.Lemmas.0.BitVec.setWidth_setWidth_succ_eq_setWidth_setWidth_of_getLsbD_false._proof_1_1 | Init.Data.BitVec.Lemmas | ∀ {w : ℕ} {i : ℕ} (k : ℕ), ¬i = k → k < i + 1 → ¬k < i → False | null | false |
_private.Mathlib.RingTheory.Binomial.0.Ring.smeval_ascPochhammer_int_ofNat._simp_1_3 | Mathlib.RingTheory.Binomial | ∀ {R : Type u} [inst : Semiring R] (n : ℕ), ↑n = Polynomial.C ↑n | null | false |
Std.DTreeMap.Internal.Impl.balanceL!.match_5.congr_eq_1 | Std.Data.DTreeMap.Internal.Balancing | ∀ {α : Type u_1} {β : α → Type u_2} (motive : Std.DTreeMap.Internal.Impl α β → Sort u_3)
(l : Std.DTreeMap.Internal.Impl α β) (h_1 : Unit → motive Std.DTreeMap.Internal.Impl.leaf)
(h_2 :
(ls : ℕ) →
(lk : α) →
(lv : β lk) →
(ll lr : Std.DTreeMap.Internal.Impl α β) → motive (Std.DTreeMap.I... | null | true |
MeasureTheory.IsHahnDecomposition.le_on | Mathlib.MeasureTheory.Measure.Decomposition.Hahn | ∀ {α : Type u_1} {mα : MeasurableSpace α} {μ ν : MeasureTheory.Measure α} {s : Set α},
MeasureTheory.IsHahnDecomposition μ ν s → μ.restrict s ≤ ν.restrict s | null | true |
FractionRing.algEquiv | Mathlib.RingTheory.Localization.FractionRing | (A : Type u_4) →
[inst : CommRing A] →
(K : Type u_6) → [inst_1 : CommRing K] → [inst_2 : Algebra A K] → [IsFractionRing A K] → FractionRing A ≃ₐ[A] K | Given a ring `A` and a localization map to a fraction ring
`f : A →+* K`, we get an `A`-isomorphism between the fraction ring of `A` as a quotient
type and `K`. | true |
Subgroup.mem_smul_pointwise_iff_exists | Mathlib.Algebra.Group.Subgroup.Pointwise | ∀ {α : Type u_1} {G : Type u_2} [inst : Group G] [inst_1 : Monoid α] [inst_2 : MulDistribMulAction α G] (m : G) (a : α)
(S : Subgroup G), m ∈ a • S ↔ ∃ s ∈ S, a • s = m | null | true |
_private.Std.Http.Data.URI.0.Std.Http.RequestTarget.originForm!._sparseCasesOn_1 | Std.Http.Data.URI | {α : Type u} →
{motive : Option α → Sort u_1} →
(t : Option α) → ((val : α) → motive (some val)) → (Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.