name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M |
|---|---|---|
_private.Mathlib.Tactic.TacticAnalysis.Declarations.0.Mathlib.TacticAnalysis.TerminalReplacementOutcome.success.sizeOf_spec | Mathlib.Tactic.TacticAnalysis.Declarations | ∀ (stx : Lean.TSyntax `tactic), sizeOf (Mathlib.TacticAnalysis.TerminalReplacementOutcome.success✝ stx) = 1 + sizeOf stx |
_private.Lean.Widget.TaggedText.0.Lean.Widget.TaggedText.instMonadPrettyFormatStateMTaggedState.match_1 | Lean.Widget.TaggedText | (motive : Lean.Widget.TaggedText.TaggedState✝ → Sort u_1) →
(x : Lean.Widget.TaggedText.TaggedState✝¹) →
((out : Lean.Widget.TaggedText (ℕ × ℕ)) →
(ts : List (ℕ × ℕ × Lean.Widget.TaggedText (ℕ × ℕ))) →
(col : ℕ) → motive { out := out, tagStack := ts, column := col }) →
motive x |
LindelofSpace.mk | Mathlib.Topology.Compactness.Lindelof | ∀ {X : Type u_2} [inst : TopologicalSpace X], IsLindelof Set.univ → LindelofSpace X |
Set.Finite.wellFoundedOn | Mathlib.Order.WellFoundedSet | ∀ {α : Type u_2} {r : α → α → Prop} [IsStrictOrder α r] {s : Set α}, s.Finite → s.WellFoundedOn r |
_private.Lean.Elab.StructInst.0.Lean.Elab.Term.StructInst.addParentInstanceFields.match_9 | Lean.Elab.StructInst | (motive : List (Lean.Name × Array Lean.Name) → Sort u_1) →
(worklist : List (Lean.Name × Array Lean.Name)) →
((parentName : Lean.Name) →
(parentFields : Array Lean.Name) →
(worklist' : List (Lean.Name × Array Lean.Name)) → motive ((parentName, parentFields) :: worklist')) →
((x : List (Lean.Name × Array Lean.Name)) → motive x) → motive worklist |
Lean.DeclNameGenerator.noConfusionType | Lean.CoreM | Sort u → Lean.DeclNameGenerator → Lean.DeclNameGenerator → Sort u |
stoneCechEquivalence._proof_5 | Mathlib.Topology.Category.CompHaus.Basic | ∀ (Y : CompHaus), CompactSpace ↑Y.toTop |
maximal_subset_iff | Mathlib.Order.Minimal | ∀ {α : Type u_2} {P : Set α → Prop} {s : Set α}, Maximal P s ↔ P s ∧ ∀ ⦃t : Set α⦄, P t → s ⊆ t → s = t |
Localization.exists_awayMap_bijective_of_localRingHom_bijective | Mathlib.RingTheory.Unramified.LocalRing | ∀ {R : Type u_1} {S : Type u_2} [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S] {p : Ideal R}
[inst_3 : p.IsPrime] {q : Ideal S} [inst_4 : q.IsPrime],
p.primesOver S = {q} →
∀ [Module.Finite R S] [inst_6 : q.LiesOver p],
(RingHom.ker (algebraMap R S)).FG →
Function.Bijective ⇑(Localization.localRingHom p q (algebraMap R S) ⋯) →
∃ r ∉ p, ∀ (r' : R), r ∣ r' → Function.Bijective ⇑(Localization.awayMap (algebraMap R S) r') |
CategoryTheory.CommMon.toMon | Mathlib.CategoryTheory.Monoidal.CommMon_ | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
[inst_1 : CategoryTheory.MonoidalCategory C] →
[inst_2 : CategoryTheory.BraidedCategory C] → CategoryTheory.CommMon C → CategoryTheory.Mon C |
_private.Std.Sync.Channel.0.Std.CloseableChannel.Unbounded.State.mk.noConfusion | Std.Sync.Channel | {α : Type} →
{P : Sort u} →
{values : Std.Queue α} →
{consumers : Std.Queue (Std.CloseableChannel.Consumer✝ α)} →
{closed : Bool} →
{values' : Std.Queue α} →
{consumers' : Std.Queue (Std.CloseableChannel.Consumer✝¹ α)} →
{closed' : Bool} →
{ values := values, consumers := consumers, closed := closed } =
{ values := values', consumers := consumers', closed := closed' } →
(values ≍ values' → consumers ≍ consumers' → closed = closed' → P) → P |
CategoryTheory.MorphismProperty.comp_mem | Mathlib.CategoryTheory.MorphismProperty.Composition | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (W : CategoryTheory.MorphismProperty C)
[W.IsStableUnderComposition] {X Y Z : C} (f : X ⟶ Y) (g : Y ⟶ Z),
W f → W g → W (CategoryTheory.CategoryStruct.comp f g) |
linearOrderOfCompares._proof_8 | Mathlib.Order.Compare | ∀ {α : Type u_1} [inst : Preorder α] (cmp : α → α → Ordering),
(∀ (a b : α), (cmp a b).Compares a b) → ∀ (a b : α), a ≤ b ∨ b ≤ a |
_private.Mathlib.GroupTheory.Goursat.0.Subgroup.mk_goursatFst_eq_iff_mk_goursatSnd_eq._simp_1_1 | Mathlib.GroupTheory.Goursat | ∀ {G : Type u_1} [inst : Group G] {N : Subgroup G} [nN : N.Normal] {x y : G}, (↑x = ↑y) = (x / y ∈ N) |
ZMod.χ₈' | Mathlib.NumberTheory.LegendreSymbol.ZModChar | MulChar (ZMod 8) ℤ |
Lean.Lsp.SignatureInformation._sizeOf_1 | Lean.Data.Lsp.LanguageFeatures | Lean.Lsp.SignatureInformation → ℕ |
_private.Mathlib.Topology.Order.0.continuous_sInf_rng._simp_1_1 | Mathlib.Topology.Order | ∀ {α : Type u} {β : Type v} {f : α → β} {t₁ : TopologicalSpace α} {t₂ : TopologicalSpace β},
Continuous f = (TopologicalSpace.coinduced f t₁ ≤ t₂) |
ModularForm.mul._proof_2 | Mathlib.NumberTheory.ModularForms.Basic | ∀ {Γ : Subgroup (GL (Fin 2) ℝ)} {k_1 k_2 : ℤ} [inst : Γ.HasDetPlusMinusOne] (f : ModularForm Γ k_1)
(g : ModularForm Γ k_2) {c : OnePoint ℝ},
IsCusp c Γ →
∀ (γ : GL (Fin 2) ℝ),
γ • OnePoint.infty = c →
UpperHalfPlane.IsBoundedAtImInfty (SlashAction.map (k_1 + k_2) γ (f.mul g.toSlashInvariantForm).toFun) |
Real.sin_pi_sub | Mathlib.Analysis.SpecialFunctions.Trigonometric.Basic | ∀ (x : ℝ), Real.sin (Real.pi - x) = Real.sin x |
RingQuot.instSemiring | Mathlib.Algebra.RingQuot | {R : Type uR} → [inst : Semiring R] → (r : R → R → Prop) → Semiring (RingQuot r) |
IsLocalization.Away.commutes | Mathlib.RingTheory.Localization.Away.Basic | ∀ {R : Type u_5} [inst : CommSemiring R] (S₁ : Type u_6) (S₂ : Type u_7) (T : Type u_8) [inst_1 : CommSemiring S₁]
[inst_2 : CommSemiring S₂] [inst_3 : CommSemiring T] [inst_4 : Algebra R S₁] [inst_5 : Algebra R S₂]
[inst_6 : Algebra R T] [inst_7 : Algebra S₁ T] [inst_8 : Algebra S₂ T] [IsScalarTower R S₁ T] [IsScalarTower R S₂ T]
(x y : R) [IsLocalization.Away x S₁] [IsLocalization.Away y S₂] [IsLocalization.Away ((algebraMap R S₂) x) T],
IsLocalization.Away ((algebraMap R S₁) y) T |
Subring.list_sum_mem | Mathlib.Algebra.Ring.Subring.Basic | ∀ {R : Type u} [inst : Ring R] (s : Subring R) {l : List R}, (∀ x ∈ l, x ∈ s) → l.sum ∈ s |
CochainComplex.mapBifunctorHomologicalComplexShift₁Iso | Mathlib.Algebra.Homology.BifunctorShift | {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.Preadditive C₁] →
[inst_4 : CategoryTheory.Limits.HasZeroMorphisms C₂] →
[inst_5 : CategoryTheory.Preadditive D] →
(K₁ : CochainComplex C₁ ℤ) →
(K₂ : CochainComplex C₂ ℤ) →
(F : CategoryTheory.Functor C₁ (CategoryTheory.Functor C₂ D)) →
[inst_6 : F.Additive] →
[inst_7 : ∀ (X₁ : C₁), (F.obj X₁).PreservesZeroMorphisms] →
(x : ℤ) →
((F.mapBifunctorHomologicalComplex (ComplexShape.up ℤ) (ComplexShape.up ℤ)).obj
((CategoryTheory.shiftFunctor (HomologicalComplex C₁ (ComplexShape.up ℤ)) x).obj
K₁)).obj
K₂ ≅
(HomologicalComplex₂.shiftFunctor₁ D x).obj
(((F.mapBifunctorHomologicalComplex (ComplexShape.up ℤ) (ComplexShape.up ℤ)).obj
K₁).obj
K₂) |
GenContFract.coe_toGenContFract | Mathlib.Algebra.ContinuedFractions.Basic | ∀ {α : Type u_1} {β : Type u_2} [inst : Coe α β] {g : GenContFract α},
↑g = { h := Coe.coe g.h, s := Stream'.Seq.map GenContFract.Pair.coeFn g.s } |
CommRingCat.Colimits.Relation.right_distrib | Mathlib.Algebra.Category.Ring.Colimits | ∀ {J : Type v} [inst : CategoryTheory.SmallCategory J] {F : CategoryTheory.Functor J CommRingCat}
(x y z : CommRingCat.Colimits.Prequotient F),
CommRingCat.Colimits.Relation F ((x.add y).mul z) ((x.mul z).add (y.mul z)) |
UniformConvergenceCLM.neg_apply | Mathlib.Topology.Algebra.Module.StrongTopology | ∀ {𝕜₁ : Type u_1} {𝕜₂ : Type u_2} [inst : NormedField 𝕜₁] [inst_1 : NormedField 𝕜₂] (σ : 𝕜₁ →+* 𝕜₂) {E : Type u_3}
(F : Type u_4) [inst_2 : AddCommGroup E] [inst_3 : Module 𝕜₁ E] [inst_4 : TopologicalSpace E]
[inst_5 : AddCommGroup F] [inst_6 : Module 𝕜₂ F] [inst_7 : TopologicalSpace F] [inst_8 : IsTopologicalAddGroup F]
(𝔖 : Set (Set E)) (f : UniformConvergenceCLM σ F 𝔖) (x : E), (-f) x = -f x |
Lean.Grind.AC.Seq.sort'_k | Init.Grind.AC | Lean.Grind.AC.Seq → Lean.Grind.AC.Seq → Lean.Grind.AC.Seq |
IsUnifLocDoublingMeasure | Mathlib.MeasureTheory.Measure.Doubling | {α : Type u_1} → [PseudoMetricSpace α] → [inst : MeasurableSpace α] → MeasureTheory.Measure α → Prop |
_private.Mathlib.Topology.Order.0.isClosed_induced._simp_1_1 | Mathlib.Topology.Order | ∀ {X : Type u} {s : Set X} [inst : TopologicalSpace X], IsClosed s = IsOpen sᶜ |
Matrix.replicateRow_inj._simp_1 | Mathlib.LinearAlgebra.Matrix.RowCol | ∀ {n : Type u_3} {α : Type v} {ι : Type u_6} [Nonempty ι] {v w : n → α},
(Matrix.replicateRow ι v = Matrix.replicateRow ι w) = (v = w) |
CStarAlgebra.instNegPart | Mathlib.Analysis.SpecialFunctions.ContinuousFunctionalCalculus.PosPart.Basic | {A : Type u_1} →
[inst : NonUnitalRing A] →
[inst_1 : Module ℝ A] →
[inst_2 : SMulCommClass ℝ A A] →
[inst_3 : IsScalarTower ℝ A A] →
[inst_4 : StarRing A] →
[inst_5 : TopologicalSpace A] → [NonUnitalContinuousFunctionalCalculus ℝ A IsSelfAdjoint] → NegPart A |
Aesop.ForwardStateStats.mk.noConfusion | Aesop.Stats.Basic | {P : Sort u} →
{ruleStateStats ruleStateStats' : Array Aesop.ForwardRuleStateStats} →
{ ruleStateStats := ruleStateStats } = { ruleStateStats := ruleStateStats' } →
(ruleStateStats = ruleStateStats' → P) → P |
Lean.Server.DirectImports.noConfusionType | Lean.Server.References | Sort u → Lean.Server.DirectImports → Lean.Server.DirectImports → Sort u |
Function.Surjective.addGroup.eq_1 | Mathlib.Algebra.Group.InjSurj | ∀ {M₁ : Type u_1} {M₂ : Type u_2} [inst : Add M₂] [inst_1 : Zero M₂] [inst_2 : SMul ℕ M₂] [inst_3 : Neg M₂]
[inst_4 : Sub M₂] [inst_5 : SMul ℤ M₂] [inst_6 : AddGroup M₁] (f : M₁ → M₂) (hf : Function.Surjective f)
(one : f 0 = 0) (mul : ∀ (x y : M₁), f (x + y) = f x + f y) (inv : ∀ (x : M₁), f (-x) = -f x)
(div : ∀ (x y : M₁), f (x - y) = f x - f y) (npow : ∀ (x : M₁) (n : ℕ), f (n • x) = n • f x)
(zpow : ∀ (x : M₁) (n : ℤ), f (n • x) = n • f x),
Function.Surjective.addGroup f hf one mul inv div npow zpow =
{ toSubNegMonoid := Function.Surjective.subNegMonoid f hf one mul inv div npow zpow, neg_add_cancel := ⋯ } |
Aesop.instInhabitedGoalDiff.default | Aesop.RuleTac.GoalDiff | Aesop.GoalDiff |
orderOf_one | Mathlib.GroupTheory.OrderOfElement | ∀ {G : Type u_1} [inst : Monoid G], orderOf 1 = 1 |
_private.Mathlib.Geometry.Euclidean.Inversion.Basic.0.EuclideanGeometry.dist_inversion_center._simp_1_6 | Mathlib.Geometry.Euclidean.Inversion.Basic | ∀ {M₀ : Type u_1} [inst : Mul M₀] [inst_1 : Zero M₀] [NoZeroDivisors M₀] {a b : M₀}, a ≠ 0 → b ≠ 0 → (a * b = 0) = False |
Asymptotics.isBigO_congr | Mathlib.Analysis.Asymptotics.Defs | ∀ {α : Type u_1} {E : Type u_3} {F : Type u_4} [inst : Norm E] [inst_1 : Norm F] {l : Filter α} {f₁ f₂ : α → E}
{g₁ g₂ : α → F}, f₁ =ᶠ[l] f₂ → g₁ =ᶠ[l] g₂ → (f₁ =O[l] g₁ ↔ f₂ =O[l] g₂) |
Std.Time.Modifier.x.injEq | Std.Time.Format.Basic | ∀ (presentation presentation_1 : Std.Time.OffsetX),
(Std.Time.Modifier.x presentation = Std.Time.Modifier.x presentation_1) = (presentation = presentation_1) |
CategoryTheory.Limits.FormalCoproduct.isoOfComponents._proof_7 | Mathlib.CategoryTheory.Limits.FormalCoproducts.Basic | ∀ {C : Type u_3} [inst : CategoryTheory.Category.{u_1, u_3} C] {X Y : CategoryTheory.Limits.FormalCoproduct C}
(e : X.I ≃ Y.I) (h : (i : X.I) → X.obj i ≅ Y.obj (e i)),
CategoryTheory.CategoryStruct.comp
{ f := ⇑e.symm, φ := fun i => CategoryTheory.CategoryStruct.comp (CategoryTheory.eqToHom ⋯) (h (e.symm i)).inv }
{ f := ⇑e, φ := fun i => (h i).hom } =
CategoryTheory.CategoryStruct.id Y |
SeminormedCommRing.mk | Mathlib.Analysis.Normed.Ring.Basic | {α : Type u_5} → [toSeminormedRing : SeminormedRing α] → (∀ (a b : α), a * b = b * a) → SeminormedCommRing α |
CategoryTheory.InducedCategory.hasForget₂._proof_1 | Mathlib.CategoryTheory.ConcreteCategory.Forget | ∀ {C : Type u_1} {D : Type u_4} [inst : CategoryTheory.Category.{u_2, u_4} D] {FD : outParam (D → D → Type u_5)}
{CD : outParam (D → Type u_3)} [inst_1 : outParam ((X Y : D) → FunLike (FD X Y) (CD X) (CD Y))]
[inst_2 : CategoryTheory.ConcreteCategory D FD] (f : C → D),
(CategoryTheory.inducedFunctor f).comp (CategoryTheory.forget D) =
(CategoryTheory.inducedFunctor f).comp (CategoryTheory.forget D) |
CategoryTheory.LaxFunctor.mapComp'.congr_simp | Mathlib.CategoryTheory.Bicategory.Strict.Pseudofunctor | ∀ {B : Type u₁} [inst : CategoryTheory.Bicategory B] {C : Type u₂} [inst_1 : CategoryTheory.Bicategory C]
(F : CategoryTheory.LaxFunctor B C) {b₀ b₁ b₂ : B} (f : b₀ ⟶ b₁) (g : b₁ ⟶ b₂) (fg : b₀ ⟶ b₂)
(h : CategoryTheory.CategoryStruct.comp f g = fg), F.mapComp' f g fg h = F.mapComp' f g fg h |
CategoryTheory.Limits.IsZero.iso.congr_simp | Mathlib.CategoryTheory.Triangulated.Opposite.Pretriangulated | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y : C} (hX : CategoryTheory.Limits.IsZero X)
(hY : CategoryTheory.Limits.IsZero Y), hX.iso hY = hX.iso hY |
CategoryTheory.Functor.CommShift₂.commShiftObj | Mathlib.CategoryTheory.Shift.CommShiftTwo | {C₁ : Type u_1} →
{C₂ : Type u_3} →
{D : Type u_5} →
{inst : CategoryTheory.Category.{v_1, u_1} C₁} →
{inst_1 : CategoryTheory.Category.{v_3, u_3} C₂} →
{inst_2 : CategoryTheory.Category.{v_5, u_5} D} →
{M : Type u_6} →
{inst_3 : AddCommMonoid M} →
{inst_4 : CategoryTheory.HasShift C₁ M} →
{inst_5 : CategoryTheory.HasShift C₂ M} →
{inst_6 : CategoryTheory.HasShift D M} →
{G : CategoryTheory.Functor C₁ (CategoryTheory.Functor C₂ D)} →
(h : CategoryTheory.CommShift₂Setup D M) →
[self : G.CommShift₂ h] → (X₁ : C₁) → (G.obj X₁).CommShift M |
Multiset.le_iff_exists_add | Mathlib.Data.Multiset.AddSub | ∀ {α : Type u_1} {s t : Multiset α}, s ≤ t ↔ ∃ u, t = s + u |
Lean.InductiveVal.numNested | Lean.Declaration | Lean.InductiveVal → ℕ |
_private.Std.Tactic.BVDecide.LRAT.Internal.Formula.RupAddResult.0.Std.Tactic.BVDecide.LRAT.Internal.DefaultFormula.confirmRupHint_preserves_invariant_helper._proof_1_20 | Std.Tactic.BVDecide.LRAT.Internal.Formula.RupAddResult | ∀ {n : ℕ}
(acc :
Array Std.Tactic.BVDecide.LRAT.Internal.Assignment ×
Std.Sat.CNF.Clause (Std.Tactic.BVDecide.LRAT.Internal.PosFin n) × Bool × Bool),
acc.1.size = n →
∀ (l : Std.Sat.Literal (Std.Tactic.BVDecide.LRAT.Internal.PosFin n)) (i : Fin n),
↑i < acc.1.size → ↑i < (acc.1.modify (↑l.1) (Std.Tactic.BVDecide.LRAT.Internal.Assignment.addAssignment l.2)).size |
_private.Mathlib.CategoryTheory.Idempotents.Karoubi.0.CategoryTheory.Idempotents.instEssSurjKaroubiToKaroubiOfIsIdempotentComplete._simp_1 | Mathlib.CategoryTheory.Idempotents.Karoubi | ∀ {obj : Type u} [self : CategoryTheory.Category.{v, u} obj] {W X Y Z : obj} (f : W ⟶ X) (g : X ⟶ Y) (h : Y ⟶ Z),
CategoryTheory.CategoryStruct.comp f (CategoryTheory.CategoryStruct.comp g h) =
CategoryTheory.CategoryStruct.comp (CategoryTheory.CategoryStruct.comp f g) h |
AddLECancellable.tsub_mul | Mathlib.Algebra.Order.Ring.Canonical | ∀ {R : Type u} [inst : NonUnitalNonAssocSemiring R] [inst_1 : PartialOrder R] [CanonicallyOrderedAdd R] [inst_3 : Sub R]
[OrderedSub R] [Std.Total fun x1 x2 => x1 ≤ x2] [MulRightMono R] {a b c : R},
AddLECancellable (b * c) → (a - b) * c = a * c - b * c |
Std.Tactic.BVDecide.Normalize.BitVec.ult_max' | Std.Tactic.BVDecide.Normalize.BitVec | ∀ {w : ℕ} (a : BitVec w), a.ult (-1#w) = !a == -1#w |
BddDistLat.recOn | Mathlib.Order.Category.BddDistLat | {motive : BddDistLat → Sort u} →
(t : BddDistLat) →
((toDistLat : DistLat) →
[isBoundedOrder : BoundedOrder ↑toDistLat] →
motive { toDistLat := toDistLat, isBoundedOrder := isBoundedOrder }) →
motive t |
ContinuousLinearEquiv.arrowCongrEquiv._proof_4 | Mathlib.Topology.Algebra.Module.Equiv | ∀ {R₁ : Type u_7} {R₂ : Type u_1} {R₃ : Type u_2} [inst : Semiring R₁] [inst_1 : Semiring R₂] [inst_2 : Semiring R₃]
{σ₁₂ : R₁ →+* R₂} {σ₂₁ : R₂ →+* R₁} [inst_3 : RingHomInvPair σ₁₂ σ₂₁] [inst_4 : RingHomInvPair σ₂₁ σ₁₂]
{σ₂₃ : R₂ →+* R₃} {σ₁₃ : R₁ →+* R₃} [inst_5 : RingHomCompTriple σ₁₂ σ₂₃ σ₁₃] {M₁ : Type u_8}
[inst_6 : TopologicalSpace M₁] [inst_7 : AddCommMonoid M₁] {M₂ : Type u_3} [inst_8 : TopologicalSpace M₂]
[inst_9 : AddCommMonoid M₂] {M₃ : Type u_4} [inst_10 : TopologicalSpace M₃] [inst_11 : AddCommMonoid M₃]
{M₄ : Type u_6} [inst_12 : TopologicalSpace M₄] [inst_13 : AddCommMonoid M₄] [inst_14 : Module R₁ M₁]
[inst_15 : Module R₂ M₂] [inst_16 : Module R₃ M₃] {R₄ : Type u_5} [inst_17 : Semiring R₄] [inst_18 : Module R₄ M₄]
{σ₃₄ : R₃ →+* R₄} {σ₄₃ : R₄ →+* R₃} [inst_19 : RingHomInvPair σ₃₄ σ₄₃] [inst_20 : RingHomInvPair σ₄₃ σ₃₄]
{σ₂₄ : R₂ →+* R₄} {σ₁₄ : R₁ →+* R₄} [inst_21 : RingHomCompTriple σ₂₁ σ₁₄ σ₂₄]
[inst_22 : RingHomCompTriple σ₂₄ σ₄₃ σ₂₃] [inst_23 : RingHomCompTriple σ₁₃ σ₃₄ σ₁₄] (e₁₂ : M₁ ≃SL[σ₁₂] M₂)
(e₄₃ : M₄ ≃SL[σ₄₃] M₃) (f : M₂ →SL[σ₂₃] M₃), (↑e₄₃).comp (((↑e₄₃.symm).comp (f.comp ↑e₁₂)).comp ↑e₁₂.symm) = f |
Submodule.coe_finsetInf | Mathlib.Algebra.Module.Submodule.Lattice | ∀ {R : Type u_1} {M : Type u_3} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] {ι : Type u_4}
(s : Finset ι) (p : ι → Submodule R M), ↑(s.inf p) = ⋂ i ∈ s, ↑(p i) |
Matroid.Indep.mem_closure_iff' | Mathlib.Combinatorics.Matroid.Closure | ∀ {α : Type u_2} {M : Matroid α} {I : Set α} {x : α},
M.Indep I → (x ∈ M.closure I ↔ x ∈ M.E ∧ (M.Indep (insert x I) → x ∈ I)) |
_private.Mathlib.Combinatorics.Enumerative.IncidenceAlgebra.0.IncidenceAlgebra.moebius_inversion_top._simp_1_7 | Mathlib.Combinatorics.Enumerative.IncidenceAlgebra | ∀ {α : Type u_1} [inst : Preorder α] (a : α), (a ≤ a) = True |
Finset.instLattice._proof_3 | Mathlib.Data.Finset.Lattice.Basic | ∀ {α : Type u_1} [inst : DecidableEq α] (x x_1 x_2 : Finset α), x ≤ x_2 → x_1 ≤ x_2 → ∀ x_3 ∈ x ∪ x_1, x_3 ∈ x_2 |
intervalIntegrable_log_norm_meromorphicOn | Mathlib.Analysis.SpecialFunctions.Integrability.LogMeromorphic | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] {f : ℝ → E} {a b : ℝ},
MeromorphicOn f (Set.uIcc a b) → IntervalIntegrable (fun x => Real.log ‖f x‖) MeasureTheory.volume a b |
_private.Lean.Elab.DeclNameGen.0.Lean.Elab.Command.NameGen.getParentProjArg._sparseCasesOn_8.else_eq | Lean.Elab.DeclNameGen | ∀ {motive : Lean.Name → Sort u} (t : Lean.Name) (str : (pre : Lean.Name) → (str : String) → motive (pre.str str))
(«else» : Nat.hasNotBit 2 t.ctorIdx → motive t) (h : Nat.hasNotBit 2 t.ctorIdx),
Lean.Elab.Command.NameGen.getParentProjArg._sparseCasesOn_8✝ t str «else» = «else» h |
VectorBundleCore.coordChange | Mathlib.Topology.VectorBundle.Basic | {R : Type u_1} →
{B : Type u_2} →
{F : Type u_3} →
[inst : NontriviallyNormedField R] →
[inst_1 : NormedAddCommGroup F] →
[inst_2 : NormedSpace R F] →
[inst_3 : TopologicalSpace B] → {ι : Type u_5} → VectorBundleCore R B F ι → ι → ι → B → F →L[R] F |
Lean.IR.CtorInfo.mk.inj | Lean.Compiler.IR.Basic | ∀ {name : Lean.Name} {cidx size usize ssize : ℕ} {name_1 : Lean.Name} {cidx_1 size_1 usize_1 ssize_1 : ℕ},
{ name := name, cidx := cidx, size := size, usize := usize, ssize := ssize } =
{ name := name_1, cidx := cidx_1, size := size_1, usize := usize_1, ssize := ssize_1 } →
name = name_1 ∧ cidx = cidx_1 ∧ size = size_1 ∧ usize = usize_1 ∧ ssize = ssize_1 |
Matrix.uniqueRingEquiv._proof_2 | Mathlib.LinearAlgebra.Matrix.Unique | ∀ {m : Type u_1} {A : Type u_2} [inst : Unique m] [inst_1 : NonUnitalNonAssocSemiring A] (x y : Matrix m m A),
Matrix.uniqueAddEquiv.toFun (x + y) = Matrix.uniqueAddEquiv.toFun x + Matrix.uniqueAddEquiv.toFun y |
Batteries.RBNode.All.map | Batteries.Data.RBMap.WF | ∀ {α : Type u_1} {β : Type u_2} {p : α → Prop} {q : β → Prop} {f : α → β},
(∀ {x : α}, p x → q (f x)) →
∀ {t : Batteries.RBNode α}, Batteries.RBNode.All p t → Batteries.RBNode.All q (Batteries.RBNode.map f t) |
_private.Mathlib.Geometry.Manifold.ChartedSpace.0.ChartedSpace.t1Space._simp_1_1 | Mathlib.Geometry.Manifold.ChartedSpace | ∀ {α : Type u} (x : α) (a b : Set α), (x ∈ a ∩ b) = (x ∈ a ∧ x ∈ b) |
Lean.ScopedEnvExtension.ScopedEntries.mk.injEq | Lean.ScopedEnvExtension | ∀ {β : Type} (map map_1 : Lean.SMap Lean.Name (Lean.PArray β)), ({ map := map } = { map := map_1 }) = (map = map_1) |
CategoryTheory.Functor.sheafPullbackConstruction.preservesFiniteLimits | Mathlib.CategoryTheory.Sites.Pullback | ∀ {C : Type u₂} [inst : CategoryTheory.Category.{v₂, u₂} C] {D : Type u₃} [inst_1 : CategoryTheory.Category.{v₃, u₃} D]
(G : CategoryTheory.Functor C D) (A : Type u₁) [inst_2 : CategoryTheory.Category.{v₁, u₁} A]
(J : CategoryTheory.GrothendieckTopology C) (K : CategoryTheory.GrothendieckTopology D) [inst_3 : G.IsContinuous J K]
[inst_4 : ∀ (F : CategoryTheory.Functor Cᵒᵖ A), G.op.HasLeftKanExtension F] [inst_5 : CategoryTheory.HasSheafify K A]
[CategoryTheory.HasSheafify J A] [CategoryTheory.Limits.PreservesFiniteLimits G.op.lan],
CategoryTheory.Limits.PreservesFiniteLimits (G.sheafPullback A J K) |
OrderIso.arrowCongr | Mathlib.Order.Hom.Basic | {α : Type u_6} →
{β : Type u_7} →
{γ : Type u_8} →
{δ : Type u_9} →
[inst : Preorder α] →
[inst_1 : Preorder β] → [inst_2 : Preorder γ] → [inst_3 : Preorder δ] → α ≃o γ → β ≃o δ → (α →o β) ≃o (γ →o δ) |
_private.Lean.Meta.Sorry.0.Lean.Meta.SorryLabelView.encode.match_1 | Lean.Meta.Sorry | (motive : Option Lean.DeclarationLocation → Sort u_1) →
(x : Option Lean.DeclarationLocation) →
((module : Lean.Name) →
(pos : Lean.Position) →
(charUtf16 : ℕ) →
(endPos : Lean.Position) →
(endCharUtf16 : ℕ) →
motive
(some
{ module := module,
range :=
{ pos := pos, charUtf16 := charUtf16, endPos := endPos, endCharUtf16 := endCharUtf16 } })) →
((x : Option Lean.DeclarationLocation) → motive x) → motive x |
Set.finite_Ico._simp_1 | Mathlib.Order.Interval.Finset.Defs | ∀ {α : Type u_1} [inst : Preorder α] [LocallyFiniteOrder α] (a b : α), (Set.Ico a b).Finite = True |
Lean.Lsp.instHashableInsertReplaceEdit.hash | Lean.Data.Lsp.LanguageFeatures | Lean.Lsp.InsertReplaceEdit → UInt64 |
Aesop.instInhabitedRuleTacDescr.default | Aesop.RuleTac.Descr | Aesop.RuleTacDescr |
MeasureTheory.setLIntegral_withDensity_eq_lintegral_mul₀ | Mathlib.MeasureTheory.Measure.WithDensity | ∀ {α : Type u_1} {m0 : MeasurableSpace α} {μ : MeasureTheory.Measure α} {f : α → ENNReal},
AEMeasurable f μ →
∀ {g : α → ENNReal},
AEMeasurable g μ →
∀ {s : Set α}, MeasurableSet s → ∫⁻ (a : α) in s, g a ∂μ.withDensity f = ∫⁻ (a : α) in s, (f * g) a ∂μ |
cfcₙHomSuperset | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.NonUnital | {R : Type u_1} →
{A : Type u_2} →
{p : A → Prop} →
[inst : CommSemiring R] →
[inst_1 : Nontrivial R] →
[inst_2 : StarRing R] →
[inst_3 : MetricSpace R] →
[inst_4 : IsTopologicalSemiring R] →
[inst_5 : ContinuousStar R] →
[inst_6 : NonUnitalRing A] →
[inst_7 : StarRing A] →
[inst_8 : TopologicalSpace A] →
[inst_9 : Module R A] →
[inst_10 : IsScalarTower R A A] →
[inst_11 : SMulCommClass R A A] →
[instCFCₙ : NonUnitalContinuousFunctionalCalculus R A p] →
{a : A} →
p a → {s : Set R} → (hs : quasispectrum R a ⊆ s) → ContinuousMapZero (↑s) R →⋆ₙₐ[R] A |
String.Slice.copy_slice_eq_iff_splits | Init.Data.String.Lemmas.Splits | ∀ {t : String} {s : String.Slice} {pos₁ pos₂ : s.Pos},
(∃ (h : pos₁ ≤ pos₂), (s.slice pos₁ pos₂ h).copy = t) ↔ ∃ t₁ t₂, pos₁.Splits t₁ (t ++ t₂) ∧ pos₂.Splits (t₁ ++ t) t₂ |
instInhabitedAsBoolRing | Mathlib.Algebra.Ring.BooleanRing | {α : Type u_1} → [Inhabited α] → Inhabited (AsBoolRing α) |
Fin.partialProd.eq_1 | Mathlib.Algebra.BigOperators.Fin | ∀ {M : Type u_2} [inst : Monoid M] {n : ℕ} (f : Fin n → M) (i : Fin (n + 1)),
Fin.partialProd f i = (List.take (↑i) (List.ofFn f)).prod |
GenContFract.contsAux_eq_contsAux_squashGCF_of_le | Mathlib.Algebra.ContinuedFractions.ConvergentsEquiv | ∀ {K : Type u_1} {n : ℕ} {g : GenContFract K} [inst : DivisionRing K] {m : ℕ},
m ≤ n → g.contsAux m = (g.squashGCF n).contsAux m |
LinearIsometryEquiv.rTensor | Mathlib.Analysis.InnerProductSpace.TensorProduct | {𝕜 : Type u_1} →
{E : Type u_2} →
{F : Type u_3} →
(G : Type u_4) →
[inst : RCLike 𝕜] →
[inst_1 : NormedAddCommGroup E] →
[inst_2 : InnerProductSpace 𝕜 E] →
[inst_3 : NormedAddCommGroup F] →
[inst_4 : InnerProductSpace 𝕜 F] →
[inst_5 : NormedAddCommGroup G] →
[inst_6 : InnerProductSpace 𝕜 G] → (E ≃ₗᵢ[𝕜] F) → TensorProduct 𝕜 E G ≃ₗᵢ[𝕜] TensorProduct 𝕜 F G |
Lean.Elab.Term.TacticMVarKind.autoParam.elim | Lean.Elab.Term.TermElabM | {motive : Lean.Elab.Term.TacticMVarKind → Sort u} →
(t : Lean.Elab.Term.TacticMVarKind) →
t.ctorIdx = 1 → ((argName : Lean.Name) → motive (Lean.Elab.Term.TacticMVarKind.autoParam argName)) → motive t |
Fin.rev_anti | Mathlib.Order.Fin.Basic | ∀ {n : ℕ}, Antitone Fin.rev |
_private.Mathlib.Data.EReal.Operations.0.EReal.le_sub_iff_add_le._simp_1_3 | Mathlib.Data.EReal.Operations | ∀ {α : Type u} [inst : PartialOrder α] [inst_1 : OrderBot α] {a : α}, (a ≤ ⊥) = (a = ⊥) |
Lean.Meta.Grind.Arith.traceModel | Lean.Meta.Tactic.Grind.Arith.ModelUtil | Lean.Name → Array (Lean.Expr × ℚ) → Lean.MetaM Unit |
Finset.max_abv_sum_one_le | Mathlib.NumberTheory.Height.Basic | ∀ {R : Type u_1} {S : Type u_2} [inst : Semiring R] [inst_1 : CommSemiring S] [inst_2 : LinearOrder S] [IsOrderedRing S]
[CharZero S] (v : AbsoluteValue R S) {ι : Type u_3} {s : Finset ι},
s.Nonempty → ∀ (x : ι → R), max (v (∑ i ∈ s, x i)) 1 ≤ ↑s.card * ∏ i ∈ s, max (v (x i)) 1 |
_private.Mathlib.CategoryTheory.Monoidal.Multifunctor.0.CategoryTheory.MonoidalCategory.curriedTensorPreFunctor._simp_1 | Mathlib.CategoryTheory.Monoidal.Multifunctor | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.MonoidalCategory C] (X : C)
{Y₁ Y₂ : C} (f : Y₁ ⟶ Y₂),
CategoryTheory.MonoidalCategoryStruct.whiskerLeft X f =
CategoryTheory.MonoidalCategoryStruct.tensorHom (CategoryTheory.CategoryStruct.id X) f |
MonotoneOn.convex_le | Mathlib.Analysis.Convex.Basic | ∀ {𝕜 : Type u_1} {E : Type u_2} {β : Type u_4} [inst : Semiring 𝕜] [inst_1 : PartialOrder 𝕜] [inst_2 : AddCommMonoid E]
[inst_3 : LinearOrder E] [IsOrderedAddMonoid E] [inst_5 : PartialOrder β] [inst_6 : Module 𝕜 E] [PosSMulMono 𝕜 E]
{s : Set E} {f : E → β}, MonotoneOn f s → Convex 𝕜 s → ∀ (r : β), Convex 𝕜 {x | x ∈ s ∧ f x ≤ r} |
Submodule.equivOpposite._proof_5 | Mathlib.Algebra.Algebra.Operations | ∀ {R : Type u_2} [inst : CommSemiring R] {A : Type u_1} [inst_1 : Semiring A] [inst_2 : Algebra R A]
(x : (Submodule R A)ᵐᵒᵖ),
MulOpposite.op
(Submodule.comap (↑(MulOpposite.opLinearEquiv R))
(Submodule.comap (↑(MulOpposite.opLinearEquiv R).symm) (MulOpposite.unop x))) =
x |
CategoryTheory.CommSq.rightAdjointLiftStructEquiv | Mathlib.CategoryTheory.LiftingProperties.Adjunction | {C : Type u_1} →
{D : Type u_2} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
[inst_1 : CategoryTheory.Category.{v_2, u_2} D] →
{G : CategoryTheory.Functor C D} →
{F : CategoryTheory.Functor D C} →
{A B : C} →
{X Y : D} →
{i : A ⟶ B} →
{p : X ⟶ Y} →
{u : G.obj A ⟶ X} →
{v : G.obj B ⟶ Y} →
(sq : CategoryTheory.CommSq u (G.map i) p v) → (adj : G ⊣ F) → sq.LiftStruct ≃ ⋯.LiftStruct |
CategoryTheory.Limits.limitObjIsoLimitCompEvaluation_inv_π_app | Mathlib.CategoryTheory.Limits.FunctorCategory.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {J : Type u₁} [inst_1 : CategoryTheory.Category.{v₁, u₁} J]
{K : Type u₂} [inst_2 : CategoryTheory.Category.{v₂, u₂} K] [inst_3 : CategoryTheory.Limits.HasLimitsOfShape J C]
(F : CategoryTheory.Functor J (CategoryTheory.Functor K C)) (j : J) (k : K),
CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.limitObjIsoLimitCompEvaluation F k).inv
((CategoryTheory.Limits.limit.π F j).app k) =
CategoryTheory.Limits.limit.π (F.comp ((CategoryTheory.evaluation K C).obj k)) j |
MeasureTheory.setLIntegral_measure_zero | Mathlib.MeasureTheory.Integral.Lebesgue.Basic | ∀ {α : Type u_1} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} (s : Set α) (f : α → ENNReal),
μ s = 0 → ∫⁻ (x : α) in s, f x ∂μ = 0 |
Std.ExtTreeMap.getKeyGE? | Std.Data.ExtTreeMap.Basic | {α : Type u} → {β : Type v} → {cmp : α → α → Ordering} → [Std.TransCmp cmp] → Std.ExtTreeMap α β cmp → α → Option α |
Lean.Compiler.LCNF.Simp.Config.casesOn | Lean.Compiler.LCNF.Simp.Config | {motive : Lean.Compiler.LCNF.Simp.Config → Sort u} →
(t : Lean.Compiler.LCNF.Simp.Config) →
((etaPoly inlinePartial implementedBy inlineDefs : Bool) →
motive
{ etaPoly := etaPoly, inlinePartial := inlinePartial, implementedBy := implementedBy,
inlineDefs := inlineDefs }) →
motive t |
ContinuousMap.HomotopyEquiv.prodCongr | Mathlib.Topology.Homotopy.Equiv | {X : Type u} →
{Y : Type v} →
{Z : Type w} →
{Z' : Type x} →
[inst : TopologicalSpace X] →
[inst_1 : TopologicalSpace Y] →
[inst_2 : TopologicalSpace Z] →
[inst_3 : TopologicalSpace Z'] →
ContinuousMap.HomotopyEquiv X Y →
ContinuousMap.HomotopyEquiv Z Z' → ContinuousMap.HomotopyEquiv (X × Z) (Y × Z') |
TopologicalSpace.UpgradedIsCompletelyMetrizableSpace.edist._inherited_default | Mathlib.Topology.Metrizable.CompletelyMetrizable | {X : Type u_3} →
(dist : X → X → ℝ) →
(∀ (x : X), dist x x = 0) →
(∀ (x y : X), dist x y = dist y x) → (∀ (x y z : X), dist x z ≤ dist x y + dist y z) → X → X → ENNReal |
ZeroHom.instAddCommGroup._proof_5 | Mathlib.Algebra.Group.Hom.Instances | ∀ {M : Type u_1} {N : Type u_2} [inst : Zero M] [inst_1 : AddCommGroup N] (a b : ZeroHom M N), a + b = b + a |
_private.Lean.Meta.Tactic.Grind.Arith.Cutsat.0.Lean.Meta.Grind.Arith.Cutsat.initFn._@.Lean.Meta.Tactic.Grind.Arith.Cutsat.798741302._hygCtx._hyg.2 | Lean.Meta.Tactic.Grind.Arith.Cutsat | IO Unit |
Set.sups_assoc | Mathlib.Data.Set.Sups | ∀ {α : Type u_2} [inst : SemilatticeSup α] (s t u : Set α), s ⊻ t ⊻ u = s ⊻ (t ⊻ u) |
_private.Lean.Server.ProtocolOverview.0.Lean.Server.Overview.MessageOverview.request.elim | Lean.Server.ProtocolOverview | {motive : Lean.Server.Overview.MessageOverview✝ → Sort u} →
(t : Lean.Server.Overview.MessageOverview✝¹) →
Lean.Server.Overview.MessageOverview.ctorIdx✝ t = 0 →
((o : Lean.Server.Overview.RequestOverview✝) → motive (Lean.Server.Overview.MessageOverview.request✝ o)) →
motive t |
natCast_eq_one | Mathlib.Algebra.Order.Kleene | ∀ {α : Type u_1} [inst : IdemSemiring α] {n : ℕ}, n ≠ 0 → ↑n = 1 |
CategoryTheory.Comma.unopFunctorCompFst | Mathlib.CategoryTheory.Comma.Basic | {A : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} A] →
{B : Type u₂} →
[inst_1 : CategoryTheory.Category.{v₂, u₂} B] →
{T : Type u₃} →
[inst_2 : CategoryTheory.Category.{v₃, u₃} T] →
(L : CategoryTheory.Functor A T) →
(R : CategoryTheory.Functor B T) →
(CategoryTheory.Comma.unopFunctor L R).comp (CategoryTheory.Comma.fst R L).op ≅
CategoryTheory.Comma.snd L.op R.op |
Equiv.Set.powerset._proof_4 | Mathlib.Logic.Equiv.Set | ∀ {α : Type u_1} (S : Set α) (x : ↑(𝒫 S)), (fun x => ⟨Subtype.val '' x, ⋯⟩) ((fun x => Subtype.val ⁻¹' ↑x) x) = x |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.