name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
_private.Batteries.Data.Array.Scan.0.Array.scanrM.loop_toList._proof_1_4 | Batteries.Data.Array.Scan | ∀ {α : Type u_1} {as : Array α} (n : ℕ) {stop start : ℕ}, start - stop = n + 1 → ¬stop < start → False | null | false |
Equiv.sumSigmaDistrib_symm_apply | Mathlib.Logic.Equiv.Sum | ∀ {α : Type u_10} {β : Type u_11} (t : α ⊕ β → Type u_9) (a : (i : α) × t (Sum.inl i) ⊕ (i : β) × t (Sum.inr i)),
(Equiv.sumSigmaDistrib t).symm a = Sum.elim (fun a => ⟨Sum.inl a.fst, a.snd⟩) (fun b => ⟨Sum.inr b.fst, b.snd⟩) a | null | true |
MonoidWithZeroHom.ValueGroup₀.instIsOrderedMonoid | Mathlib.Algebra.Order.GroupWithZero.Range | ∀ {A : Type u_1} {B : Type u_2} [inst : MonoidWithZero A] [inst_1 : LinearOrderedCommGroupWithZero B] {f : A →*₀ B},
IsOrderedMonoid f.ValueGroup₀ | null | true |
_private.Mathlib.Order.Atoms.0.IsAtomic.Set.Iic.isAtomic.match_1 | Mathlib.Order.Atoms | ∀ {α : Type u_1} [inst : PartialOrder α] [inst_1 : OrderBot α] (y : α) (motive : (∃ a, IsAtom a ∧ a ≤ y) → Prop)
(x : ∃ a, IsAtom a ∧ a ≤ y), (∀ (a : α) (ha : IsAtom a) (hay : a ≤ y), motive ⋯) → motive x | null | false |
Lean.Widget.RpcEncodablePacket.«_@».Lean.Widget.InteractiveGoal.562241082._hygCtx._hyg.1.rec | Lean.Widget.InteractiveGoal | {motive : Lean.Widget.RpcEncodablePacket✝ → Sort u} →
((names fvarIds type : Lean.Json) →
(val? isInstance? isType? isInserted? isRemoved? : Option Lean.Json) →
motive
{ names := names, fvarIds := fvarIds, type := type, val? := val?, isInstance? := isInstance?,
isType? := isType?, ... | null | false |
Int.sub_lt_self | Init.Data.Int.Order | ∀ (a : ℤ) {b : ℤ}, 0 < b → a - b < a | null | true |
Commute.eq | Mathlib.Algebra.Group.Semigroup | ∀ {M : Type u_2} [inst : Mul M] {a b : M}, Commute a b → a * b = b * a | Equality behind `Commute a b`; useful for rewriting. | true |
AddSubmonoid.addUnitsEquivAddUnitsType._proof_3 | Mathlib.Algebra.Group.Submonoid.Units | ∀ {M : Type u_1} [inst : AddMonoid M] (S : AddSubmonoid M),
Function.LeftInverse (fun x => ⟨{ val := ↑↑x, neg := ↑↑(-x), val_neg := ⋯, neg_val := ⋯ }, ⋯⟩) fun x =>
match x with
| ⟨val, h⟩ =>
{ val := ⟨(AddUnits.coeHom M) val, ⋯⟩, neg := ⟨(AddUnits.coeHom M) (-val), ⋯⟩, val_neg := ⋯, neg_val := ⋯ } | null | false |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.get?_eq_some_iff._simp_1_3 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {x : Ord α} {t : Std.DTreeMap.Internal.Impl α β} {k : α},
(k ∈ t) = (Std.DTreeMap.Internal.Impl.contains k t = true) | null | false |
_private.Batteries.Data.List.Lemmas.0.List.getElem_filter_eq_getElem_getElem_findIdxs_sub._proof_1_30 | Batteries.Data.List.Lemmas | ∀ {α : Type u_1} {p : α → Bool} (head : α) (tail : List α) {i : ℕ} (s : ℕ),
i < (List.filter p (head :: tail)).length → p head = true → -1 * ↑i + 1 ≤ 0 → i - 1 < (List.filter p tail).length | null | false |
TensorProduct.smul_tmul | Mathlib.LinearAlgebra.TensorProduct.Defs | ∀ {R : Type u_1} {R' : Type u_2} [inst : CommSemiring R] [inst_1 : Monoid R'] {M : Type u_5} {N : Type u_6}
[inst_2 : AddCommMonoid M] [inst_3 : AddCommMonoid N] [inst_4 : DistribMulAction R' M] [inst_5 : Module R M]
[inst_6 : Module R N] [inst_7 : DistribMulAction R' N] [TensorProduct.CompatibleSMul R R' M N] (r :... | `smul` can be moved from one side of the product to the other . | true |
RBTree.RBNode.IsCut.lt_trans | Batteries.Recycling.RBTree.Lemmas | ∀ {α : Type u_1} {cmp : α → α → Ordering} {cut : α → Ordering} {x y : α} [RBTree.RBNode.IsCut cmp cut]
[Std.TransCmp cmp], cmp x y = Ordering.lt → cut x = Ordering.lt → cut y = Ordering.lt | null | true |
_private.Mathlib.RingTheory.Polynomial.Resultant.Basic.0.Polynomial.resultant_add_mul_monomial_right._proof_1_25 | Mathlib.RingTheory.Polynomial.Resultant.Basic | ∀ (m n k : ℕ) (j₁ : Fin (m + n)) (j₂ : Fin m),
(↑j₂ ≤ ↑j₁ ∧ ↑j₁ ≤ ↑j₂ + n) ∧ k ≤ ↑j₁ - ↑j₂ → ¬(↑j₂ + k ≤ ↑j₁ ∧ ↑j₁ ≤ ↑j₂ + (k + m)) → m < ↑j₁ - ↑j₂ - k | null | false |
Mathlib.Tactic.Translate.TranslationInfo.recOn | Mathlib.Tactic.Translate.Expr | {motive : Mathlib.Tactic.Translate.TranslationInfo → Sort u} →
(t : Mathlib.Tactic.Translate.TranslationInfo) →
((translation : Lean.Name) →
(reorder : Mathlib.Tactic.Translate.Reorder) →
(relevantArg : Mathlib.Tactic.Translate.RelevantArg) →
(unfold : Bool) →
motive { ... | null | false |
MeasurableSet.mem | Mathlib.MeasureTheory.MeasurableSpace.Constructions | ∀ {α : Type u_1} {s : Set α} [inst : MeasurableSpace α], MeasurableSet s → Measurable fun x => x ∈ s | **Alias** of the reverse direction of `measurable_mem`. | true |
_private.Mathlib.Geometry.Euclidean.Volume.MeasureSimplex.0.Affine.Simplex.euclideanHausdorffMeasure_closedInterior._simp_1_2 | Mathlib.Geometry.Euclidean.Volume.MeasureSimplex | ∀ (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] (p₁ p₂ : P), k ∙ (p₁ -ᵥ p₂) = vectorSpan k {p₁, p₂} | null | false |
dist_pi_const_le | Mathlib.Topology.MetricSpace.Pseudo.Pi | ∀ {α : Type u_1} {β : Type u_2} [inst : PseudoMetricSpace α] [inst_1 : Fintype β] (a b : α),
(dist (fun x => a) fun x => b) ≤ dist a b | null | true |
Lean.Meta.Sym.isGrindGadget | Lean.Meta.Sym.AlphaShareCommon | Lean.Name → Bool | Returns `true` if `declName` is the name of a grind helper declaration that
should not be unfolded by `unfoldReducible`. `Grind.EqMatch`, `Grind.MatchCond`, `Grind.nestedReducible`
are `abbrev`s, but they are gadgets that must survive until the corresponding
propagators consume them.
| true |
_private.Mathlib.Topology.Algebra.Polynomial.0.Polynomial.coeff_le_of_roots_le._simp_1_1 | Mathlib.Topology.Algebra.Polynomial | ∀ {α : Type u_1} {β : Type v} {f : α → β} {b : β} {s : Multiset α}, (b ∈ Multiset.map f s) = ∃ a ∈ s, f a = b | null | false |
_private.Mathlib.Analysis.InnerProductSpace.Defs.0.InnerProductSpace.Core.«_aux_Mathlib_Analysis_InnerProductSpace_Defs___macroRules__private_Mathlib_Analysis_InnerProductSpace_Defs_0_InnerProductSpace_Core_term_†_1» | Mathlib.Analysis.InnerProductSpace.Defs | Lean.Macro | null | false |
Real.sign_eq_zero_iff._simp_1 | Mathlib.Basic.Real.Sign | ∀ {r : ℝ}, (r.sign = 0) = (r = 0) | null | false |
minimal_nonempty_open_eq_singleton | Mathlib.Topology.Separation.Basic | ∀ {X : Type u_1} [inst : TopologicalSpace X] [T0Space X] {s : Set X},
IsOpen s → s.Nonempty → (∀ t ⊆ s, t.Nonempty → IsOpen t → t = s) → ∃ x, s = {x} | null | true |
left_iff_dite_iff | Init.PropLemmas | ∀ {p : Prop} [inst : Decidable p] {x : Prop} {y : ¬p → Prop}, (x ↔ if h : p then x else y h) ↔ ∀ (h : ¬p), x ↔ y h | null | true |
GradedMonoid.list_prod_map_eq_dProd | Mathlib.Algebra.GradedMonoid | ∀ {ι : Type u_1} {α : Type u_2} {A : ι → Type u_3} [inst : AddMonoid ι] [inst_1 : GradedMonoid.GMonoid A] (l : List α)
(f : α → GradedMonoid A),
(List.map f l).prod =
GradedMonoid.mk (l.dProdIndex fun i => (f i).fst) (l.dProd (fun i => (f i).fst) fun i => (f i).snd) | A variant of `GradedMonoid.mk_list_dProd` for rewriting in the other direction. | true |
CategoryTheory.IsPullback.of_hasPullback | Mathlib.CategoryTheory.Limits.Shapes.Pullback.IsPullback.Defs | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {X Y Z : C} (f : X ⟶ Z) (g : Y ⟶ Z)
[inst_1 : CategoryTheory.Limits.HasPullback f g],
CategoryTheory.IsPullback (CategoryTheory.Limits.pullback.fst f g) (CategoryTheory.Limits.pullback.snd f g) f g | The pullback provided by `HasPullback f g` fits into an `IsPullback`. | true |
ProbabilityTheory.Kernel.IndepFun.comp | Mathlib.Probability.Independence.Kernel.IndepFun | ∀ {α : Type u_1} {Ω : Type u_2} {β : Type u_4} {β' : Type u_5} {γ : Type u_6} {γ' : Type u_7} {mα : MeasurableSpace α}
{mΩ : MeasurableSpace Ω} {κ : ProbabilityTheory.Kernel α Ω} {μ : MeasureTheory.Measure α} {f : Ω → β} {g : Ω → β'}
{mβ : MeasurableSpace β} {mβ' : MeasurableSpace β'} {mγ : MeasurableSpace γ} {mγ' ... | null | true |
_private.Std.Data.Internal.List.Associative.0.Std.Internal.List.getKey_eraseKey._simp_1_1 | Std.Data.Internal.List.Associative | ∀ {α : Type u} {β : α → Type v} [inst : BEq α] {l : List ((a : α) × β a)} {a : α}
(h : Std.Internal.List.containsKey a l = true), some (Std.Internal.List.getKey a l h) = Std.Internal.List.getKey? a l | null | false |
CategoryTheory.Under.pushout_obj | Mathlib.CategoryTheory.Comma.Over.Pullback | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y : C} (f : X ⟶ Y)
[inst_1 : CategoryTheory.Limits.HasPushoutsAlong f] (x : CategoryTheory.Under X),
(CategoryTheory.Under.pushout f).obj x = CategoryTheory.Under.mk (CategoryTheory.Limits.pushout.inr x.hom f) | null | true |
Order.height_toDual | Mathlib.Order.KrullDimension | ∀ {α : Type u_1} [inst : Preorder α] (x : α), Order.height (OrderDual.toDual x) = Order.coheight x | null | true |
AddLocalization.ind | Mathlib.GroupTheory.MonoidLocalization.Basic | ∀ {M : Type u_1} [inst : AddCommMonoid M] {S : AddSubmonoid M} {p : AddLocalization S → Prop},
(∀ (y : M × ↥S), p (AddLocalization.mk y.1 y.2)) → ∀ (x : AddLocalization S), p x | null | true |
ProbabilityTheory.Kernel.partialTraj_comp_partialTraj | Mathlib.Probability.Kernel.IonescuTulcea.PartialTraj | ∀ {X : ℕ → Type u_1} {mX : (n : ℕ) → MeasurableSpace (X n)} {a b c : ℕ}
{κ : (n : ℕ) → ProbabilityTheory.Kernel ((i : ↥(Finset.Iic n)) → X ↑i) (X (n + 1))},
a ≤ b →
b ≤ c →
(ProbabilityTheory.Kernel.partialTraj κ b c).comp (ProbabilityTheory.Kernel.partialTraj κ a b) =
ProbabilityTheory.Kernel.par... | Given the trajectory up to time `a`, `partialTraj κ a b` gives the distribution of
the trajectory up to time `b`. Then plugging this into `partialTraj κ b c` gives
the distribution of the trajectory up to time `c`. | true |
Ordinal.bsup_le | Mathlib.SetTheory.Ordinal.Family | ∀ {o : Ordinal.{u}} {f : (b : Ordinal.{u}) → b < o → Ordinal.{max u v}} {a : Ordinal.{max u v}},
(∀ (i : Ordinal.{u}) (h : i < o), f i h ≤ a) → o.bsup f ≤ a | null | true |
_private.Mathlib.RingTheory.Coalgebra.CoassocSimps.0.CoassocSimps.coassoc_left._simp_1_1 | Mathlib.RingTheory.Coalgebra.CoassocSimps | ∀ {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), TensorProduct.map LinearMap.id f = LinearMap.lTensor M f | null | false |
Lean.Elab.TacticInfo.goalsBefore | Lean.Elab.InfoTree.Types | Lean.Elab.TacticInfo → List Lean.MVarId | null | true |
RingOfIntegers.exponent | Mathlib.NumberTheory.NumberField.Ideal.KummerDedekind | {K : Type u_1} → [inst : Field K] → NumberField.RingOfIntegers K → ℕ | The smallest positive integer `d` contained in the conductor of `θ`. It is the smallest integer
such that `d • 𝓞 K ⊆ ℤ[θ]`, see `exponent_eq_sInf`. It is set to `0` if `d` does not exists.
| true |
ContMDiff.piecewise | 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... | Given two `C^n` functions `f` and `g` which coincide locally around the frontier of a set `s`,
then the piecewise function defined using `f` on `s` and `g` elsewhere is `C^n`. | true |
FirstOrder.Language.mk.injEq | Mathlib.ModelTheory.Basic | ∀ (Functions : ℕ → Type u) (Relations : ℕ → Type v) (Functions_1 : ℕ → Type u) (Relations_1 : ℕ → Type v),
({ Functions := Functions, Relations := Relations } = { Functions := Functions_1, Relations := Relations_1 }) =
(Functions = Functions_1 ∧ Relations = Relations_1) | null | true |
Mathlib.Tactic.Linarith.LinarithConfig.splitHypotheses._default | Mathlib.Tactic.Linarith.Frontend | Bool | null | false |
TopologicalAddGroup.IsSES.pushforward_def | Mathlib.MeasureTheory.Measure.Haar.Extension | ∀ {A : Type u_1} {B : Type u_2} {C : Type u_3} {E : Type u_4} [inst : AddGroup A] [inst_1 : AddGroup B]
[inst_2 : AddGroup C] [inst_3 : TopologicalSpace A] [inst_4 : TopologicalSpace B] [inst_5 : TopologicalSpace C]
{φ : A →+ B} {ψ : B →+ C} (H : TopologicalAddGroup.IsSES φ ψ) [inst_6 : IsTopologicalAddGroup A]
[... | null | true |
NonUnitalCommRing.toNonUnitalCommSemiring._proof_2 | Mathlib.Algebra.Ring.Defs | ∀ {α : Type u_1} [s : NonUnitalCommRing α] (a b c : α), a * (b + c) = a * b + a * c | null | false |
Lean.removeRoot | Lean.Data.OpenDecl | Lean.Name → Lean.Name | null | true |
_private.Std.Data.DHashMap.Internal.AssocList.Lemmas.0.Std.DHashMap.Internal.AssocList.Const.alter.match_1.eq_1 | Std.Data.DHashMap.Internal.AssocList.Lemmas | ∀ {β : Type u_1} (motive : Option β → Sort u_2) (h_1 : Unit → motive none) (h_2 : (b : β) → motive (some b)),
(match none with
| none => h_1 ()
| some b => h_2 b) =
h_1 () | null | true |
_private.Mathlib.Algebra.Homology.ExactSequenceFour.0.CategoryTheory.ComposableArrows.Exact.opcyclesIsoCycles_hom_fac._proof_15 | Mathlib.Algebra.Homology.ExactSequenceFour | ∀ {n : ℕ} (k : ℕ),
autoParam (k ≤ n) CategoryTheory.ComposableArrows.Exact.opcyclesIsoCycles_hom_fac._auto_1 → k + 1 + 2 < n + 3 + 1 | null | false |
CategoryTheory.inclusion | Mathlib.CategoryTheory.ConnectedComponents | {J : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} J] →
(j : CategoryTheory.ConnectedComponents J) → CategoryTheory.Functor j.Component (CategoryTheory.Decomposed J) | The inclusion of each component into the decomposed category. This is just `sigma.incl` but having
this abbreviation helps guide typeclass search to get the right category instance on `decomposed J`.
| true |
ContDiffMapSupportedInClass.casesOn | Mathlib.Analysis.Distribution.ContDiffMapSupportedIn | {B : Type u_5} →
{E : Type u_6} →
{F : Type u_7} →
[inst : NormedAddCommGroup E] →
[inst_1 : NormedAddCommGroup F] →
[inst_2 : NormedSpace ℝ E] →
[inst_3 : NormedSpace ℝ F] →
{n : ℕ∞} →
{K : TopologicalSpace.Compacts E} →
[inst_4 ... | null | false |
Lean.Meta.Cache._sizeOf_1 | Lean.Meta.Basic | Lean.Meta.Cache → ℕ | null | false |
_private.Mathlib.Geometry.Manifold.IsManifold.InteriorBoundary.0.DifferentiableAt.mem_interior_convex_of_surjective_fderiv.match_1_1 | Mathlib.Geometry.Manifold.IsManifold.InteriorBoundary | ∀ {E : Type u_2} {H : Type u_1} [inst : NormedAddCommGroup H] [inst_1 : NormedSpace ℝ H] {f : E → H} {x : E} {s : Set H}
(motive : (∃ f_1, ∀ a ∈ interior s, f_1 a < f_1 (f x)) → Prop) (x_1 : ∃ f_1, ∀ a ∈ interior s, f_1 a < f_1 (f x)),
(∀ (F : StrongDual ℝ H) (hF : ∀ a ∈ interior s, F a < F (f x)), motive ⋯) → moti... | null | false |
GradedRingHom.instOne | Mathlib.RingTheory.GradedAlgebra.RingHom | {ι : Type u_1} →
{A : Type u_2} → {σ : Type u_6} → [inst : Semiring A] → [inst_1 : SetLike σ A] → {𝒜 : ι → σ} → One (𝒜 →+*ᵍ 𝒜) | null | true |
ExteriorAlgebra.lift_symm_apply | Mathlib.LinearAlgebra.ExteriorAlgebra.Basic | ∀ (R : Type u1) [inst : CommRing R] {M : Type u2} [inst_1 : AddCommGroup M] [inst_2 : Module R M] {A : Type u_1}
[inst_3 : Semiring A] [inst_4 : Algebra R A] (a : ExteriorAlgebra R M →ₐ[R] A),
(ExteriorAlgebra.lift R).symm a = ⟨a.toLinearMap ∘ₗ CliffordAlgebra.ι 0, ⋯⟩ | null | true |
Mathlib.Tactic.IntervalCases.Methods.bisect._unsafe_rec | Mathlib.Tactic.IntervalCases | Mathlib.Tactic.IntervalCases.Methods →
Lean.MVarId →
Subarray Mathlib.Tactic.IntervalCases.IntervalCasesSubgoal →
Mathlib.Tactic.IntervalCases.Bound →
Mathlib.Tactic.IntervalCases.Bound → Lean.Expr → Lean.Expr → Lean.Expr → Lean.Expr → Lean.Expr → Lean.MetaM Unit | null | false |
_private.Mathlib.NumberTheory.FermatPsp.0.Nat.exists_infinite_pseudoprimes._proof_1_6 | Mathlib.NumberTheory.FermatPsp | ∀ (m : ℕ), 1 < 2 * (m + 2) | null | false |
Mathlib.Tactic.RingNF.RingMode.ctorElimType | Mathlib.Tactic.Ring.RingNF | {motive : Mathlib.Tactic.RingNF.RingMode → Sort u} → ℕ → Sort (max 1 u) | null | false |
Complex.lim_re | Mathlib.Analysis.Complex.Norm | ∀ (f : CauSeq ℂ fun x => ‖x‖), (Complex.cauSeqRe f).lim = f.lim.re | null | true |
enorm_prod_le_of_le | Mathlib.Analysis.Normed.Group.Basic | ∀ {ι : Type u_3} {ε : Type u_7} [inst : TopologicalSpace ε] [inst_1 : ESeminormedCommMonoid ε] (s : Finset ι)
{f : ι → ε} {n : ι → ENNReal}, (∀ b ∈ s, ‖f b‖ₑ ≤ n b) → ‖∏ b ∈ s, f b‖ₑ ≤ ∑ b ∈ s, n b | null | true |
_private.Mathlib.Analysis.Hofer.0._aux_Mathlib_Analysis_Hofer___macroRules__private_Mathlib_Analysis_Hofer_0_termD_1 | Mathlib.Analysis.Hofer | Lean.Macro | null | false |
_private.Mathlib.Data.Nat.Factorization.Basic.0.Nat.Ico_pow_dvd_eq_Ico_of_lt._simp_1_3 | Mathlib.Data.Nat.Factorization.Basic | ∀ {a c b : Prop}, (a ∧ c ↔ b ∧ c) = (c → (a ↔ b)) | null | false |
Lean.Elab.Term.ToDepElimPattern.State | Lean.Elab.Match | Type | null | true |
_private.Mathlib.Order.Directed.0.directedOn_iff_directed._simp_1_5 | Mathlib.Order.Directed | ∀ {b a : Prop}, (∃ (_ : a), b) = (a ∧ b) | null | false |
MonoidHom.CompTriple.IsId.eq_id | Mathlib.Algebra.Group.Hom.CompTypeclasses | ∀ {M : Type u_1} {inst : Monoid M} {σ : M →* M} [self : MonoidHom.CompTriple.IsId σ], σ = MonoidHom.id M | null | true |
Equiv.prodPiEquivSumPi_apply | Mathlib.Logic.Equiv.Prod | ∀ {ι : Type u_9} {ι' : Type u_10} (π : ι → Type u) (π' : ι' → Type u)
(a : ((i : ι) → Sum.elim π π' (Sum.inl i)) × ((i' : ι') → Sum.elim π π' (Sum.inr i'))) (i : ι ⊕ ι'),
(Equiv.prodPiEquivSumPi π π') a i = (Equiv.sumPiEquivProdPi (Sum.elim π π')).symm a i | null | true |
CategoryTheory.Functor.descOfIsLeftKanExtension_fac_app | Mathlib.CategoryTheory.Functor.KanExtension.Basic | ∀ {C : Type u_1} {H : Type u_3} {D : Type u_5} [inst : CategoryTheory.Category.{v_1, u_1} C]
[inst_1 : CategoryTheory.Category.{v_3, u_3} H] [inst_2 : CategoryTheory.Category.{v_5, u_5} D]
(F' : CategoryTheory.Functor D H) {L : CategoryTheory.Functor C D} {F : CategoryTheory.Functor C H}
(α : F ⟶ L.comp F') [inst... | null | true |
CategoryTheory.ShortComplex.LeftHomologyData.copy._proof_5 | Mathlib.Algebra.Homology.ShortComplex.LeftHomology | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{S : CategoryTheory.ShortComplex C} (h : S.LeftHomologyData) {K' : C} (eK : K' ≅ h.K),
CategoryTheory.CategoryStruct.comp
((CategoryTheory.Limits.parallelPair (h.hi.lift (CategoryTheory.Limits.Ke... | null | false |
Lean.Grind.CommRing.Poly.insert.go.induct_unfolding | Init.Grind.Ring.CommSolver | ∀ (k : ℤ) (m : Lean.Grind.CommRing.Mon) (motive : Lean.Grind.CommRing.Poly → Lean.Grind.CommRing.Poly → Prop),
(∀ (k_1 : ℤ),
motive (Lean.Grind.CommRing.Poly.num k_1) (Lean.Grind.CommRing.Poly.add k m (Lean.Grind.CommRing.Poly.num k_1))) →
(∀ (k_1 : ℤ) (m_1 : Lean.Grind.CommRing.Mon) (p : Lean.Grind.CommRin... | null | true |
_private.Mathlib.LinearAlgebra.LinearPMap.0.LinearPMap.graph_map_fst_eq_domain._simp_1_6 | Mathlib.LinearAlgebra.LinearPMap | ∀ {α : Sort u_1} {p : α → Prop} {b : Prop}, (∃ x, p x ∧ b) = ((∃ x, p x) ∧ b) | null | false |
MeasureTheory.exp_neg_llr | Mathlib.MeasureTheory.Measure.LogLikelihoodRatio | ∀ {α : Type u_1} {mα : MeasurableSpace α} {μ ν : MeasureTheory.Measure α} [MeasureTheory.SigmaFinite μ]
[MeasureTheory.SigmaFinite ν],
μ.AbsolutelyContinuous ν → (fun x => Real.exp (-MeasureTheory.llr μ ν x)) =ᵐ[μ] fun x => (ν.rnDeriv μ x).toReal | null | true |
Lean.Compiler.LCNF.CtorFieldInfo.object.injEq | Lean.Compiler.LCNF.ToImpureType | ∀ (i : ℕ) (type : Lean.Expr) (i_1 : ℕ) (type_1 : Lean.Expr),
(Lean.Compiler.LCNF.CtorFieldInfo.object i type = Lean.Compiler.LCNF.CtorFieldInfo.object i_1 type_1) =
(i = i_1 ∧ type = type_1) | null | true |
ContDiff.fourierPowSMulRight | Mathlib.Analysis.Fourier.FourierTransformDeriv | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℂ E] {V : Type u_2} {W : Type u_3}
[inst_2 : NormedAddCommGroup V] [inst_3 : NormedSpace ℝ V] [inst_4 : NormedAddCommGroup W] [inst_5 : NormedSpace ℝ W]
(L : V →L[ℝ] W →L[ℝ] ℝ) {f : V → E} {k : WithTop ℕ∞},
ContDiff ℝ k f → ∀ (n : ℕ), ContDiff ℝ... | null | true |
CategoryTheory.Limits.sigmaConstCokernelCofork_pt | Mathlib.CategoryTheory.Limits.Preserves.SigmaConst | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C] (R : C)
{α : Type u_1} {β : Type u_2} (f : α → β) [inst_2 : CategoryTheory.Limits.HasCoproduct fun x => R]
[inst_3 : CategoryTheory.Limits.HasCoproduct fun x => R] [inst_4 : CategoryTheory.Limits.HasCoproduc... | null | true |
TopModuleCat | Mathlib.Algebra.Category.ModuleCat.Topology.Basic | (R : Type u) → [Ring R] → [TopologicalSpace R] → Type (max u (v + 1)) | The category of topological modules. | true |
AEMeasurable.fun_neg | Mathlib.MeasureTheory.Group.Arithmetic | ∀ {G : Type u_2} {α : Type u_3} [inst : Neg G] [inst_1 : MeasurableSpace G] [MeasurableNeg G] {m : MeasurableSpace α}
{f : α → G} {μ : MeasureTheory.Measure α}, AEMeasurable f μ → AEMeasurable (fun i => -f i) μ | null | true |
Lean.Lsp.Ipc.CallHierarchy.rec_2 | Lean.Data.Lsp.Ipc | {motive_1 : Lean.Lsp.Ipc.CallHierarchy → Sort u} →
{motive_2 : Array Lean.Lsp.Ipc.CallHierarchy → Sort u} →
{motive_3 : List Lean.Lsp.Ipc.CallHierarchy → Sort u} →
((item : Lean.Lsp.CallHierarchyItem) →
(fromRanges : Array Lean.Lsp.Range) →
(children : Array Lean.Lsp.Ipc.CallHierarchy)... | null | false |
CategoryTheory.SmallObject.hasPushouts | Mathlib.CategoryTheory.SmallObject.IsCardinalForSmallObjectArgument | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (I : CategoryTheory.MorphismProperty C) (κ : Cardinal.{w})
[inst_1 : Fact κ.IsRegular] [inst_2 : OrderBot κ.ord.ToType] [I.IsCardinalForSmallObjectArgument κ],
CategoryTheory.Limits.HasPushouts C | null | true |
CategoryTheory.Profunctor.associator._proof_6 | Mathlib.CategoryTheory.Profunctor.Comp | ∀ {C D E F : Type u_1} [inst : CategoryTheory.Category.{u_4, u_1} C] [inst_1 : CategoryTheory.Category.{u_6, u_1} D]
[inst_2 : CategoryTheory.Category.{u_5, u_1} E] [inst_3 : CategoryTheory.Category.{u_3, u_1} F]
(P : CategoryTheory.Profunctor.{max u_2 u_1, u_4, u_6, u_1, u_1} C D)
(Q : CategoryTheory.Profunctor.... | null | false |
AddSubgroup.op.instNormal | Mathlib.Algebra.Group.Subgroup.MulOppositeLemmas | ∀ {G : Type u_2} [inst : AddGroup G] {H : AddSubgroup G} [H.Normal], H.op.Normal | null | true |
LinearMap.BilinForm.apply_apply_same_eq_zero_iff | Mathlib.LinearAlgebra.SesquilinearForm.Basic | ∀ {R : Type u_1} {M : Type u_5} [inst : CommRing R] [inst_1 : LinearOrder R] [IsStrictOrderedRing R]
[inst_3 : AddCommGroup M] [inst_4 : Module R M] (B : LinearMap.BilinForm R M),
(∀ (x : M), 0 ≤ (B x) x) → LinearMap.IsSymm B → ∀ {x : M}, (B x) x = 0 ↔ x ∈ LinearMap.ker B | null | true |
AnalyticAt.comp_of_eq' | Mathlib.Analysis.Analytic.Composition | ∀ {𝕜 : 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] {g : F → G} {f : E → F} {y : F} {x : ... | **Alias** of `AnalyticAt.fun_comp_of_eq`.
---
Eta-expanded form of `AnalyticAt.comp_of_eq`
---
Version of `AnalyticAt.comp` where point equality is a separate hypothesis. | true |
Equiv.piCongr'.eq_1 | Mathlib.Logic.Equiv.Basic | ∀ {α : Sort u_1} {β : Sort u_4} {W : α → Sort w} {Z : β → Sort z} (h₁ : α ≃ β) (h₂ : (b : β) → W (h₁.symm b) ≃ Z b),
h₁.piCongr' h₂ = (h₁.symm.piCongr fun b => (h₂ b).symm).symm | null | true |
Fin.cast_addNat | Init.Data.Fin.Lemmas | ∀ {n : ℕ} (m : ℕ) (i : Fin n), Fin.cast ⋯ (i.addNat m) = Fin.natAdd m i | null | true |
_private.Mathlib.Topology.Metrizable.Uniformity.0.UniformSpace.metrizable_uniformity._simp_1_5 | Mathlib.Topology.Metrizable.Uniformity | ∀ {α : Sort u_1} (a : α), (a = a) = True | null | false |
List.nodup_iff_forall_not_duplicate | Mathlib.Data.List.Duplicate | ∀ {α : Type u_1} {l : List α}, l.Nodup ↔ ∀ (x : α), ¬List.Duplicate x l | null | true |
instLinearOrderEReal._aux_10 | Mathlib.Data.EReal.Basic | DecidableEq EReal | null | false |
LiouvilleWith.sub_nat_iff._simp_1 | Mathlib.NumberTheory.Transcendental.Liouville.LiouvilleWith | ∀ {p x : ℝ} {n : ℕ}, LiouvilleWith p (x - ↑n) = LiouvilleWith p x | null | false |
ImportGraph.Shake.getResetExtraModUses | ImportGraph.Shake.EnvExtension | Lean.Environment →
optParam Lean.EnvExtension.AsyncMode ImportGraph.Shake.extraModUsesAsyncMode →
optParam Lean.Name Lean.Name.anonymous → (List Lean.ExtraModUse × Lean.PHashSet Lean.ExtraModUse) × Lean.Environment | Gets and resets the new extra mod uses in the `extraModUses` extension. Note that the state
does not include imported entries. | true |
Std.TreeMap.Raw.insertMany_list_equiv_foldl | Std.Data.TreeMap.Raw.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t₁ : Std.TreeMap.Raw α β cmp} {l : List (α × β)},
(t₁.insertMany l).Equiv (List.foldl (fun acc p => acc.insert p.1 p.2) t₁ l) | null | true |
CategoryTheory.ObjectProperty.productTo | Mathlib.CategoryTheory.Generator.Basic | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
(P : CategoryTheory.ObjectProperty C) →
(X : C) → [inst_1 : CategoryTheory.Limits.HasProduct (P.productToFamily X)] → X ⟶ ∏ᶜ P.productToFamily X | Given `P : ObjectProperty C` and `X : C`, this is the product of
all the morphisms `X ⟶ Y` such that `P Y` holds. | true |
Finset.zero_mem_neg_add_iff._simp_1 | Mathlib.Algebra.Group.Pointwise.Finset.Basic | ∀ {α : Type u_2} [inst : DecidableEq α] [inst_1 : AddGroup α] {s t : Finset α}, (0 ∈ -t + s) = ¬Disjoint s t | null | false |
Nat.ppred | Mathlib.Data.Nat.PSub | ℕ → Option ℕ | Partial predecessor operation. Returns `ppred n = some m`
if `n = m + 1`, otherwise `none`. | true |
Polynomial.exists_mul_sq_add_linear_part_eq_eval_add | Mathlib.Algebra.Polynomial.Taylor | ∀ {R : Type u_1} [inst : CommSemiring R] (p : Polynomial R) (x y : R),
∃ c, c * y ^ 2 + Polynomial.eval x (Polynomial.derivative p) * y + Polynomial.eval x p = Polynomial.eval (x + y) p | null | true |
String.startsWith_slice_iff | Init.Data.String.Lemmas.Pattern.TakeDrop.String | ∀ {pat : String.Slice} {s : String}, s.startsWith pat = true ↔ pat.copy.toList <+: s.toList | null | true |
Matrix.instNonUnitalRing._proof_1 | Mathlib.Data.Matrix.Mul | ∀ {n : Type u_1} {α : Type u_2} [inst : NonUnitalRing α] (a b : Matrix n n α), a - b = a + -b | null | false |
LinearEquiv._sizeOf_inst | Mathlib.Algebra.Module.Equiv.Defs | {R : Type u_14} →
{S : Type u_15} →
{inst : Semiring R} →
{inst_1 : Semiring S} →
(σ : R →+* S) →
{σ' : S →+* R} →
{inst_2 : RingHomInvPair σ σ'} →
{inst_3 : RingHomInvPair σ' σ} →
(M : Type u_16) →
(M₂ : Type u_17) →
... | null | false |
Cycle.length_nil | Mathlib.Data.List.Cycle | ∀ {α : Type u_1}, Cycle.nil.length = 0 | null | true |
CoxeterSystem.length_eq_one_iff | Mathlib.GroupTheory.Coxeter.Length | ∀ {B : Type u_1} {W : Type u_2} [inst : Group W] {M : CoxeterMatrix B} (cs : CoxeterSystem M W) {w : W},
cs.length w = 1 ↔ ∃ i, w = cs.simple i | null | true |
Multiplicative.mulAction_isPretransitive | Mathlib.Algebra.Group.Action.Pretransitive | ∀ {α : Type u_3} {β : Type u_4} [inst : AddMonoid α] [inst_1 : AddAction α β] [AddAction.IsPretransitive α β],
MulAction.IsPretransitive (Multiplicative α) β | null | true |
LawfulMonadAttach.eq_of_canReturn_pure | Init.Control.Lawful.MonadAttach.Lemmas | ∀ {m : Type u_1 → Type u_2} {α : Type u_1} [inst : Monad m] [inst_1 : MonadAttach m] [LawfulMonad m]
[LawfulMonadAttach m] {a b : α}, MonadAttach.CanReturn (pure a) b → a = b | null | true |
_private.Mathlib.NumberTheory.Padics.Measure.AmiceTransform.0.AbstractMeasure.amiceTransform.eq_1 | Mathlib.NumberTheory.Padics.Measure.AmiceTransform | ∀ {p : ℕ} [inst : Fact (Nat.Prime p)] {R : Type u_1} [inst_1 : CommRing R] [inst_2 : TopologicalSpace R]
[inst_3 : Algebra ℤ_[p] R] [inst_4 : ContinuousSMul ℤ_[p] R] [inst_5 : IsTopologicalRing R],
AbstractMeasure.amiceTransform =
{ toFun := fun μ => PowerSeries.mk fun n => μ (mahler n • 1), map_add' := ⋯, map_... | null | true |
MeasureTheory.integral_prod_swap | Mathlib.MeasureTheory.Integral.Prod | ∀ {α : Type u_1} {β : Type u_2} {E : Type u_3} [inst : MeasurableSpace α] [inst_1 : MeasurableSpace β]
{μ : MeasureTheory.Measure α} {ν : MeasureTheory.Measure β} [inst_2 : NormedAddCommGroup E] [MeasureTheory.SFinite ν]
[inst_4 : NormedSpace ℝ E] [MeasureTheory.SFinite μ] (f : α × β → E),
∫ (z : β × α), f z.swap... | null | true |
Mathlib.Tactic.Linarith.Comp.scale | Mathlib.Tactic.Linarith.Datatypes | Mathlib.Tactic.Linarith.Comp → ℕ → Mathlib.Tactic.Linarith.Comp | `c.scale n` scales the coefficients of `c` by `n`. | true |
mul_le_of_mul_le_left | Mathlib.Algebra.Order.Monoid.Unbundled.Basic | ∀ {α : Type u_1} {a b c d : α} [inst : Mul α] [inst_1 : Preorder α] [MulLeftMono α], a * b ≤ c → d ≤ b → a * d ≤ c | null | true |
div_div_eq_mul_div | Mathlib.Algebra.Group.Basic | ∀ {α : Type u_1} [inst : DivisionMonoid α] (a b c : α), a / (b / c) = a * c / b | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.