name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
_private.Mathlib.GroupTheory.GroupAction.Blocks.0.MulAction.IsBlock.of_subset._simp_1_3 | Mathlib.GroupTheory.GroupAction.Blocks | ∀ {G : Type u_1} [inst : DivisionMonoid G] (a b : G), b⁻¹ * a⁻¹ = (a * b)⁻¹ | null | false |
Orientation.oangle_sign_sub_smul_left | Mathlib.Geometry.Euclidean.Angle.Oriented.Basic | ∀ {V : Type u_1} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V] [inst_2 : Fact (Module.finrank ℝ V = 2)]
(o : Orientation ℝ V (Fin 2)) (x y : V) (r : ℝ), (o.oangle (x - r • y) y).sign = (o.oangle x y).sign | Subtracting a multiple of the second vector passed to `oangle` from the first vector does
not change the sign of the angle. | true |
_private.Batteries.Data.Random.MersenneTwister.0.Batteries.Random.MersenneTwister.Config.lMask | Batteries.Data.Random.MersenneTwister | (cfg : Batteries.Random.MersenneTwister.Config) → BitVec cfg.wordSize | null | true |
Lean.Environment.imports | Lean.Environment | Lean.Environment → Array Lean.Import | null | true |
Std.Internal.List.maxKey!_insertEntryIfNew | Std.Data.Internal.List.Associative | ∀ {α : Type u} {β : α → Type v} [inst : Ord α] [Std.TransOrd α] [inst_2 : BEq α] [Std.LawfulBEqOrd α]
[inst_4 : Inhabited α] {l : List ((a : α) × β a)},
Std.Internal.List.DistinctKeys l →
∀ {k : α} {v : β k},
Std.Internal.List.maxKey! (Std.Internal.List.insertEntryIfNew k v l) =
(Std.Internal.List... | null | true |
_private.Lean.Compiler.LCNF.Simp.SimpValue.0.Lean.Compiler.LCNF.Simp.simpCtorDiscr?.match_6 | Lean.Compiler.LCNF.Simp.SimpValue | (motive : Lean.Compiler.LCNF.LetValue Lean.Compiler.LCNF.Purity.pure → Sort u_1) →
(e : Lean.Compiler.LCNF.LetValue Lean.Compiler.LCNF.Purity.pure) →
((declName : Lean.Name) →
(us : List Lean.Level) →
(args : Array (Lean.Compiler.LCNF.Arg Lean.Compiler.LCNF.Purity.pure)) →
motive (Le... | null | false |
_private.Mathlib.Algebra.Ring.GeomSum.0.geom_sum₂_mul_of_le._simp_1_1 | Mathlib.Algebra.Ring.GeomSum | ∀ {n m : ℕ}, (m ∈ Finset.range n) = (m < n) | null | false |
Mathlib.Tactic.FieldSimp.Sign.mul.match_1 | Mathlib.Tactic.FieldSimp.Lemmas | {v : Lean.Level} →
{M : Q(Type v)} →
(motive : Mathlib.Tactic.FieldSimp.Sign M → Mathlib.Tactic.FieldSimp.Sign M → Sort u_1) →
(g₁ g₂ : Mathlib.Tactic.FieldSimp.Sign M) →
(Unit → motive Mathlib.Tactic.FieldSimp.Sign.plus Mathlib.Tactic.FieldSimp.Sign.plus) →
((i : Q(Field «$M»)) → motive M... | null | false |
Std.DTreeMap.minKeyD_le_minKeyD_erase | Std.Data.DTreeMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t : Std.DTreeMap α β cmp} [Std.TransCmp cmp] {k : α},
(t.erase k).isEmpty = false → ∀ {fallback : α}, (cmp (t.minKeyD fallback) ((t.erase k).minKeyD fallback)).isLE = true | null | true |
OrderMonoidWithZeroHomClass.toOrderMonoidWithZeroHom.congr_simp | Mathlib.RingTheory.Valuation.Basic | ∀ {F : Type u_1} {α : Type u_2} {β : Type u_3} [inst : Preorder α] [inst_1 : Preorder β] [inst_2 : MulZeroOneClass α]
[inst_3 : MulZeroOneClass β] [inst_4 : FunLike F α β] [inst_5 : OrderHomClass F α β]
[inst_6 : MonoidWithZeroHomClass F α β] (f f_1 : F), f = f_1 → ↑f = ↑f_1 | null | true |
Std.DHashMap.Internal.Raw.WFImp.mk._flat_ctor | Std.Data.DHashMap.Internal.Defs | ∀ {α : Type u} {β : α → Type v} [inst : BEq α] [inst_1 : Hashable α] {m : Std.DHashMap.Raw α β},
Std.DHashMap.Internal.IsHashSelf m.buckets →
m.size = (Std.DHashMap.Internal.toListModel m.buckets).length →
Std.Internal.List.DistinctKeys (Std.DHashMap.Internal.toListModel m.buckets) → Std.DHashMap.Internal.R... | null | false |
CategoryTheory.Limits.SequentialProduct.functorMap_commSq_succ._proof_6 | Mathlib.CategoryTheory.Limits.Shapes.SequentialProduct | ∀ (n : ℕ), n < n + 1 | null | false |
HasDerivWithinAt.clog | Mathlib.Analysis.SpecialFunctions.Complex.LogDeriv | ∀ {f : ℂ → ℂ} {f' x : ℂ} {s : Set ℂ},
HasDerivWithinAt f f' s x → f x ∈ Complex.slitPlane → HasDerivWithinAt (fun t => Complex.log (f t)) (f' / f x) s x | null | true |
LinearEquiv.symmEquiv_apply_symm_apply | Mathlib.Algebra.Module.Equiv.Defs | ∀ {R : Type u_1} {S : Type u_6} {M : Type u_7} {M₂ : Type u_9} [inst : Semiring R] [inst_1 : Semiring S]
[inst_2 : AddCommMonoid M] [inst_3 : AddCommMonoid M₂] {module_M : Module R M} {module_S_M₂ : Module S M₂}
{σ : R →+* S} {σ' : S →+* R} {re₁ : RingHomInvPair σ σ'} {re₂ : RingHomInvPair σ' σ} (e : M ≃ₛₗ[σ] M₂) (... | null | true |
List.alternatingProd._sunfold | Mathlib.Algebra.BigOperators.Group.List.Defs | {G : Type u_4} → [One G] → [Mul G] → [Inv G] → List G → G | null | false |
QuotientAddGroup.induction_on | Mathlib.GroupTheory.Coset.Defs | ∀ {α : Type u_1} [inst : AddGroup α] {s : AddSubgroup α} {C : α ⧸ s → Prop} (x : α ⧸ s), (∀ (z : α), C ↑z) → C x | null | true |
ProbabilityTheory.Kernel.compProd_of_not_isSFiniteKernel_left | Mathlib.Probability.Kernel.Composition.CompProd | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} {mα : MeasurableSpace α} {mβ : MeasurableSpace β}
{mγ : MeasurableSpace γ} (κ : ProbabilityTheory.Kernel α β) (η : ProbabilityTheory.Kernel (α × β) γ),
¬ProbabilityTheory.IsSFiniteKernel κ → κ.compProd η = 0 | null | true |
_private.Mathlib.Topology.Bornology.Absorbs.0.absorbs_inter._simp_1_1 | Mathlib.Topology.Bornology.Absorbs | ∀ {G₀ : Type u_1} {α : Type u_2} [inst : GroupWithZero G₀] [inst_1 : Bornology G₀] [inst_2 : MulAction G₀ α]
{s t : Set α}, Absorbs G₀ s t = ∀ᶠ (c : G₀) in Bornology.cobounded G₀, Set.MapsTo (fun x => c⁻¹ • x) t s | null | false |
_private.Mathlib.Algebra.BigOperators.Intervals.0.Finset.sum_Ico_Ico_comm._proof_1_4 | Mathlib.Algebra.BigOperators.Intervals | ∀ (a b a_1 b_1 : ℕ), (a ≤ a_1 ∧ a_1 < b) ∧ a_1 ≤ b_1 ∧ b_1 < b → (a ≤ b_1 ∧ b_1 < b) ∧ a ≤ a_1 ∧ a_1 < b_1 + 1 | null | false |
PFun.fixInduction'._proof_2 | Mathlib.Data.PFun | ∀ {α : Type u_1} {β : Type u_2} {f : α →. β ⊕ α} {b : β} (a' : α),
b ∈ f.fix a' → ∀ (b' : β), Sum.inl b' ∈ f a' → Sum.inl b ∈ f a' | null | false |
isOpen_interior._simp_1 | Mathlib.Topology.Closure | ∀ {X : Type u} [inst : TopologicalSpace X] {s : Set X}, IsOpen (interior s) = True | null | false |
Order.Ideal.instInfSet | Mathlib.Order.Ideal | {P : Type u_1} → [inst : SemilatticeSup P] → [OrderBot P] → InfSet (Order.Ideal P) | null | true |
String.Slice.Pattern.Model.ForwardSliceSearcher.matchesAt_iff_splits | Init.Data.String.Lemmas.Pattern.String.Basic | ∀ {pat s : String.Slice} {pos : s.Pos},
String.Slice.Pattern.Model.MatchesAt pat pos ↔ ∃ t₁ t₂, pos.Splits t₁ (pat.copy ++ t₂) | null | true |
Plausible.InjectiveFunction.shrink._proof_1 | Mathlib.Testing.Plausible.Functions | ∀ {α : Type} (xs : List ((_ : α) × α)),
(List.map Sigma.fst xs).Perm (List.map Sigma.snd xs) →
(List.map Sigma.snd xs).Nodup → (List.map Sigma.fst xs).Perm (List.map Sigma.snd xs) ∧ (List.map Sigma.snd xs).Nodup | null | false |
Lean.Parser.Tactic.case' | Init.Tactics | Lean.ParserDescr | `case'` is similar to the `case tag => tac` tactic, but does not ensure the goal
has been solved after applying `tac`, nor admits the goal if `tac` failed.
Recall that `case` closes the goal using `sorry` when `tac` fails, and
the tactic execution is not interrupted.
Extensions:
* `case' _ : t => tac` is analogous ... | true |
CategoryTheory.Coverage.mk.noConfusion | Mathlib.CategoryTheory.Sites.Coverage | {C : Type u_1} →
{inst : CategoryTheory.Category.{v_1, u_1} C} →
{P : Sort u} →
{toPrecoverage : CategoryTheory.Precoverage C} →
{pullback :
∀ ⦃X Y : C⦄ (f : Y ⟶ X),
∀ S ∈ toPrecoverage.coverings X, ∃ T ∈ toPrecoverage.coverings Y, T.FactorsThruAlong S f} →
{toPre... | null | false |
CategoryTheory.instHasLiftingPropertySnd | Mathlib.CategoryTheory.LiftingProperties.Limits | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {Y Z W : C} {g : Z ⟶ W} {t : Y ⟶ W}
[inst_1 : CategoryTheory.Limits.HasPullback g t] {T₁ T₂ : C} (p : T₁ ⟶ T₂) [CategoryTheory.HasLiftingProperty p g],
CategoryTheory.HasLiftingProperty p (CategoryTheory.Limits.pullback.snd g t) | null | true |
PresheafOfModules.instAddCommGroupModuleColimit._aux_14 | Mathlib.Algebra.Category.ModuleCat.Presheaf.ColimitFunctor | {C : Type u_3} →
[inst : CategoryTheory.Category.{u_2, u_3} C] →
{R : CategoryTheory.Functor Cᵒᵖ RingCat} →
{cR : CategoryTheory.Limits.Cocone R} →
(hcR : CategoryTheory.Limits.IsColimit cR) →
{M : PresheafOfModules R} →
{cM : CategoryTheory.Limits.Cocone M.presheaf} →
... | null | false |
Subsemiring.unop_eq_bot._simp_1 | Mathlib.Algebra.Ring.Subsemiring.MulOpposite | ∀ {R : Type u_2} [inst : NonAssocSemiring R] {S : Subsemiring Rᵐᵒᵖ}, (S.unop = ⊥) = (S = ⊥) | null | false |
MeasureTheory.Measure.addHaarScalarFactor_smul_congr | Mathlib.MeasureTheory.Measure.Haar.Unique | ∀ {G : Type u_1} {A : Type u_2} [inst : Group G] [inst_1 : AddCommGroup A] [inst_2 : DistribMulAction G A]
[inst_3 : MeasurableSpace A] [inst_4 : TopologicalSpace A] [inst_5 : BorelSpace A] [inst_6 : IsTopologicalAddGroup A]
[LocallyCompactSpace A] [inst_8 : ContinuousConstSMul G A] (μ : MeasureTheory.Measure A) {ν... | null | true |
Aesop.ForwardRuleMatches.noConfusionType | Aesop.Tree.Data.ForwardRuleMatches | Sort u → Aesop.ForwardRuleMatches → Aesop.ForwardRuleMatches → Sort u | null | false |
DFinsupp.instLocallyFiniteOrder | Mathlib.Data.DFinsupp.Interval | {ι : Type u_1} →
{α : ι → Type u_2} →
[DecidableEq ι] →
[(i : ι) → DecidableEq (α i)] →
[inst : (i : ι) → PartialOrder (α i)] →
[inst_1 : (i : ι) → Zero (α i)] → [(i : ι) → LocallyFiniteOrder (α i)] → LocallyFiniteOrder (Π₀ (i : ι), α i) | null | true |
NonemptyFinLinOrd.mk | Mathlib.Order.Category.NonemptyFinLinOrd | (toLinOrd : LinOrd) → [nonempty : Nonempty ↑toLinOrd] → [fintype : Fintype ↑toLinOrd] → NonemptyFinLinOrd | null | true |
_private.Init.Data.Format.Basic.0.Std.Format.WorkGroup | Init.Data.Format.Basic | Type | null | true |
instMonoidWithConvMatrix._proof_4 | Mathlib.LinearAlgebra.Matrix.WithConv | ∀ {m : Type u_3} {n : Type u_2} {α : Type u_1} [inst : Monoid α] (a : WithConv (Matrix m n α)), 1 * a = a | null | false |
Order.IsPredPrelimit.lt_sInf_iff | Mathlib.Order.SuccPred.CompleteLinearOrder | ∀ {α : Type u_2} [inst : CompleteLinearOrder α] {s : Set α} {x : α},
Order.IsPredPrelimit x → (x < sInf s ↔ ∃ a, x < a ∧ ∀ b ∈ s, a < b) | Similar to `lt_sInf_iff` but with a stronger RHS, as it requires a strict inequality. | true |
Lean.Elab.Term.Quotation.MatchResult.noConfusion | Lean.Elab.Quotation | {P : Sort u} →
{t t' : Lean.Elab.Term.Quotation.MatchResult} → t = t' → Lean.Elab.Term.Quotation.MatchResult.noConfusionType P t t' | null | false |
Finset.instFintypeSubtypeMemSubgroupInvMulSubgroup._simp_2 | Mathlib.Combinatorics.Additive.VerySmallDoubling | ∀ {α : Type u_2} [inst : DecidableEq α] [inst_1 : Mul α] (s t : Finset α), ↑s * ↑t = ↑(s * t) | null | false |
MulRingSeminormClass.toMonoidHomClass | Mathlib.Algebra.Order.Hom.RingNorm | ∀ {F : Type u_4} {α : outParam (Type u_5)} {β : outParam (Type u_6)} {inst : NonAssocRing α} {inst_1 : Semiring β}
{inst_2 : PartialOrder β} {inst_3 : FunLike F α β} [self : MulRingSeminormClass F α β], MonoidHomClass F α β | null | true |
HomologicalComplex.Hom.isIso_of_components | Mathlib.Algebra.Homology.HomologicalComplex | ∀ {ι : Type u_1} {V : Type u} [inst : CategoryTheory.Category.{v, u} V]
[inst_1 : CategoryTheory.Limits.HasZeroMorphisms V] {c : ComplexShape ι} {C₁ C₂ : HomologicalComplex V c}
(f : C₁ ⟶ C₂) [∀ (n : ι), CategoryTheory.IsIso (f.f n)], CategoryTheory.IsIso f | null | true |
_private.Lean.Meta.Tactic.Grind.EMatchTheorem.0.Lean.Meta.Grind.NormalizePattern.Context.symPrios | Lean.Meta.Tactic.Grind.EMatchTheorem | Lean.Meta.Grind.NormalizePattern.Context✝ → Lean.Meta.Grind.SymbolPriorities | null | true |
exists_seq_strictAnti_strictMono_tendsto | Mathlib.Topology.Order.IsLUB | ∀ {α : Type u_1} [inst : TopologicalSpace α] [inst_1 : LinearOrder α] [OrderTopology α] [DenselyOrdered α]
[FirstCountableTopology α] {x y : α},
x < y →
∃ u v,
StrictAnti u ∧
StrictMono v ∧
(∀ (k : ℕ), u k ∈ Set.Ioo x y) ∧
(∀ (l : ℕ), v l ∈ Set.Ioo x y) ∧
(∀ (k ... | null | true |
Asymptotics.IsLittleO.forall_isBigOWith | Mathlib.Analysis.Asymptotics.Defs | ∀ {α : Type u_1} {E : Type u_2} {F : Type u_3} {f : α → E} {g : α → F} {l : Filter α} [inst : Norm E] [inst_1 : Norm F],
f =o[l] g → ∀ ⦃c : ℝ⦄, 0 < c → Asymptotics.IsBigOWith c l f g | **Alias** of the forward direction of `Asymptotics.isLittleO_iff_forall_isBigOWith`.
---
Definition of `IsLittleO` in terms of `IsBigOWith`. | true |
MvPowerSeries.lexOrder_eq_top_iff_eq_zero._simp_1 | Mathlib.RingTheory.MvPowerSeries.LexOrder | ∀ {σ : Type u_1} {R : Type u_2} [inst : Semiring R] [inst_1 : LinearOrder σ] [inst_2 : WellFoundedGT σ]
(φ : MvPowerSeries σ R), (φ.lexOrder = ⊤) = (φ = 0) | null | false |
_private.Batteries.Data.Fin.Coding.0.Fin.encodeSigma.match_1.splitter | Batteries.Data.Fin.Coding | (n : ℕ) →
(f : Fin (n + 1) → ℕ) →
(motive : Fin (Fin.sum fun x => f x.succ) → Sort u_1) →
(x : Fin (Fin.sum fun x => f x.succ)) →
((k : ℕ) → (hk : k < Fin.sum fun x => f x.succ) → motive ⟨k, hk⟩) → motive x | null | true |
ContinuousMap.instNormedCommRing._proof_2 | Mathlib.Topology.ContinuousMap.Compact | ∀ {α : Type u_1} [inst : TopologicalSpace α] {R : Type u_2} [inst_1 : NormedCommRing R] (a b : C(α, R)), a * b = b * a | null | false |
SSet.Subcomplex.N.mk | Mathlib.AlgebraicTopology.SimplicialSet.NonDegenerateSimplicesSubcomplex | {X : SSet} →
{A : X.Subcomplex} →
{n : ℕ} →
(x : X.obj (Opposite.op { len := n })) → x ∈ X.nonDegenerate n → x ∉ A.obj (Opposite.op { len := n }) → A.N | Constructor for the type of nondegenerate simplices which
do not belong to a given subcomplex of a simplicial set. | true |
em | Mathlib.Basic.Logic.Basic | ∀ (p : Prop), p ∨ ¬p | **Alias** of `Classical.em`. | true |
Mathlib.Tactic.Algebra.RingCompute.add | Mathlib.Tactic.Algebra.Basic | {u v : Lean.Level} →
{R : Q(Type u)} →
{A : Q(Type v)} →
{sR : Q(CommSemiring «$R»)} →
{sA : Q(CommSemiring «$A»)} →
(sAlg : Q(Algebra «$R» «$A»)) →
Mathlib.Tactic.Ring.Common.Cache sR →
{a b : Q(«$A»)} →
Mathlib.Tactic.Algebra.BaseType sAlg a →
... | Evaluate the sum of two normalized expressions in `R` using `ring`. | true |
PolynomialLaw.instAddCommMonoid._proof_4 | Mathlib.RingTheory.PolynomialLaw.Basic | ∀ {R : Type u_1} [inst : CommSemiring R] {M : Type u_2} [inst_1 : AddCommMonoid M] [inst_2 : Module R M] {N : Type u_3}
[inst_3 : AddCommMonoid N] [inst_4 : Module R N] (f : M →ₚₗ[R] N), 0 • f = 0 | null | false |
IntermediateField.LinearDisjoint.adjoin_rank_eq_rank_left_of_isAlgebraic | Mathlib.FieldTheory.LinearDisjoint | ∀ {F : Type u} {E : Type v} [inst : Field F] [inst_1 : Field E] [inst_2 : Algebra F E] {A : IntermediateField F E}
{L : Type w} [inst_3 : Field L] [inst_4 : Algebra F L] [inst_5 : Algebra L E] [inst_6 : IsScalarTower F L E],
A.LinearDisjoint L →
Algebra.IsAlgebraic F ↥A ∨ Algebra.IsAlgebraic F L →
Module.... | If `A` and `L` are linearly disjoint over `F`, one of them is algebraic,
then `[L(A) : L] = [A : F]`. | true |
TwoSidedIdeal.opOrderIso_apply | Mathlib.RingTheory.TwoSidedIdeal.Basic | ∀ {R : Type u_1} [inst : NonUnitalNonAssocRing R] (I : TwoSidedIdeal R), TwoSidedIdeal.opOrderIso I = I.op | null | true |
_private.Mathlib.MeasureTheory.Measure.WithDensity.0.MeasureTheory.withDensity_apply_eq_zero'._simp_1_4 | Mathlib.MeasureTheory.Measure.WithDensity | ∀ {b a : Prop}, (∃ (_ : a), b) = (a ∧ b) | null | false |
Mathlib.Meta.NormNum.proveJacobiSym | Mathlib.Tactic.NormNum.LegendreSymbol | (ea : Q(ℤ)) → (eb : Q(ℕ)) → (er : Q(ℤ)) × Q(jacobiSym «$ea» «$eb» = «$er») | This evaluates `r := jacobiSym a b` and produces a proof term for the equality.
This is done by reducing to `r := jacobiSymNat (a % b) b`. | true |
Std.ExtTreeSet.insertMany_nil | Std.Data.ExtTreeSet.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t : Std.ExtTreeSet α cmp} [inst : Std.TransCmp cmp], t.insertMany [] = t | null | true |
Ideal.count_associates_eq | Mathlib.RingTheory.DedekindDomain.Ideal.Lemmas | ∀ {R : Type u_1} [inst : CommRing R] [inst_1 : IsDedekindDomain R] {a a₀ x : R} {n : ℕ},
Prime x →
¬x ∣ a → a₀ = x ^ n * a → (Associates.mk (Ideal.span {x})).count (Associates.mk (Ideal.span {a₀})).factors = n | Variant of `UniqueFactorizationMonoid.count_normalizedFactors_eq` for associated Ideals. | true |
CategoryTheory.Kleisli.Adjunction.adj._proof_4 | Mathlib.CategoryTheory.Monad.Kleisli | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] (T : CategoryTheory.Monad C) {X : C}
{Y Y' : CategoryTheory.Kleisli T} (f : (CategoryTheory.Kleisli.Adjunction.toKleisli T).obj X ⟶ Y) (g : Y ⟶ Y'),
{ toFun := fun f => f.of, invFun := fun f => { of := f }, left_inv := ⋯, right_inv := ⋯ }
(Categor... | null | false |
Std.DHashMap.mem_of_mem_filter | Std.Data.DHashMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {x : BEq α} {x_1 : Hashable α} {m : Std.DHashMap α β} [EquivBEq α] [LawfulHashable α]
{f : (a : α) → β a → Bool} {k : α}, k ∈ Std.DHashMap.filter f m → k ∈ m | null | true |
Std.DTreeMap.Raw.get?_alter | Std.Data.DTreeMap.Raw.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t : Std.DTreeMap.Raw α β cmp} [Std.TransCmp cmp]
[inst : Std.LawfulEqCmp cmp],
t.WF →
∀ {k k' : α} {f : Option (β k) → Option (β k)},
(t.alter k f).get? k' = if h : cmp k k' = Ordering.eq then cast ⋯ (f (t.get? k)) else t.get? k' | null | true |
ULift.mulAction._proof_1 | Mathlib.Algebra.Module.ULift | ∀ {R : Type u_2} {M : Type u_3} [inst : Monoid R] [inst_1 : MulAction R M] (x x_1 : ULift.{u_1, u_2} R) (b : M),
(x.down * x_1.down) • b = x.down • x_1.down • b | null | false |
Std.DTreeMap.Internal.Impl.Const.getD_diff_of_contains_eq_false_right | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {instOrd : Ord α} {β : Type v} {m₁ m₂ : Std.DTreeMap.Internal.Impl α fun x => β} [Std.TransOrd α]
(h₁ : m₁.WF),
m₂.WF →
∀ {k : α} {fallback : β},
Std.DTreeMap.Internal.Impl.contains k m₂ = false →
Std.DTreeMap.Internal.Impl.Const.getD (m₁.diff m₂ ⋯) k fallback =
Std.DTreeM... | null | true |
AddSubgroup.mk_le_mk._simp_1 | Mathlib.Algebra.Group.Subgroup.Defs | ∀ {G : Type u_1} [inst : AddGroup G] {s t : AddSubmonoid G} (h_neg : ∀ {x : G}, x ∈ s.carrier → -x ∈ s.carrier)
(h_neg' : ∀ {x : G}, x ∈ t.carrier → -x ∈ t.carrier),
({ toAddSubmonoid := s, neg_mem' := h_neg } ≤ { toAddSubmonoid := t, neg_mem' := h_neg' }) = (s ≤ t) | null | false |
EReal.induction₂_symm | Mathlib.Data.EReal.Basic | ∀ {P : EReal → EReal → Prop},
(∀ {x y : EReal}, P x y → P y x) →
P ⊤ ⊤ →
(∀ (x : ℝ), 0 < x → P ⊤ ↑x) →
P ⊤ 0 →
(∀ x < 0, P ⊤ ↑x) →
P ⊤ ⊥ →
(∀ (x : ℝ), 0 < x → P ↑x ⊥) →
(∀ (x y : ℝ), P ↑x ↑y) → P 0 ⊥ → (∀ x < 0, P ↑x ⊥) → P ⊥ ⊥ → ∀ (x y : EReal), P... | Induct on two `EReal`s by performing case splits on the sign of one whenever the other is
infinite. This version eliminates some cases by assuming that the relation is symmetric. | true |
CategoryTheory.MonoidalCategory.Limits.pushout.associator_naturality_left_condition_assoc | Mathlib.CategoryTheory.Monoidal.Limits.Shapes.Pullback | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.MonoidalCategory C]
[inst_2 : CategoryTheory.Limits.HasPushouts C] {A B X Y Z W : C} {f : A ⟶ B} {g : X ⟶ Y}
{h : CategoryTheory.MonoidalCategoryStruct.tensorObj Z W ⟶ X} {Z_1 : C}
(h_1 :
CategoryTheory.Limits.pushout (CategoryT... | null | true |
MDifferentiableOn.clm_bundle_apply₂ | Mathlib.Geometry.Manifold.VectorBundle.Hom | ∀ {𝕜 : Type u_1} {B : Type u_2} {F₁ : Type u_3} {F₂ : Type u_4} {F₃ : Type u_5} {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 : Topological... | Consider differentiable maps `v : M → E₁` and `w : M → E₂` to vector bundles, over a base map
`b : M → B`, and bilinear maps `ψ m : E₁ (b m) → E₂ (b m) → E₃ (b m)` depending smoothly on `m`.
One can apply `ψ m` to `v m` and `w m`, and the resulting map is differentiable.
We give here a version of this statement on a ... | true |
LightProfinite.instInhabited._proof_3 | Mathlib.Topology.Category.LightProfinite.Basic | SecondCountableTopology PEmpty.{u_1 + 1} | null | false |
List.erase_eq_eraseIdx | Init.Data.List.Erase | ∀ {α : Type u_1} [inst : BEq α] (l : List α) (a : α),
l.erase a =
match List.idxOf? a l with
| none => l
| some i => l.eraseIdx i | null | true |
Bool.or_eq_true_iff | Init.Data.Bool | ∀ {x y : Bool}, (x || y) = true ↔ x = true ∨ y = true | null | true |
ContinuousLinearEquiv.symm_comp_self | Mathlib.Topology.Algebra.Module.Equiv.Basic | ∀ {R₁ : Type u_1} {R₂ : Type u_2} [inst : Semiring R₁] [inst_1 : Semiring R₂] {σ₁₂ : R₁ →+* R₂} {σ₂₁ : R₂ →+* R₁}
[inst_2 : RingHomInvPair σ₁₂ σ₂₁] [inst_3 : RingHomInvPair σ₂₁ σ₁₂] {M₁ : Type u_4} [inst_4 : TopologicalSpace M₁]
[inst_5 : AddCommMonoid M₁] {M₂ : Type u_5} [inst_6 : TopologicalSpace M₂] [inst_7 : Ad... | null | true |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.Equiv.getKeyD_eq._simp_1_2 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {instOrd : Ord α} {a b : α}, (compare a b ≠ Ordering.eq) = ((a == b) = false) | null | false |
SSet.isIso_mapFundamentalGroupoid_of_isIso | Mathlib.AlgebraicTopology.SimplicialSet.FundamentalGroupoid.Basic | ∀ {X Y : SSet} (f : X ⟶ Y),
autoParam (CategoryTheory.IsIso ((SSet.truncation 2).map f)) SSet.isIso_mapFundamentalGroupoid_of_isIso._auto_1 →
(SSet.mapFundamentalGroupoid f).IsIso | The isomorphism of fundamental groupoids that is induced
by a morphism of simplicial sets which induces an isomorphism
on the `2`-truncations. | true |
LocallyConstant.instNonAssocSemiring._proof_5 | Mathlib.Topology.LocallyConstant.Algebra | ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] [inst_1 : NonAssocSemiring Y] (x : ℕ)
(x_1 : LocallyConstant X Y), ⇑(x • x_1) = ⇑(x • x_1) | null | false |
_private.Init.Data.Option.Lemmas.0.Option.none_lt._simp_1_1 | Init.Data.Option.Lemmas | ∀ {α : Type u_1} [inst : LT α] {a : α}, (none < some a) = True | null | false |
HomotopicalAlgebra.CofibrantObject.HoCat.adj._proof_2 | Mathlib.AlgebraicTopology.ModelCategory.BifibrantObjectHomotopy | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : HomotopicalAlgebra.ModelCategory C]
(X : HomotopicalAlgebra.BifibrantObject.HoCat C),
CategoryTheory.CategoryStruct.comp
(HomotopicalAlgebra.CofibrantObject.HoCat.adjUnit.app
(HomotopicalAlgebra.BifibrantObject.HoCat.ιCofibrantOb... | null | false |
Interval.addCommMonoid._proof_4 | Mathlib.Algebra.Order.Interval.Basic | ∀ {α : Type u_1} [inst : AddCommMonoid α] [inst_1 : Preorder α] [inst_2 : IsOrderedAddMonoid α] (a : Interval α),
0 + a = a | null | false |
String.contains_slice_iff | Init.Data.String.Lemmas.Pattern.Find.String | ∀ {t : String.Slice} {s : String}, s.contains t = true ↔ t.copy.toList <:+: s.toList | null | true |
cfc_inv | 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] [inst_9 : ContinuousFunctionalCalculus R A p]... | null | true |
Std.TreeMap.getKey?_ofList_of_contains_eq_false | Std.Data.TreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} [Std.TransCmp cmp] [inst : BEq α] [Std.LawfulBEqCmp cmp]
{l : List (α × β)} {k : α}, (List.map Prod.fst l).contains k = false → (Std.TreeMap.ofList l cmp).getKey? k = none | null | true |
CategoryTheory.ShortComplex.ShortExact.exactAt_X₁._auto_3 | Mathlib.Algebra.Homology.HomologySequenceLemmas | Lean.Syntax | null | false |
UInt8.toUSize_ofNat' | Init.Data.UInt.Lemmas | ∀ {n : ℕ}, n < UInt8.size → (UInt8.ofNat n).toUSize = USize.ofNat n | null | true |
ZMod.dft_eq_fourier | Mathlib.Analysis.Fourier.ZMod | ∀ {N : ℕ} [inst : NeZero N] {E : Type u_2} [inst_1 : NormedAddCommGroup E] [inst_2 : NormedSpace ℂ E] [CompleteSpace E]
(Φ : ZMod N → E) (k : ZMod N), ZMod.dft Φ k = Fourier.fourierIntegral ZMod.toCircle MeasureTheory.Measure.count Φ k | The discrete Fourier transform agrees with the general one (assuming the target space is a complete
normed space).
| true |
ContextFreeGrammar.produces_reverse | Mathlib.Computability.ContextFreeGrammar | ∀ {T : Type u_1} {g : ContextFreeGrammar T} {u v : List (Symbol T g.NT)},
g.reverse.Produces u.reverse v.reverse ↔ g.Produces u v | null | true |
_private.Init.Data.List.Lemmas.0.List.mem_map.match_1_1 | Init.Data.List.Lemmas | ∀ {α : Type u_1} (motive : List α → Prop) (x : List α),
(∀ (_ : Unit), motive []) → (∀ (head : α) (l : List α), motive (head :: l)) → motive x | null | false |
Sym2.card_toFinset | Mathlib.Data.Sym.Sym2 | ∀ {α : Type u_1} [inst : DecidableEq α] (z : Sym2 α), z.toFinset.card = if z.IsDiag then 1 else 2 | Mapping an unordered pair to a finite set produces a finset of size `1` if the pair is on the
diagonal, else of size `2` if the pair is off the diagonal. | true |
AffineSpace.vadd_asymptoticNhds | Mathlib.Topology.Algebra.AsymptoticCone | ∀ {k : Type u_1} {V : Type u_2} {P : Type u_3} [inst : Field k] [inst_1 : LinearOrder k] [inst_2 : AddCommGroup V]
[inst_3 : Module k V] [inst_4 : AddTorsor V P] [inst_5 : TopologicalSpace V] (u v : V),
u +ᵥ AffineSpace.asymptoticNhds k P v = AffineSpace.asymptoticNhds k P v | null | true |
_private.Mathlib.RingTheory.Coprime.Basic.0.IsCoprime.isUnit_of_dvd.match_1_1 | Mathlib.RingTheory.Coprime.Basic | ∀ {R : Type u_1} [inst : CommSemiring R] {x y : R} (motive : x ∣ y → Prop) (d : x ∣ y),
(∀ (k : R) (hk : y = x * k), motive ⋯) → motive d | null | false |
SubMulAction.instSetLike.eq_1 | Mathlib.GroupTheory.GroupAction.SubMulAction | ∀ {R : Type u} {M : Type v} [inst : SMul R M],
SubMulAction.instSetLike = { coe := SubMulAction.carrier, coe_injective := ⋯ } | null | true |
_private.Init.Data.List.MapIdx.0.List.length_mapIdx_go._proof_1_6 | Init.Data.List.MapIdx | ∀ {α : Type u_1} {β : Type u_2} (l : List α) (x : Array β), ¬l.length + (x.size + 1) = l.length + 1 + x.size → False | null | false |
subset_sInf_def | Mathlib.Order.CompleteLatticeIntervals | ∀ {α : Type u_2} (s : Set α) [inst : Preorder α] [inst_1 : InfSet α] [inst_2 : Inhabited ↑s],
sInf = fun t =>
if ht : t.Nonempty ∧ BddBelow t ∧ sInf (Subtype.val '' t) ∈ s then ⟨sInf (Subtype.val '' t), ⋯⟩ else default | null | true |
Std.ExtTreeMap.maxKeyD_insert | Std.Data.ExtTreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.ExtTreeMap α β cmp} [inst : Std.TransCmp cmp] {k : α}
{v : β} {fallback : α},
(t.insert k v).maxKeyD fallback = t.maxKey?.elim k fun k' => if (cmp k' k).isLE = true then k else k' | null | true |
FreeAddMagma.below | Mathlib.Algebra.Free | {α : Type u} → {motive : FreeAddMagma α → Sort u_1} → FreeAddMagma α → Sort (max (u + 1) u_1) | null | false |
Subsemiring.nonneg._proof_1 | Mathlib.Algebra.Ring.Subsemiring.Order | ∀ (R : Type u_1) [inst : Semiring R] [inst_1 : PartialOrder R] [IsOrderedRing R], AddLeftMono R | null | false |
Array.popWhile._unsafe_rec | Init.Data.Array.Basic | {α : Type u} → (α → Bool) → Array α → Array α | null | false |
_private.ProofWidgets.Component.RefreshComponent.0.ProofWidgets.RefreshToken.updateLazy.match_1 | ProofWidgets.Component.RefreshComponent | (motive : ProofWidgets.RefreshToken → Sort u_1) →
(x : ProofWidgets.RefreshToken) →
((state : Std.Mutex ProofWidgets.RefreshComponent.RefreshState) →
(cancelTk : IO.CancelToken) →
(promise : IO.Ref (IO.Promise Unit)) → motive { state := state, cancelTk := cancelTk, promise := promise }) →
... | null | false |
_private.Mathlib.Order.Setoid.Partition.Card.0.Setoid.IsPartition.ncard_eq_finsum.match_1_2 | Mathlib.Order.Setoid.Partition.Card | {α : Type u_1} →
{P : Set (Set α)} →
(motive : (_ : ↑P) × α → Sort u_2) → (x : (_ : ↑P) × α) → ((t : ↑P) → (x : α) → motive ⟨t, x⟩) → motive x | null | false |
CategoryTheory.Sigma.natIso_inv | Mathlib.CategoryTheory.Sigma.Basic | ∀ {I : Type w₁} {C : I → Type u₁} [inst : (i : I) → CategoryTheory.Category.{v₁, u₁} (C i)] {D : Type u₂}
[inst_1 : CategoryTheory.Category.{v₂, u₂} D] {q₁ q₂ : CategoryTheory.Functor ((i : I) × C i) D}
(h : (i : I) → (CategoryTheory.Sigma.incl i).comp q₁ ≅ (CategoryTheory.Sigma.incl i).comp q₂),
(CategoryTheory.... | null | true |
CategoryTheory.MorphismProperty.isStableUnderTransfiniteCompositionOfShape_iff | Mathlib.CategoryTheory.MorphismProperty.TransfiniteComposition | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (W : CategoryTheory.MorphismProperty C) (J : Type w)
[inst_1 : LinearOrder J] [inst_2 : SuccOrder J] [inst_3 : OrderBot J] [inst_4 : WellFoundedLT J],
W.IsStableUnderTransfiniteCompositionOfShape J ↔ W.transfiniteCompositionsOfShape J ≤ W | null | true |
NonUnitalRingHom.snd_comp_prod | Mathlib.Algebra.Ring.Prod | ∀ {R : Type u_1} {S : Type u_3} {T : Type u_5} [inst : NonUnitalNonAssocSemiring R]
[inst_1 : NonUnitalNonAssocSemiring S] [inst_2 : NonUnitalNonAssocSemiring T] (f : R →ₙ+* S) (g : R →ₙ+* T),
(NonUnitalRingHom.snd S T).comp (f.prod g) = g | null | true |
_private.Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Unital.0._auto_492 | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Unital | Lean.Syntax | null | false |
MeasureTheory.isFiniteMeasure_toFiniteAux | Mathlib.MeasureTheory.Measure.WithDensityFinite | ∀ {α : Type u_1} {mα : MeasurableSpace α} {μ : MeasureTheory.Measure α} [inst : MeasureTheory.SFinite μ],
MeasureTheory.IsFiniteMeasure μ.toFiniteAux | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.