name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M |
|---|---|---|
_private.Mathlib.Tactic.NormNum.Result.0.Mathlib.Meta.NormNum.IsNat.to_isInt.match_1_1 | Mathlib.Tactic.NormNum.Result | ∀ {α : Type u_1} [inst : Ring α] (motive : (x : α) → (x_1 : ℕ) → Mathlib.Meta.NormNum.IsNat x x_1 → Prop) (x : α)
(x_1 : ℕ) (x_2 : Mathlib.Meta.NormNum.IsNat x x_1), (∀ (n : ℕ), motive (↑n) n ⋯) → motive x x_1 x_2 |
HomotopicalAlgebra.CofibrantObject.instIsFibrantResolutionObj | Mathlib.AlgebraicTopology.ModelCategory.CofibrantObjectHomotopy | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : HomotopicalAlgebra.ModelCategory C] (X : C)
[HomotopicalAlgebra.IsFibrant X],
HomotopicalAlgebra.IsFibrant (HomotopicalAlgebra.CofibrantObject.HoCat.resolutionObj X) |
Encodable.decodeSigma.match_1 | Mathlib.Logic.Encodable.Basic | (motive : ℕ × ℕ → Sort u_1) → (x : ℕ × ℕ) → ((n₁ n₂ : ℕ) → motive (n₁, n₂)) → motive x |
_private.Mathlib.Data.Rat.Lemmas.0.Rat.add_den_dvd_lcm._simp_1_1 | Mathlib.Data.Rat.Lemmas | ∀ {n : ℕ}, (0 < n) = (n ≠ 0) |
CategoryTheory.MonoidalCategory.MonoidalLeftAction.monoidalOppositeLeftAction_actionAssocIso_mop_mop | Mathlib.CategoryTheory.Monoidal.Action.Opposites | ∀ (C : Type u_1) (D : Type u_2) [inst : CategoryTheory.Category.{v_1, u_1} C]
[inst_1 : CategoryTheory.MonoidalCategory C] [inst_2 : CategoryTheory.Category.{v_2, u_2} D]
[inst_3 : CategoryTheory.MonoidalCategory.MonoidalRightAction C D] (c c' : C) (d : D),
CategoryTheory.MonoidalCategory.MonoidalLeftActionStruct.actionAssocIso { unmop := c } { unmop := c' } d =
CategoryTheory.MonoidalCategory.MonoidalRightActionStruct.actionAssocIso d c' c |
_private.Mathlib.Data.PFun.0.PFun.preimage_asSubtype._simp_1_1 | Mathlib.Data.PFun | ∀ {α : Type u} {β : Type v} {f : α → β} {s : Set β} {a : α}, (a ∈ f ⁻¹' s) = (f a ∈ s) |
_private.Lean.Elab.Syntax.0.Lean.Elab.Term.toParserDescr.processAtom | Lean.Elab.Syntax | Lean.Syntax → Lean.Elab.Term.ToParserDescrM (Lean.Term × ℕ) |
MeasureTheory.Lp.dense_hasCompactSupport_contDiff | Mathlib.Analysis.Normed.Lp.SmoothApprox | ∀ {E : Type u_3} {F : Type u_4} [inst : MeasurableSpace E] [inst_1 : NormedAddCommGroup F]
[inst_2 : NormedAddCommGroup E] [inst_3 : NormedSpace ℝ E] [FiniteDimensional ℝ E] [BorelSpace E]
[inst_6 : NormedSpace ℝ F] {μ : MeasureTheory.Measure E} [MeasureTheory.IsFiniteMeasureOnCompacts μ] {p : ENNReal},
p ≠ ⊤ → ∀ [hp₂ : Fact (1 ≤ p)], Dense {f | ∃ g, ↑↑f =ᵐ[μ] g ∧ HasCompactSupport g ∧ ContDiff ℝ (↑⊤) g} |
_private.Mathlib.Data.Sign.Defs.0.Left.sign_neg._simp_1_1 | Mathlib.Data.Sign.Defs | ∀ {α : Type u} [inst : AddGroup α] [inst_1 : LT α] [AddLeftStrictMono α] {a : α}, (0 < -a) = (a < 0) |
BitVec.msb_eq_true_iff_two_mul_ge | Init.Data.BitVec.Lemmas | ∀ {w : ℕ} {x : BitVec w}, x.msb = true ↔ 2 * x.toNat ≥ 2 ^ w |
_private.Lean.Meta.Tactic.Simp.BuiltinSimprocs.Nat.0._regBuiltin.Nat.reduceBneDiff.declare_175._@.Lean.Meta.Tactic.Simp.BuiltinSimprocs.Nat.1751779906._hygCtx._hyg.20 | Lean.Meta.Tactic.Simp.BuiltinSimprocs.Nat | IO Unit |
Multiset.revzip_powersetAux_perm | Mathlib.Data.Multiset.Powerset | ∀ {α : Type u_1} {l₁ l₂ : List α}, l₁.Perm l₂ → (Multiset.powersetAux l₁).revzip.Perm (Multiset.powersetAux l₂).revzip |
FinEnum.Quotient.enum | Mathlib.Data.FinEnum | {α : Type u} → [FinEnum α] → (s : Setoid α) → [DecidableRel fun x1 x2 => x1 ≈ x2] → FinEnum (Quotient s) |
PrimeSpectrum.subset_vanishingIdeal_zeroLocus | Mathlib.RingTheory.Spectrum.Prime.Basic | ∀ {R : Type u} [inst : CommSemiring R] (s : Set R), s ⊆ ↑(PrimeSpectrum.vanishingIdeal (PrimeSpectrum.zeroLocus s)) |
CategoryTheory.braiding_rightUnitor | Mathlib.CategoryTheory.Monoidal.Braided.Basic | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.MonoidalCategory C]
[inst_2 : CategoryTheory.BraidedCategory C] (X : C),
CategoryTheory.CategoryStruct.comp (β_ (CategoryTheory.MonoidalCategoryStruct.tensorUnit C) X).hom
(CategoryTheory.MonoidalCategoryStruct.rightUnitor X).hom =
(CategoryTheory.MonoidalCategoryStruct.leftUnitor X).hom |
OreLocalization.instCommRing | Mathlib.RingTheory.OreLocalization.Ring | {R : Type u_1} →
[inst : CommRing R] → {S : Submonoid R} → [inst_1 : OreLocalization.OreSet S] → CommRing (OreLocalization S R) |
Polynomial.SplittingFieldAux.algebra | Mathlib.FieldTheory.SplittingField.Construction | (n : ℕ) → {K : Type u} → [inst : Field K] → (f : Polynomial K) → Algebra K (Polynomial.SplittingFieldAux n f) |
Lean.getMaxHeartbeats | Lean.Util.Heartbeats | Lean.CoreM ℕ |
AlgebraicGeometry.PresheafedSpace.id_base | Mathlib.Geometry.RingedSpace.PresheafedSpace | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] (X : AlgebraicGeometry.PresheafedSpace C),
(CategoryTheory.CategoryStruct.id X).base = CategoryTheory.CategoryStruct.id ↑X |
RingHom.IsIntegralElem.of_mul_unit | Mathlib.RingTheory.IntegralClosure.IsIntegralClosure.Basic | ∀ {R : Type u_1} {S : Type u_4} [inst : CommRing R] [inst_1 : CommRing S] (f : R →+* S) (x y : S) (r : R),
f r * y = 1 → f.IsIntegralElem (x * y) → f.IsIntegralElem x |
_private.Mathlib.NumberTheory.ModularForms.JacobiTheta.Bounds.0.HurwitzKernelBounds.exp_lt_aux | Mathlib.NumberTheory.ModularForms.JacobiTheta.Bounds | ∀ {t : ℝ}, 0 < t → Real.exp (-Real.pi * t) < 1 |
Lean.Json.Parser.num | Lean.Data.Json.Parser | Std.Internal.Parsec.String.Parser Lean.JsonNumber |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.minKeyD_eq_fallback._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) |
Part.mod_def | Mathlib.Data.Part | ∀ {α : Type u_1} [inst : Mod α] (a b : Part α),
a % b = do
let y ← a
Part.map (fun x => y % x) b |
CategoryTheory.StrictlyUnitaryPseudofunctor.mk'._proof_1 | Mathlib.CategoryTheory.Bicategory.Functor.StrictlyUnitary | ∀ {B : Type u_6} [inst : CategoryTheory.Bicategory B] {C : Type u_3} [inst_1 : CategoryTheory.Bicategory C]
(S : CategoryTheory.StrictlyUnitaryPseudofunctorCore B C) {a b c : B} (f : a ⟶ b) (x x_1 : b ⟶ c) (η : x ⟶ x_1),
S.map₂ (CategoryTheory.Bicategory.whiskerLeft f η) =
CategoryTheory.CategoryStruct.comp (S.mapComp f x).hom
(CategoryTheory.CategoryStruct.comp (CategoryTheory.Bicategory.whiskerLeft (S.map f) (S.map₂ η))
(S.mapComp f x_1).inv) |
Lean.IR.FnBody.freeIndices | Lean.Compiler.IR.FreeVars | Lean.IR.FnBody → Lean.IR.IndexSet |
CompletelyDistribLattice.MinimalAxioms.mk.sizeOf_spec | Mathlib.Order.CompleteBooleanAlgebra | ∀ {α : Type u} [inst : SizeOf α] (toCompleteLattice : CompleteLattice α)
(iInf_iSup_eq : ∀ {ι : Type u} {κ : ι → Type u} (f : (a : ι) → κ a → α), ⨅ a, ⨆ b, f a b = ⨆ g, ⨅ a, f a (g a)),
sizeOf { toCompleteLattice := toCompleteLattice, iInf_iSup_eq := iInf_iSup_eq } = 1 + sizeOf toCompleteLattice |
Mathlib.Notation3.Matcher | Mathlib.Util.Notation3 | Type |
_private.Std.Sat.AIG.RefVecOperator.Map.0.Std.Sat.AIG.RefVec.map.go_get_aux._simp_1_2 | Std.Sat.AIG.RefVecOperator.Map | ∀ (n : ℕ), (n ≤ n) = True |
Aesop.AddRapp.mk.inj | Aesop.Tree.AddRapp | ∀ {toRuleApplication : Aesop.RuleApplication} {parent : Aesop.GoalRef} {appliedRule : Aesop.RegularRule}
{successProbability : Aesop.Percent} {toRuleApplication_1 : Aesop.RuleApplication} {parent_1 : Aesop.GoalRef}
{appliedRule_1 : Aesop.RegularRule} {successProbability_1 : Aesop.Percent},
{ toRuleApplication := toRuleApplication, parent := parent, appliedRule := appliedRule,
successProbability := successProbability } =
{ toRuleApplication := toRuleApplication_1, parent := parent_1, appliedRule := appliedRule_1,
successProbability := successProbability_1 } →
toRuleApplication = toRuleApplication_1 ∧
parent = parent_1 ∧ appliedRule = appliedRule_1 ∧ successProbability = successProbability_1 |
antivary_inv_left₀._simp_1 | Mathlib.Algebra.Order.Monovary | ∀ {ι : Type u_1} {α : Type u_2} {β : Type u_3} [inst : Semifield α] [inst_1 : LinearOrder α] [IsStrictOrderedRing α]
[inst_3 : LinearOrder β] {f : ι → α} {g : ι → β}, StrongLT 0 f → Antivary f⁻¹ g = Monovary f g |
_private.Init.Core.0.beq_of_eq.match_1_1 | Init.Core | ∀ {α : Type u_1} {a : α} (motive : (b : α) → a = b → Prop) (b : α) (x : a = b),
(∀ (a_1 : Unit), motive a ⋯) → motive b x |
LinearMap.rTensor_id_apply | Mathlib.LinearAlgebra.TensorProduct.Map | ∀ {R : Type u_1} [inst : CommSemiring R] (M : Type u_7) (N : Type u_8) [inst_1 : AddCommMonoid M]
[inst_2 : AddCommMonoid N] [inst_3 : Module R M] [inst_4 : Module R N] (x : TensorProduct R N M),
(LinearMap.rTensor M LinearMap.id) x = x |
ApproximatesLinearOn.mono_num | Mathlib.Analysis.Calculus.InverseFunctionTheorem.ApproximatesLinearOn | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {F : Type u_3} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {f : E → F}
{f' : E →L[𝕜] F} {s : Set E} {c c' : NNReal}, c ≤ c' → ApproximatesLinearOn f f' s c → ApproximatesLinearOn f f' s c' |
Tree.numNodes | Mathlib.Data.Tree.Basic | {α : Type u} → Tree α → ℕ |
RelLowerSet.casesOn | Mathlib.Order.Defs.Unbundled | {α : Type u_1} →
[inst : LE α] →
{P : α → Prop} →
{motive : RelLowerSet P → Sort u} →
(t : RelLowerSet P) →
((carrier : Set α) →
(isRelLowerSet' : IsRelLowerSet carrier P) →
motive { carrier := carrier, isRelLowerSet' := isRelLowerSet' }) →
motive t |
Lean.IR.LitVal._sizeOf_inst | Lean.Compiler.IR.Basic | SizeOf Lean.IR.LitVal |
sigmaAntidiagonalEquivProd.eq_1 | Mathlib.NumberTheory.TsumDivisorsAntidiagonal | sigmaAntidiagonalEquivProd =
{ toFun := fun x => divisorsAntidiagonalFactors x.fst x.snd, invFun := fun x => ⟨⟨↑x.1 * ↑x.2, ⋯⟩, ⟨(↑x.1, ↑x.2), ⋯⟩⟩,
left_inv := sigmaAntidiagonalEquivProd._proof_4, right_inv := sigmaAntidiagonalEquivProd._proof_3 } |
Filter.tendsto_of_subseq_tendsto | Mathlib.Order.Filter.AtTopBot.CountablyGenerated | ∀ {α : Type u_1} {ι : Type u_3} {x : ι → α} {f : Filter α} {l : Filter ι} [l.IsCountablyGenerated],
(∀ (ns : ℕ → ι), Filter.Tendsto ns Filter.atTop l → ∃ ms, Filter.Tendsto (fun n => x (ns (ms n))) Filter.atTop f) →
Filter.Tendsto x l f |
MeasurableEquiv.measurableEmbedding | Mathlib.MeasureTheory.MeasurableSpace.Embedding | ∀ {α : Type u_1} {β : Type u_2} [inst : MeasurableSpace α] [inst_1 : MeasurableSpace β] (e : α ≃ᵐ β),
MeasurableEmbedding ⇑e |
Lean.FuzzyMatching.CharType.separator | Lean.Data.FuzzyMatching | Lean.FuzzyMatching.CharType |
CategoryTheory.MorphismProperty.Comma.lift._proof_5 | Mathlib.CategoryTheory.MorphismProperty.Comma | ∀ {A : Type u_5} [inst : CategoryTheory.Category.{u_3, u_5} A] {B : Type u_6}
[inst_1 : CategoryTheory.Category.{u_4, u_6} B] {T : Type u_8} [inst_2 : CategoryTheory.Category.{u_7, u_8} T]
{L : CategoryTheory.Functor A T} {R : CategoryTheory.Functor B T} {P : CategoryTheory.MorphismProperty T}
{Q : CategoryTheory.MorphismProperty A} {W : CategoryTheory.MorphismProperty B} [inst_3 : Q.IsMultiplicative]
[inst_4 : W.IsMultiplicative] {C : Type u_2} [inst_5 : CategoryTheory.Category.{u_1, u_2} C]
(F : CategoryTheory.Functor C (CategoryTheory.Comma L R)) (hP : ∀ (X : C), P (F.obj X).hom)
(hQ : ∀ {X Y : C} (f : X ⟶ Y), Q (F.map f).left) (hW : ∀ {X Y : C} (f : X ⟶ Y), W (F.map f).right) {X Y Z : C}
(f : X ⟶ Y) (g : Y ⟶ Z),
(let __spread.0 := F.map (CategoryTheory.CategoryStruct.comp f g);
{ toCommaMorphism := __spread.0, prop_hom_left := ⋯, prop_hom_right := ⋯ }) =
CategoryTheory.CategoryStruct.comp
(let __spread.0 := F.map f;
{ toCommaMorphism := __spread.0, prop_hom_left := ⋯, prop_hom_right := ⋯ })
(let __spread.0 := F.map g;
{ toCommaMorphism := __spread.0, prop_hom_left := ⋯, prop_hom_right := ⋯ }) |
IsUnit.mul_left_cancel | Mathlib.Algebra.Group.Units.Basic | ∀ {M : Type u_1} [inst : Monoid M] {a b c : M}, IsUnit a → a * b = a * c → b = c |
_private.Mathlib.Order.Monotone.Defs.0.monotone_prodMk_iff._simp_1_3 | Mathlib.Order.Monotone.Defs | ∀ {α : Sort u_1} {p q : α → Prop}, (∀ (x : α), p x ∧ q x) = ((∀ (x : α), p x) ∧ ∀ (x : α), q x) |
GrpCat.shrinkFunctorMap_app | Mathlib.Algebra.Category.Grp.Shrink | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {F G : CategoryTheory.Functor C GrpCat} (τ : F ⟶ G)
[inst_1 : ∀ (X : C), Small.{w, w'} ↑(F.obj X)] [inst_2 : ∀ (X : C), Small.{w, w'} ↑(G.obj X)] (X : C),
(GrpCat.shrinkFunctorMap τ).app X =
GrpCat.ofHom ((Shrink.mulEquiv.symm.toMonoidHom.comp (GrpCat.Hom.hom (τ.app X))).comp Shrink.mulEquiv.toMonoidHom) |
Int.instNormedCommRing._proof_2 | Mathlib.Analysis.Normed.Ring.Lemmas | ∀ (m n : ℤ), ‖m * n‖ ≤ ‖m‖ * ‖n‖ |
PosNum.decidableDvd | Mathlib.Data.Num.ZNum | DecidableRel fun x1 x2 => x1 ∣ x2 |
_private.Mathlib.RingTheory.WittVector.Basic.0.WittVector.comm_ring_aux₁._proof_4 | Mathlib.RingTheory.WittVector.Basic | ∀ (p : ℕ) (R : Type u_1) [inst : Fact (Nat.Prime p)], WittVector.ghostFun✝ 1 = 1 |
CategoryTheory.Functor.DenseAt | Mathlib.CategoryTheory.Functor.KanExtension.DenseAt | {C : Type u₁} →
{D : Type u₂} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
[inst_1 : CategoryTheory.Category.{v₂, u₂} D] → CategoryTheory.Functor C D → D → Type (max u₁ u₂ v₂) |
_private.Init.Data.UInt.Bitwise.0.UInt32.shiftRight_xor._simp_1_1 | Init.Data.UInt.Bitwise | ∀ {a b : UInt32}, (a = b) = (a.toBitVec = b.toBitVec) |
Aesop.GoalDiff.newGoal | Aesop.RuleTac.GoalDiff | Aesop.GoalDiff → Lean.MVarId |
Set.image_image2_right_anticomm | Mathlib.Data.Set.NAry | ∀ {α : Type u_1} {β : Type u_3} {β' : Type u_4} {γ : Type u_5} {δ : Type u_7} {s : Set α} {t : Set β} {f : α → β' → γ}
{g : β → β'} {f' : β → α → δ} {g' : δ → γ},
(∀ (a : α) (b : β), f a (g b) = g' (f' b a)) → Set.image2 f s (g '' t) = g' '' Set.image2 f' t s |
LinearMap.BilinForm.isAlt_zero._simp_1 | Mathlib.LinearAlgebra.BilinearForm.Properties | ∀ {R : Type u_1} {M : Type u_2} [inst : CommSemiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M],
LinearMap.BilinForm.IsAlt 0 = True |
ProbabilityTheory.iIndepSets.isProbabilityMeasure | Mathlib.Probability.Independence.Basic | ∀ {Ω : Type u_1} {ι : Type u_2} {π : ι → Set (Set Ω)} {x : MeasurableSpace Ω} {μ : MeasureTheory.Measure Ω},
ProbabilityTheory.iIndepSets π μ → MeasureTheory.IsProbabilityMeasure μ |
CategoryTheory.LocalizerMorphism.RightResolution.instCategory | Mathlib.CategoryTheory.Localization.Resolution | {C₁ : Type u_1} →
{C₂ : Type u_2} →
[inst : CategoryTheory.Category.{v_1, u_1} C₁] →
[inst_1 : CategoryTheory.Category.{v_2, u_2} C₂] →
{W₁ : CategoryTheory.MorphismProperty C₁} →
{W₂ : CategoryTheory.MorphismProperty C₂} →
{Φ : CategoryTheory.LocalizerMorphism W₁ W₂} →
{X₂ : C₂} → CategoryTheory.Category.{v_1, max u_1 v_2} (Φ.RightResolution X₂) |
Std.Tactic.BVDecide.BVExpr.bitblast.TwoPowShiftTarget.mk._flat_ctor | Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.ShiftRight | {α : Type} →
[inst : Hashable α] →
[inst_1 : DecidableEq α] →
{aig : Std.Sat.AIG α} →
{w : ℕ} →
(n : ℕ) → aig.RefVec w → aig.RefVec n → ℕ → Std.Tactic.BVDecide.BVExpr.bitblast.TwoPowShiftTarget aig w |
Std.HashSet.Raw.Equiv.refl._simp_1 | Std.Data.HashSet.RawLemmas | ∀ {α : Type u} (m : Std.HashSet.Raw α), m.Equiv m = True |
Lean.IR.VarId.recOn | Lean.Compiler.IR.Basic | {motive : Lean.IR.VarId → Sort u} → (t : Lean.IR.VarId) → ((idx : Lean.IR.Index) → motive { idx := idx }) → motive t |
CategoryTheory.MonoidalCategory.MonoidalLeftAction.monoidalOppositeLeftAction._proof_10 | Mathlib.CategoryTheory.Monoidal.Action.Opposites | ∀ (C : Type u_1) (D : Type u_4) [inst : CategoryTheory.Category.{u_2, u_1} C]
[inst_1 : CategoryTheory.MonoidalCategory C] [inst_2 : CategoryTheory.Category.{u_3, u_4} D]
[inst_3 : CategoryTheory.MonoidalCategory.MonoidalRightAction C D] {c c' : Cᴹᵒᵖ} (c'' : Cᴹᵒᵖ) (f : c ⟶ c') (d : D),
CategoryTheory.MonoidalCategory.MonoidalRightActionStruct.actionHomRight d
(CategoryTheory.MonoidalCategoryStruct.whiskerRight f c'').unmop =
CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCategory.MonoidalRightActionStruct.actionAssocIso d c''.unmop c.unmop).hom
(CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCategory.MonoidalRightActionStruct.actionHomRight
(CategoryTheory.MonoidalCategory.MonoidalRightActionStruct.actionObj d c''.unmop) f.unmop)
(CategoryTheory.MonoidalCategory.MonoidalRightActionStruct.actionAssocIso d c''.unmop c'.unmop).inv) |
Lean.Elab.withEnableInfoTree | Lean.Elab.InfoTree.Main | {m : Type → Type} → {α : Type} → [Monad m] → [Lean.Elab.MonadInfoTree m] → [MonadFinally m] → Bool → m α → m α |
Aesop.SafeRuleResult.postponed | Aesop.Search.Expansion | Aesop.PostponedSafeRule → Aesop.SafeRuleResult |
_private.Init.Data.String.Lemmas.Pattern.String.ForwardSearcher.0.String.Slice.Pattern.Model.ForwardSliceSearcher.prefixFunction_le_iff | Init.Data.String.Lemmas.Pattern.String.ForwardSearcher | ∀ {k : ℕ} {pat : ByteArray} {stackPos : ℕ} {hst : stackPos < pat.size},
String.Slice.Pattern.Model.ForwardSliceSearcher.prefixFunction✝ pat stackPos hst ≤ k ↔
∀ (k' : ℕ),
k < k' → k' ≤ stackPos → ¬String.Slice.Pattern.Model.ForwardSliceSearcher.PartialMatch✝ pat pat k' (stackPos + 1) |
Ordinal.omega_eq_preOmega | Mathlib.SetTheory.Cardinal.Aleph | ∀ (o : Ordinal.{u_1}), Ordinal.omega o = Ordinal.preOmega (Ordinal.omega0 + o) |
Batteries.BinomialHeap.Imp.Heap.foldTreeM._unsafe_rec | Batteries.Data.BinomialHeap.Basic | {m : Type u_1 → Type u_2} →
{β : Type u_1} → {α : Type u_3} → [Monad m] → β → (α → β → β → m β) → Batteries.BinomialHeap.Imp.Heap α → m β |
_private.Mathlib.Analysis.Seminorm.0.Seminorm.isLUB_sSup | Mathlib.Analysis.Seminorm | ∀ {𝕜 : Type u_3} {E : Type u_7} [inst : NormedField 𝕜] [inst_1 : AddCommGroup E] [inst_2 : Module 𝕜 E]
(s : Set (Seminorm 𝕜 E)), BddAbove s → s.Nonempty → IsLUB s (sSup s) |
_private.Mathlib.CategoryTheory.Sites.Closed.0.CategoryTheory.classifier_isSheaf._simp_1_1 | Mathlib.CategoryTheory.Sites.Closed | ∀ {a b : Prop}, (a ∧ b) = (b ∧ a) |
Complex.eventually_eq_or_eq_zero_of_isLocalMin_norm | Mathlib.Analysis.Complex.AbsMax | ∀ {E : Type u} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℂ E] {f : E → ℂ} {c : E},
(∀ᶠ (z : E) in nhds c, DifferentiableAt ℂ f z) → IsLocalMin (norm ∘ f) c → (∀ᶠ (z : E) in nhds c, f z = f c) ∨ f c = 0 |
ModuleCat.restrictScalarsEquivalenceOfRingEquiv._proof_5 | Mathlib.Algebra.Category.ModuleCat.ChangeOfRings | ∀ {S : Type u_2} [inst : Ring S] (M : ModuleCat S) (x y : ↑M),
(AddEquiv.refl ↑M).toFun (x + y) = (AddEquiv.refl ↑M).toFun x + (AddEquiv.refl ↑M).toFun y |
Associates.factors_eq_some_iff_ne_zero | Mathlib.RingTheory.UniqueFactorizationDomain.FactorSet | ∀ {α : Type u_1} [inst : CommMonoidWithZero α] [inst_1 : UniqueFactorizationMonoid α] {a : Associates α},
(∃ s, a.factors = ↑s) ↔ a ≠ 0 |
Fin.ne_zero_of_lt | Mathlib.Data.Fin.Basic | ∀ {n : ℕ} {a b : Fin (n + 1)}, a < b → b ≠ 0 |
ENNReal.lt_add_of_sub_lt_left | Mathlib.Data.ENNReal.Operations | ∀ {a b c : ENNReal}, a ≠ ⊤ ∨ b ≠ ⊤ → a - b < c → a < b + c |
Set.subsingleton_univ_iff | Mathlib.Data.Set.Subsingleton | ∀ {α : Type u}, Set.univ.Subsingleton ↔ Subsingleton α |
_private.Mathlib.Analysis.Convex.Quasiconvex.0.QuasilinearOn.monotoneOn_or_antitoneOn._simp_1_1 | Mathlib.Analysis.Convex.Quasiconvex | ∀ {α : Type u_1} {β : Type u_2} [inst : LinearOrder α] [inst_1 : LinearOrder β] {f : α → β} {s : Set α},
(MonotoneOn f s ∨ AntitoneOn f s) = ∀ a ∈ s, ∀ b ∈ s, ∀ c ∈ s, c ∈ Set.uIcc a b → f c ∈ Set.uIcc (f a) (f b) |
Submonoid.mem_map._simp_2 | Mathlib.Algebra.Group.Submonoid.Operations | ∀ {M : Type u_1} {N : Type u_2} [inst : MulOneClass M] [inst_1 : MulOneClass N] {F : Type u_4} [inst_2 : FunLike F M N]
[mc : MonoidHomClass F M N] {f : F} {S : Submonoid M} {y : N}, (y ∈ Submonoid.map f S) = ∃ x ∈ S, f x = y |
MeasureTheory.ProbabilityMeasure.eq_of_forall_apply_eq | Mathlib.MeasureTheory.Measure.ProbabilityMeasure | ∀ {Ω : Type u_1} [inst : MeasurableSpace Ω] (μ ν : MeasureTheory.ProbabilityMeasure Ω),
(∀ (s : Set Ω), MeasurableSet s → μ s = ν s) → μ = ν |
_private.Init.Grind.Module.NatModuleNorm.0.Lean.Grind.Linarith.Expr.denoteN.match_1.splitter | Init.Grind.Module.NatModuleNorm | (motive : Lean.Grind.Linarith.Expr → Sort u_1) →
(x : Lean.Grind.Linarith.Expr) →
((a b : Lean.Grind.Linarith.Expr) → motive (a.sub b)) →
((a : Lean.Grind.Linarith.Expr) → motive a.neg) →
((k : ℤ) → (a : Lean.Grind.Linarith.Expr) → motive (Lean.Grind.Linarith.Expr.intMul k a)) →
(Unit → motive Lean.Grind.Linarith.Expr.zero) →
((v : Lean.Grind.Linarith.Var) → motive (Lean.Grind.Linarith.Expr.var v)) →
((a b : Lean.Grind.Linarith.Expr) → motive (a.add b)) →
((k : ℕ) → (a : Lean.Grind.Linarith.Expr) → motive (Lean.Grind.Linarith.Expr.natMul k a)) → motive x |
CategoryTheory.Monad.Algebra.ctorIdx | Mathlib.CategoryTheory.Monad.Algebra | {C : Type u₁} → {inst : CategoryTheory.Category.{v₁, u₁} C} → {T : CategoryTheory.Monad C} → T.Algebra → ℕ |
Lean.MetavarContext.MkBinding.Context.mk.sizeOf_spec | Lean.MetavarContext | ∀ (quotContext : Lean.Name) (preserveOrder : Bool) (binderInfoForMVars : Lean.BinderInfo)
(mvarIdsToAbstract : Lean.MVarIdSet),
sizeOf
{ quotContext := quotContext, preserveOrder := preserveOrder, binderInfoForMVars := binderInfoForMVars,
mvarIdsToAbstract := mvarIdsToAbstract } =
1 + sizeOf quotContext + sizeOf preserveOrder + sizeOf binderInfoForMVars + sizeOf mvarIdsToAbstract |
_private.Mathlib.MeasureTheory.Integral.Bochner.Basic.0.MeasureTheory.integral_eq_iff_of_ae_le._simp_1_1 | Mathlib.MeasureTheory.Integral.Bochner.Basic | ∀ {G : Type u_3} [inst : AddGroup G] {a b : G}, (a - b = 0) = (a = b) |
quasiIso_comp | Mathlib.Algebra.Homology.QuasiIso | ∀ {ι : Type u_1} {C : Type u} [inst : CategoryTheory.Category.{v, u} C]
[inst_1 : CategoryTheory.Limits.HasZeroMorphisms C] {c : ComplexShape ι} {K L M : HomologicalComplex C c} (φ : K ⟶ L)
(φ' : L ⟶ M) [inst_2 : ∀ (i : ι), K.HasHomology i] [inst_3 : ∀ (i : ι), L.HasHomology i]
[inst_4 : ∀ (i : ι), M.HasHomology i] [hφ : QuasiIso φ] [hφ' : QuasiIso φ'],
QuasiIso (CategoryTheory.CategoryStruct.comp φ φ') |
Lean.Elab.Tactic.Conv.PatternMatchState.ctorElim | Lean.Elab.Tactic.Conv.Pattern | {motive : Lean.Elab.Tactic.Conv.PatternMatchState → Sort u} →
(ctorIdx : ℕ) →
(t : Lean.Elab.Tactic.Conv.PatternMatchState) →
ctorIdx = t.ctorIdx → Lean.Elab.Tactic.Conv.PatternMatchState.ctorElimType ctorIdx → motive t |
IO.Process.Stdio.rec | Init.System.IO | {motive : IO.Process.Stdio → Sort u} →
motive IO.Process.Stdio.piped →
motive IO.Process.Stdio.inherit → motive IO.Process.Stdio.null → (t : IO.Process.Stdio) → motive t |
_private.Mathlib.Order.Minimal.0.minimal_subtype._simp_1_2 | Mathlib.Order.Minimal | ∀ {α : Type u_2} [inst : LE α] {p : α → Prop} {x y : α} {hx : p x} {hy : p y}, (⟨x, hx⟩ ≤ ⟨y, hy⟩) = (x ≤ y) |
Finset.card_mul_cast_divConst | Mathlib.Combinatorics.Additive.DoublingConst | ∀ {G : Type u_1} [inst : Group G] [inst_1 : DecidableEq G] {𝕜 : Type u_3} [inst_2 : Semifield 𝕜] [CharZero 𝕜]
(A B : Finset G), ↑A.card * ↑(A.divConst B) = ↑(A / B).card |
Lean.Elab.Term.MVarErrorKind | Lean.Elab.Term.TermElabM | Type |
Rat.cast_inv._simp_1 | Mathlib.Data.Rat.Cast.CharZero | ∀ {α : Type u_3} [inst : DivisionRing α] [CharZero α] (p : ℚ), (↑p)⁻¹ = ↑p⁻¹ |
CategoryTheory.Pseudofunctor.Grothendieck.category._proof_5 | Mathlib.CategoryTheory.Bicategory.Grothendieck | ∀ {𝒮 : Type u_3} [inst : CategoryTheory.Category.{u_1, u_3} 𝒮]
{F : CategoryTheory.Pseudofunctor (CategoryTheory.LocallyDiscrete 𝒮) CategoryTheory.Cat} {W X Y Z : F.Grothendieck}
(f : W ⟶ X) (g : X ⟶ Y) (h : Y ⟶ Z),
CategoryTheory.CategoryStruct.comp (CategoryTheory.CategoryStruct.comp f g) h =
CategoryTheory.CategoryStruct.comp f (CategoryTheory.CategoryStruct.comp g h) |
FourierModule.casesOn | Mathlib.Analysis.Fourier.Notation | {R : Type u_5} →
{E : Type u_6} →
{F : Type u_7} →
[inst : Add E] →
[inst_1 : Add F] →
[inst_2 : SMul R E] →
[inst_3 : SMul R F] →
{motive : FourierModule R E F → Sort u} →
(t : FourierModule R E F) →
((toFourierTransform : FourierTransform E F) →
(fourier_add :
∀ (f g : E),
FourierTransform.fourier (f + g) =
FourierTransform.fourier f + FourierTransform.fourier g) →
(fourier_smul :
∀ (r : R) (f : E), FourierTransform.fourier (r • f) = r • FourierTransform.fourier f) →
motive
{ toFourierTransform := toFourierTransform, fourier_add := fourier_add,
fourier_smul := fourier_smul }) →
motive t |
Projectivization.orthogonal._proof_1 | Mathlib.LinearAlgebra.Projectivization.Constructions | ∀ {F : Type u_1} [inst : Field F] {m : Type u_2} [inst_1 : Fintype m] (x x_1 x_2 x_3 : { v // v ≠ 0 }),
x ≈ x_2 → x_1 ≈ x_3 → (↑x ⬝ᵥ ↑x_1 = 0) = (↑x_2 ⬝ᵥ ↑x_3 = 0) |
_private.Mathlib.NumberTheory.NumberField.Units.DirichletTheorem.0.NumberField.Units.dirichletUnitTheorem.logEmbedding_component_le._simp_1_2 | Mathlib.NumberTheory.NumberField.Units.DirichletTheorem | ∀ {α : Type u_2} {β : Type u_3} [inst : SemilatticeSup α] [inst_1 : OrderBot α] {s : Finset β} {f : β → α} {a : α},
(s.sup f ≤ a) = ∀ b ∈ s, f b ≤ a |
Algebra.Extension.Hom.sub._simp_2 | Mathlib.RingTheory.Extension.Cotangent.Basic | ∀ {R : Type u} [inst : CommRing R] (I : Ideal R) (x : ↥I), (I.toCotangent x = 0) = (↑x ∈ I ^ 2) |
RelSeries.append | Mathlib.Order.RelSeries | {α : Type u_1} → {r : SetRel α α} → (p q : RelSeries r) → (p.last, q.head) ∈ r → RelSeries r |
Padic.instNorm | Mathlib.NumberTheory.Padics.PadicNumbers | (p : ℕ) → [inst : Fact (Nat.Prime p)] → Norm ℚ_[p] |
TwoSidedIdeal.instSMulNatSubtypeMem._proof_1 | Mathlib.RingTheory.TwoSidedIdeal.Basic | ∀ {R : Type u_1} [inst : NonUnitalNonAssocRing R] (I : TwoSidedIdeal R) (n : ℕ) (x : ↥I), n • ↑x ∈ I |
groupHomology.coe_mapCycles₁ | Mathlib.RepresentationTheory.Homological.GroupHomology.Functoriality | ∀ {k G H : Type u} [inst : CommRing k] [inst_1 : Group G] [inst_2 : Group H] {A : Rep k G} {B : Rep k H} (f : G →* H)
(φ : A ⟶ (Action.res (ModuleCat k) f).obj B) (x : ↑(ModuleCat.of k ↥(groupHomology.cycles₁ A))),
↑((CategoryTheory.ConcreteCategory.hom (groupHomology.mapCycles₁ f φ)) x) =
(CategoryTheory.ConcreteCategory.hom (groupHomology.chainsMap₁ f φ)) ↑x |
CategoryTheory.Bicategory.whiskerRight_comp_symm_assoc | Mathlib.CategoryTheory.Bicategory.Basic | ∀ {B : Type u} [inst : CategoryTheory.Bicategory B] {a b c d : B} {f f' : a ⟶ b} (η : f ⟶ f') (g : b ⟶ c) (h : c ⟶ d)
{Z : a ⟶ d} (h_1 : CategoryTheory.CategoryStruct.comp (CategoryTheory.CategoryStruct.comp f' g) h ⟶ Z),
CategoryTheory.CategoryStruct.comp
(CategoryTheory.Bicategory.whiskerRight (CategoryTheory.Bicategory.whiskerRight η g) h) h_1 =
CategoryTheory.CategoryStruct.comp (CategoryTheory.Bicategory.associator f g h).hom
(CategoryTheory.CategoryStruct.comp
(CategoryTheory.Bicategory.whiskerRight η (CategoryTheory.CategoryStruct.comp g h))
(CategoryTheory.CategoryStruct.comp (CategoryTheory.Bicategory.associator f' g h).inv h_1)) |
RingPreordering.coe_set_mk | Mathlib.Algebra.Order.Ring.Ordering.Defs | ∀ {R : Type u_1} [inst : CommRing R] (toSubsemiring : Subsemiring R)
(mem_of_isSquare : ∀ {x : R}, IsSquare x → x ∈ toSubsemiring.carrier) (neg_one_notMem : -1 ∉ toSubsemiring.carrier),
↑{ toSubsemiring := toSubsemiring, mem_of_isSquare' := mem_of_isSquare, neg_one_notMem' := neg_one_notMem } =
↑toSubsemiring |
Aesop.IndexMatchLocation.hyp | Aesop.Index.Basic | Lean.LocalDecl → Aesop.IndexMatchLocation |
OrderDual.instNontrivial | Mathlib.Order.OrderDual | ∀ {α : Type u_1} [h : Nontrivial α], Nontrivial αᵒᵈ |
Lean.Compiler.LCNF.JoinPointFinder.FindCtx.mk | Lean.Compiler.LCNF.JoinPoints | ℕ → Lean.FVarIdMap ℕ → Option Lean.FVarId → Lean.Compiler.LCNF.JoinPointFinder.FindCtx |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.