name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M |
|---|---|---|
Int.add_le_of_le_neg_add | Init.Data.Int.Order | ∀ {a b c : ℤ}, b ≤ -a + c → a + b ≤ c |
SimplicialObject.opEquivalence._proof_2 | Mathlib.AlgebraicTopology.SimplicialObject.Op | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] (X : CategoryTheory.SimplicialObject C),
CategoryTheory.CategoryStruct.comp
(SimplicialObject.opFunctor.map (SimplicialObject.opFunctorCompOpFunctorIso.symm.hom.app X))
(SimplicialObject.opFunctorCompOpFunctorIso.hom.app (SimplicialObject.opFunctor.obj X)) =
CategoryTheory.CategoryStruct.id (SimplicialObject.opFunctor.obj X) |
CategoryTheory.Limits.limit.isLimitToOver | Mathlib.CategoryTheory.Limits.Over | {J : Type w} →
[inst : CategoryTheory.Category.{w', w} J] →
{C : Type u} →
[inst_1 : CategoryTheory.Category.{v, u} C] →
(F : CategoryTheory.Functor J C) →
[inst_2 : CategoryTheory.Limits.HasLimit F] →
CategoryTheory.Limits.IsLimit (CategoryTheory.Limits.limit.toUnder F) |
Lean.Language.SnapshotTree.foldSnaps.Control.proceed.noConfusion | Lean.Server.Requests | {P : Sort u} →
{foldChildren foldChildren' : Bool} →
Lean.Language.SnapshotTree.foldSnaps.Control.proceed foldChildren =
Lean.Language.SnapshotTree.foldSnaps.Control.proceed foldChildren' →
(foldChildren = foldChildren' → P) → P |
PSet.Subset | Mathlib.SetTheory.ZFC.PSet | PSet.{u_1} → PSet.{u_2} → Prop |
mabs_div_le_max_div | Mathlib.Algebra.Order.Group.Abs | ∀ {G : Type u_1} [inst : CommGroup G] [inst_1 : LinearOrder G] [IsOrderedMonoid G] {a b c : G},
a ≤ b → b ≤ c → ∀ (d : G), |b / d|ₘ ≤ max (c / d) (d / a) |
Finsupp.weight_single_one_apply | Mathlib.Data.Finsupp.Weight | ∀ {σ : Type u_1} {R : Type u_3} [inst : Semiring R] [inst_1 : DecidableEq σ] (s : σ) (f : σ →₀ R),
(Finsupp.weight (Pi.single s 1)) f = f s |
forall_and_left | Mathlib.Logic.Basic | ∀ {α : Sort u_1} [Nonempty α] (q : Prop) (p : α → Prop), (∀ (x : α), q ∧ p x) ↔ q ∧ ∀ (x : α), p x |
CategoryTheory.MonoidalCategory.MonoidalRightAction.termρᵣ | Mathlib.CategoryTheory.Monoidal.Action.Basic | Lean.ParserDescr |
_private.Init.Data.String.Lemmas.FindPos.0.String.Slice.le_posLE_iff._simp_1_2 | Init.Data.String.Lemmas.FindPos | ∀ {s : String.Slice} {l r : s.Pos}, (l ≤ r) = (l.offset ≤ r.offset) |
Subalgebra.perfectClosure._proof_2 | Mathlib.FieldTheory.PurelyInseparable.Basic | ∀ (R : Type u_2) (A : Type u_1) [inst : CommSemiring R] [inst_1 : CommSemiring A] [inst_2 : Algebra R A] (p : ℕ)
[ExpChar A p] {a b : A},
a ∈ {x | ∃ n, x ^ p ^ n ∈ (algebraMap R A).rangeS} →
b ∈ {x | ∃ n, x ^ p ^ n ∈ (algebraMap R A).rangeS} → a + b ∈ {x | ∃ n, x ^ p ^ n ∈ (algebraMap R A).rangeS} |
instWellFoundedLTOrderDualOfWellFoundedGT | Mathlib.Order.RelClasses | ∀ (α : Type u_1) [inst : LT α] [h : WellFoundedGT α], WellFoundedLT αᵒᵈ |
Std.IteratorAccess.ctorIdx | Init.Data.Iterators.Consumers.Monadic.Access | {α : Type w} → {m : Type w → Type w'} → {β : Type w} → {inst : Std.Iterator α m β} → Std.IteratorAccess α m → ℕ |
_private.Mathlib.LinearAlgebra.Lagrange.0.Lagrange.basisDivisor_inj._simp_1_6 | Mathlib.LinearAlgebra.Lagrange | ∀ {G : Type u_3} [inst : AddGroup G] {a b : G}, (a - b = 0) = (a = b) |
ContinuousMap.linearIsometryBoundedOfCompact_apply_apply | Mathlib.Topology.ContinuousMap.Compact | ∀ {α : Type u_1} {E : Type u_3} [inst : TopologicalSpace α] [inst_1 : CompactSpace α]
[inst_2 : SeminormedAddCommGroup E] {𝕜 : Type u_4} [inst_3 : NormedRing 𝕜] [inst_4 : Module 𝕜 E]
[inst_5 : IsBoundedSMul 𝕜 E] (f : C(α, E)) (a : α), ((ContinuousMap.linearIsometryBoundedOfCompact α E 𝕜) f) a = f a |
LinearMap.mkContinuous_norm_le | Mathlib.Analysis.Normed.Operator.Basic | ∀ {𝕜 : Type u_1} {𝕜₂ : Type u_2} {E : Type u_4} {F : Type u_5} [inst : SeminormedAddCommGroup E]
[inst_1 : SeminormedAddCommGroup F] [inst_2 : NontriviallyNormedField 𝕜] [inst_3 : NontriviallyNormedField 𝕜₂]
[inst_4 : NormedSpace 𝕜 E] [inst_5 : NormedSpace 𝕜₂ F] {σ₁₂ : 𝕜 →+* 𝕜₂} (f : E →ₛₗ[σ₁₂] F) {C : ℝ},
0 ≤ C → ∀ (h : ∀ (x : E), ‖f x‖ ≤ C * ‖x‖), ‖f.mkContinuous C h‖ ≤ C |
Lean.TheoremVal.mk._flat_ctor | Lean.Declaration | Lean.Name → List Lean.Name → Lean.Expr → Lean.Expr → List Lean.Name → Lean.TheoremVal |
SuccOrder.prelimitRecOn._proof_2 | Mathlib.Order.SuccPred.Limit | ∀ {α : Type u_1} [inst : PartialOrder α] [inst_1 : SuccOrder α] (a : α),
¬Order.IsSuccPrelimit a → ∃ b, ¬IsMax b ∧ Order.succ b = a |
AlternativeMonad.map._inherited_default | Batteries.Control.AlternativeMonad | {m : Type u_1 → Type u_2} →
({α : Type u_1} → α → m α) → ({α β : Type u_1} → m α → (α → m β) → m β) → {α β : Type u_1} → (α → β) → m α → m β |
Ideal.Filtration.Stable.exists_pow_smul_eq | Mathlib.RingTheory.Filtration | ∀ {R : Type u_1} {M : Type u_2} [inst : CommRing R] [inst_1 : AddCommGroup M] [inst_2 : Module R M] {I : Ideal R}
{F : I.Filtration M}, F.Stable → ∃ n₀, ∀ (k : ℕ), F.N (n₀ + k) = I ^ k • F.N n₀ |
Lean.Meta.DiscrTree.casesOn | Lean.Meta.DiscrTree.Types | {α : Type} →
{motive : Lean.Meta.DiscrTree α → Sort u} →
(t : Lean.Meta.DiscrTree α) →
((root : Lean.PersistentHashMap Lean.Meta.DiscrTree.Key (Lean.Meta.DiscrTree.Trie α)) → motive { root := root }) →
motive t |
MeasureTheory.Measure.measure_support_eq_zero_iff._auto_1 | Mathlib.MeasureTheory.Measure.MeasureSpace | Lean.Syntax |
_private.Mathlib.MeasureTheory.Measure.Haar.Basic.0.MeasureTheory.Measure.haar.chaar_sup_le._simp_1_2 | Mathlib.MeasureTheory.Measure.Haar.Basic | ∀ {α : Type u_1} [inst : Preorder α] {b x : α}, (x ∈ Set.Ici b) = (b ≤ x) |
Lean.Grind.Config.splitImp._default | Init.Grind.Config | Bool |
Complex.mul_cpow_ofReal_nonneg | Mathlib.Analysis.SpecialFunctions.Pow.Complex | ∀ {a b : ℝ}, 0 ≤ a → 0 ≤ b → ∀ (r : ℂ), (↑a * ↑b) ^ r = ↑a ^ r * ↑b ^ r |
CategoryTheory.ProjectiveResolution.complex_d_comp_π_f_zero | Mathlib.CategoryTheory.Preadditive.Projective.Resolution | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasZeroObject C]
[inst_2 : CategoryTheory.Limits.HasZeroMorphisms C] {Z : C} (P : CategoryTheory.ProjectiveResolution Z),
CategoryTheory.CategoryStruct.comp (P.complex.d 1 0) (P.π.f 0) = 0 |
Equiv.normedCommGroup.eq_1 | Mathlib.Analysis.Normed.Module.TransferInstance | ∀ {α : Type u_1} {β : Type u_2} [inst : NormedCommGroup β] (e : α ≃ β),
e.normedCommGroup =
{ toNorm := (NormedCommGroup.induced α β e.mulEquiv ⋯).toNorm,
toCommGroup := (NormedCommGroup.induced α β e.mulEquiv ⋯).toCommGroup, toPseudoMetricSpace := e.pseudometricSpace,
eq_of_dist_eq_zero := ⋯, dist_eq := ⋯ } |
Std.DTreeMap.Internal.Impl.containsThenInsert_fst_eq_containsₘ | Std.Data.DTreeMap.Internal.WF.Lemmas | ∀ {α : Type u} {β : α → Type v} [inst : Ord α] [Std.TransOrd α] [inst_2 : BEq α] [Std.LawfulBEqOrd α]
(t : Std.DTreeMap.Internal.Impl α β) (htb : t.Balanced),
t.Ordered → ∀ (a : α) (b : β a), (Std.DTreeMap.Internal.Impl.containsThenInsert a b t htb).1 = t.containsₘ a |
Lean.Compiler.LCNF.MonadFVarSubst | Lean.Compiler.LCNF.CompilerM | (Type → Type) → outParam Lean.Compiler.LCNF.Purity → outParam Bool → Type |
MeasureTheory.Measure.quasiMeasurePreserving_smul | Mathlib.MeasureTheory.Measure.Lebesgue.EqHaar | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] [inst_2 : MeasurableSpace E] [BorelSpace E]
[FiniteDimensional ℝ E] (μ : MeasureTheory.Measure E) [μ.IsAddHaarMeasure] {r : ℝ},
r ≠ 0 → MeasureTheory.Measure.QuasiMeasurePreserving (fun x => r • x) μ μ |
Metric.closedBall_eq_sphere_of_nonpos | Mathlib.Topology.MetricSpace.Pseudo.Defs | ∀ {α : Type u} [inst : PseudoMetricSpace α] {x : α} {ε : ℝ}, ε ≤ 0 → Metric.closedBall x ε = Metric.sphere x ε |
Rack.PreEnvelGroupRel'.symm | Mathlib.Algebra.Quandle | {R : Type u} →
[inst : Rack R] → {a b : Rack.PreEnvelGroup R} → Rack.PreEnvelGroupRel' R a b → Rack.PreEnvelGroupRel' R b a |
Lean.ErrorExplanation.declLoc? | Lean.ErrorExplanation | Lean.ErrorExplanation → Option Lean.DeclarationLocation |
Module.rankAtStalk_tensorProduct_of_isScalarTower | Mathlib.RingTheory.Spectrum.Prime.FreeLocus | ∀ {R : Type uR} {M : Type uM} [inst : CommRing R] [inst_1 : AddCommGroup M] [inst_2 : Module R M] [Module.Flat R M]
[Module.Finite R M] {S : Type u_1} [inst_5 : CommRing S] [inst_6 : Algebra R S] (N : Type u_2)
[inst_7 : AddCommGroup N] [inst_8 : Module R N] [inst_9 : Module S N] [inst_10 : IsScalarTower R S N]
[Module.Finite S N] [Module.Flat S N] (p : PrimeSpectrum S),
Module.rankAtStalk (TensorProduct R N M) p =
Module.rankAtStalk N p * Module.rankAtStalk M (PrimeSpectrum.comap (algebraMap R S) p) |
WithTop.insertTop | Mathlib.Order.Interval.Finset.Defs | {α : Type u_1} → Finset α ↪o Finset (WithTop α) |
_private.Mathlib.Topology.MetricSpace.PiNat.0.PiCountable.pseudoEMetricSpace._simp_8 | Mathlib.Topology.MetricSpace.PiNat | ∀ {a b c : Prop}, (a ∧ b → c) = (a → b → c) |
SemiNormedGrp.explicitCokernelDesc._proof_1 | Mathlib.Analysis.Normed.Group.SemiNormedGrp.Kernels | ∀ {X Y Z : SemiNormedGrp} {f : X ⟶ Y} {g : Y ⟶ Z},
CategoryTheory.CategoryStruct.comp f g = 0 →
CategoryTheory.CategoryStruct.comp f g = CategoryTheory.CategoryStruct.comp 0 g |
GroupExtension.Splitting.instFunLike | Mathlib.GroupTheory.GroupExtension.Defs | {N : Type u_1} →
{E : Type u_2} →
{G : Type u_3} →
[inst : Group N] → [inst_1 : Group E] → [inst_2 : Group G] → (S : GroupExtension N E G) → FunLike S.Splitting G E |
SimpleGraph.cliqueFinset.congr_simp | Mathlib.Combinatorics.SimpleGraph.Clique | ∀ {α : Type u_1} (G G_1 : SimpleGraph α),
G = G_1 →
∀ [inst : Fintype α] [inst_1 : DecidableEq α] {inst_2 : DecidableRel G.Adj} [inst_3 : DecidableRel G_1.Adj]
(n n_1 : ℕ), n = n_1 → G.cliqueFinset n = G_1.cliqueFinset n_1 |
LocallyConstant.instInhabited._proof_1 | Mathlib.Topology.LocallyConstant.Basic | ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] [inst_1 : Inhabited Y],
IsLocallyConstant (Function.const X default) |
Batteries.Random.MersenneTwister.State.noConfusion | Batteries.Data.Random.MersenneTwister | {P : Sort u} →
{cfg : Batteries.Random.MersenneTwister.Config} →
{t : Batteries.Random.MersenneTwister.State cfg} →
{cfg' : Batteries.Random.MersenneTwister.Config} →
{t' : Batteries.Random.MersenneTwister.State cfg'} →
cfg = cfg' → t ≍ t' → Batteries.Random.MersenneTwister.State.noConfusionType P t t' |
String.mk | Init.Data.String.Bootstrap | List Char → String |
Option.decidableForallMem._proof_3 | Init.Data.Option.Instances | ∀ {α : Type u_1} {p : α → Prop} (a : α), ¬p a → ¬∀ a_1 ∈ some a, p a_1 |
_private.Init.Data.SInt.Bitwise.0.Int16.shiftRight_and._simp_1_1 | Init.Data.SInt.Bitwise | ∀ {a b : Int16}, (a = b) = (a.toBitVec = b.toBitVec) |
_private.Lean.Meta.SynthInstance.0.Lean.Meta.SynthInstance.removeUnusedArguments? | Lean.Meta.SynthInstance | Lean.MetavarContext → Lean.Expr → Lean.MetaM (Option (Lean.Expr × Lean.Expr)) |
_private.Lean.Elab.Match.0.Lean.Elab.Term.withElaboratedLHS | Lean.Elab.Match | {α : Type} →
Array Lean.Elab.Term.PatternVarDecl →
Array Lean.Syntax →
Lean.Syntax →
ℕ →
Lean.Expr →
(Lean.Meta.Match.AltLHS → Lean.Expr → Lean.Elab.TermElabM α) →
ExceptT Lean.Elab.Term.PatternElabException Lean.Elab.TermElabM α |
Denumerable.raise'._unsafe_rec | Mathlib.Logic.Equiv.Finset | List ℕ → ℕ → List ℕ |
Int16.ofBitVec_ofNat | Init.Data.SInt.Lemmas | ∀ (n : ℕ), Int16.ofBitVec (BitVec.ofNat 16 n) = Int16.ofNat n |
CategoryTheory.Limits.IsLimit.pullbackConeEquivBinaryFanFunctor | Mathlib.CategoryTheory.Limits.Constructions.Over.Products | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{X Y Z : C} →
{f : Y ⟶ X} →
{g : Z ⟶ X} →
{c : CategoryTheory.Limits.PullbackCone f g} →
CategoryTheory.Limits.IsLimit c →
CategoryTheory.Limits.IsLimit (CategoryTheory.Limits.pullbackConeEquivBinaryFan.functor.obj c) |
CategoryTheory.Abelian.Preradical.toColon_hom_left_colonπ | Mathlib.CategoryTheory.Abelian.Preradical.Colon | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} C] [inst_1 : CategoryTheory.Abelian C]
(Φ Ψ : CategoryTheory.Abelian.Preradical C),
CategoryTheory.CategoryStruct.comp (Φ.toColon Ψ).hom.left (Φ.colonπ Ψ) = 0 |
_private.Mathlib.RingTheory.Invariant.Basic.0.Ideal.Quotient.exists_algHom_fixedPoint_quotient_under._simp_1_2 | Mathlib.RingTheory.Invariant.Basic | ∀ {G : Type u_3} [inst : AddGroup G] {a b : G}, (a - b = 0) = (a = b) |
CategoryTheory.ComposableArrows.isoMkSucc_inv | Mathlib.CategoryTheory.ComposableArrows.Basic | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {n : ℕ} {F G : CategoryTheory.ComposableArrows C (n + 1)}
(α : F.obj' 0 ⋯ ≅ G.obj' 0 ⋯) (β : F.δ₀ ≅ G.δ₀)
(w :
CategoryTheory.CategoryStruct.comp (F.map' 0 1 CategoryTheory.ComposableArrows.homMk₁._proof_4 ⋯)
(CategoryTheory.ComposableArrows.app' β.hom 0 ⋯) =
CategoryTheory.CategoryStruct.comp α.hom (G.map' 0 1 CategoryTheory.ComposableArrows.homMk₁._proof_4 ⋯)),
(CategoryTheory.ComposableArrows.isoMkSucc α β w).inv = CategoryTheory.ComposableArrows.homMkSucc α.inv β.inv ⋯ |
comap_abs_nhds_zero | Mathlib.Topology.Algebra.Order.Group | ∀ {G : Type u_1} [inst : TopologicalSpace G] [inst_1 : AddCommGroup G] [inst_2 : LinearOrder G] [IsOrderedAddMonoid G]
[OrderTopology G], Filter.comap abs (nhds 0) = nhds 0 |
Matrix.transpose_zero | Mathlib.LinearAlgebra.Matrix.Defs | ∀ {m : Type u_2} {n : Type u_3} {α : Type v} [inst : Zero α], Matrix.transpose 0 = 0 |
RootPairing.Equiv.toEndUnit._proof_9 | Mathlib.LinearAlgebra.RootSystem.Hom | ∀ {ι : Type u_1} {R : Type u_4} {M : Type u_2} {N : Type u_3} [inst : CommRing R] [inst_1 : AddCommGroup M]
[inst_2 : Module R M] [inst_3 : AddCommGroup N] [inst_4 : Module R N] (P : RootPairing ι R M N) (f g : P.Aut),
{ val := ↑(f * g), inv := ↑(RootPairing.Equiv.symm P P (f * g)), val_inv := ⋯, inv_val := ⋯ } =
{ val := ↑f, inv := ↑(RootPairing.Equiv.symm P P f), val_inv := ⋯, inv_val := ⋯ } *
{ val := ↑g, inv := ↑(RootPairing.Equiv.symm P P g), val_inv := ⋯, inv_val := ⋯ } |
_private.Lean.Meta.Tactic.Grind.0.Lean.initFn._@.Lean.Meta.Tactic.Grind.964293774._hygCtx._hyg.2 | Lean.Meta.Tactic.Grind | IO Unit |
SimpleGraph.IsMaximumClique.maximum | Mathlib.Combinatorics.SimpleGraph.Clique | ∀ {α : Type u_3} [inst : Finite α] {G : SimpleGraph α} {s : Finset α},
G.IsMaximumClique s → ∀ (t : Finset α), G.IsClique ↑t → t.card ≤ s.card |
Stream'.Seq.terminates_ofList | Mathlib.Data.Seq.Basic | ∀ {α : Type u} (l : List α), (↑l).Terminates |
Std.TreeMap.instSliceableRooSlice._auto_1 | Std.Data.TreeMap.Slice | Lean.Syntax |
_private.Lean.Meta.Tactic.Rewrites.0.Lean.Meta.Rewrites.takeListAux.match_7 | Lean.Meta.Tactic.Rewrites | (motive : MProd (Array Lean.Meta.Rewrites.RewriteResult) (Std.HashMap String Unit) → Sort u_1) →
(x : MProd (Array Lean.Meta.Rewrites.RewriteResult) (Std.HashMap String Unit)) →
((acc : Array Lean.Meta.Rewrites.RewriteResult) → (seen : Std.HashMap String Unit) → motive ⟨acc, seen⟩) → motive x |
_private.Init.Data.Array.Lemmas.0.Array.foldlM_loop_empty._proof_1_2 | Init.Data.Array.Lemmas | ∀ {α : Type u_1} {s j : ℕ}, j < s → s = 0 → False |
_private.Mathlib.Analysis.Calculus.Deriv.Inverse.0.HasDerivWithinAt.eventually_ne._simp_1_2 | Mathlib.Analysis.Calculus.Deriv.Inverse | ∀ {α : Type u_2} [inst : Zero α] [inst_1 : OfNat α 2] [NeZero 2], (2 = 0) = False |
emultiplicity_map_eq | Mathlib.RingTheory.Multiplicity | ∀ {α : Type u_1} {β : Type u_2} [inst : Monoid α] [inst_1 : Monoid β] {F : Type u_3} [inst_2 : EquivLike F α β]
[MulEquivClass F α β] (f : F) {a b : α}, emultiplicity (f a) (f b) = emultiplicity a b |
_private.Lean.Util.Recognizers.0.Lean.Expr.notNot?.match_1 | Lean.Util.Recognizers | (motive : Option Lean.Expr → Sort u_1) →
(x : Option Lean.Expr) → ((p : Lean.Expr) → motive (some p)) → (Unit → motive none) → motive x |
_private.Mathlib.Analysis.InnerProductSpace.Spectrum.0.LinearMap.IsSymmetric.unsortedEigenvectorBasis | Mathlib.Analysis.InnerProductSpace.Spectrum | {𝕜 : Type u_1} →
[inst : RCLike 𝕜] →
{E : Type u_2} →
[inst_1 : NormedAddCommGroup E] →
[inst_2 : InnerProductSpace 𝕜 E] →
{T : E →ₗ[𝕜] E} →
[FiniteDimensional 𝕜 E] → {n : ℕ} → T.IsSymmetric → Module.finrank 𝕜 E = n → OrthonormalBasis (Fin n) 𝕜 E |
CFC.abs_ofNat | Mathlib.Analysis.SpecialFunctions.ContinuousFunctionalCalculus.Abs | ∀ {A : Type u_2} [inst : Ring A] [inst_1 : StarRing A] [inst_2 : TopologicalSpace A] [inst_3 : Algebra ℝ A]
[inst_4 : ContinuousFunctionalCalculus ℝ A IsSelfAdjoint] [inst_5 : PartialOrder A] [inst_6 : StarOrderedRing A]
[inst_7 : NonnegSpectrumClass ℝ A] [IsTopologicalRing A] [T2Space A] [StarModule ℝ A] (n : ℕ)
[inst_11 : n.AtLeastTwo], CFC.abs (OfNat.ofNat n) = OfNat.ofNat n |
Fin.preimage_val_uIoo_val | Mathlib.Order.Interval.Set.Fin | ∀ {n : ℕ} (i j : Fin n), Fin.val ⁻¹' Set.uIoo ↑i ↑j = Set.uIoo i j |
OpenPartialHomeomorph.homeomorphOfImageSubsetSource._proof_2 | Mathlib.Topology.OpenPartialHomeomorph.Basic | ∀ {X : Type u_2} {Y : Type u_1} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y]
(e : OpenPartialHomeomorph X Y) {s : Set X} {t : Set Y}, s ⊆ e.source → ↑e '' s = t → t ⊆ e.target |
_private.Mathlib.CategoryTheory.WithTerminal.Cone.0.CategoryTheory.WithTerminal.coneBack_obj_pt | Mathlib.CategoryTheory.WithTerminal.Cone | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {J : Type w} [inst_1 : CategoryTheory.Category.{w', w} J]
{X : C} {K : CategoryTheory.Functor J (CategoryTheory.Over X)}
(t : CategoryTheory.Limits.Cone (CategoryTheory.WithTerminal.liftFromOver.obj K)),
(CategoryTheory.WithTerminal.coneBack✝.obj t).pt = CategoryTheory.Over.mk (t.π.app CategoryTheory.WithTerminal.star) |
Units.cfcRpow._auto_1 | Mathlib.Analysis.SpecialFunctions.ContinuousFunctionalCalculus.Rpow.Basic | Lean.Syntax |
Int64.reduceLT._regBuiltin.Int64.reduceLT.declare_1._@.Lean.Meta.Tactic.Simp.BuiltinSimprocs.SInt.4041591762._hygCtx._hyg.165 | Lean.Meta.Tactic.Simp.BuiltinSimprocs.SInt | IO Unit |
CategoryTheory.LaxFunctor._sizeOf_inst | Mathlib.CategoryTheory.Bicategory.Functor.Lax | (B : Type u₁) →
{inst : CategoryTheory.Bicategory B} →
(C : Type u₂) →
{inst_1 : CategoryTheory.Bicategory C} → [SizeOf B] → [SizeOf C] → SizeOf (CategoryTheory.LaxFunctor B C) |
AddSubgroup.toIntSubmodule._proof_4 | Mathlib.Algebra.Module.Submodule.Lattice | ∀ {M : Type u_1} [inst : AddCommGroup M] {a b : AddSubgroup M},
{ toFun := fun S => { toAddSubmonoid := S.toAddSubmonoid, smul_mem' := ⋯ }, invFun := Submodule.toAddSubgroup,
left_inv := ⋯, right_inv := ⋯ }
a ≤
{ toFun := fun S => { toAddSubmonoid := S.toAddSubmonoid, smul_mem' := ⋯ }, invFun := Submodule.toAddSubgroup,
left_inv := ⋯, right_inv := ⋯ }
b ↔
{ toFun := fun S => { toAddSubmonoid := S.toAddSubmonoid, smul_mem' := ⋯ }, invFun := Submodule.toAddSubgroup,
left_inv := ⋯, right_inv := ⋯ }
a ≤
{ toFun := fun S => { toAddSubmonoid := S.toAddSubmonoid, smul_mem' := ⋯ }, invFun := Submodule.toAddSubgroup,
left_inv := ⋯, right_inv := ⋯ }
b |
FirstOrder.Language.BoundedFormula.mapTermRel.eq_def | Mathlib.ModelTheory.Syntax | ∀ {L : FirstOrder.Language} {L' : FirstOrder.Language} {α : Type u'} {β : Type v'} {g : ℕ → ℕ}
(ft : (n : ℕ) → L.Term (α ⊕ Fin n) → L'.Term (β ⊕ Fin (g n))) (fr : (n : ℕ) → L.Relations n → L'.Relations n)
(h : (n : ℕ) → L'.BoundedFormula β (g (n + 1)) → L'.BoundedFormula β (g n + 1)) (x : ℕ) (x_1 : L.BoundedFormula α x),
FirstOrder.Language.BoundedFormula.mapTermRel ft fr h x_1 =
match x, x_1 with
| _n, FirstOrder.Language.BoundedFormula.falsum => FirstOrder.Language.BoundedFormula.falsum
| _n, FirstOrder.Language.BoundedFormula.equal t₁ t₂ =>
FirstOrder.Language.BoundedFormula.equal (ft _n t₁) (ft _n t₂)
| _n, FirstOrder.Language.BoundedFormula.rel R ts =>
FirstOrder.Language.BoundedFormula.rel (fr l R) fun i => ft _n (ts i)
| _n, φ₁.imp φ₂ =>
(FirstOrder.Language.BoundedFormula.mapTermRel ft fr h φ₁).imp
(FirstOrder.Language.BoundedFormula.mapTermRel ft fr h φ₂)
| n, φ.all => (h n (FirstOrder.Language.BoundedFormula.mapTermRel ft fr h φ)).all |
Mathlib.Tactic.Translate.TranslateData.unfoldBoundaries? | Mathlib.Tactic.Translate.Core | Mathlib.Tactic.Translate.TranslateData → Option Mathlib.Tactic.UnfoldBoundary.UnfoldBoundaryExt |
normalizedGCDMonoidOfLCM._proof_5 | Mathlib.Algebra.GCDMonoid.Basic | ∀ {α : Type u_1} [inst : CommMonoidWithZero α] [IsCancelMulZero α] [inst_2 : NormalizationMonoid α]
[inst_3 : DecidableEq α] (lcm : α → α → α) (lcm_dvd : ∀ {a b c : α}, c ∣ a → b ∣ a → lcm c b ∣ a),
(∀ (a b : α), normalize (lcm a b) = lcm a b) →
∀ (a b : α),
normalize (if a = 0 then normalize b else if b = 0 then normalize a else Classical.choose ⋯) =
if a = 0 then normalize b else if b = 0 then normalize a else Classical.choose ⋯ |
Std.ExtHashSet.contains_iff_mem._simp_1 | Std.Data.ExtHashSet.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {m : Std.ExtHashSet α} [inst : EquivBEq α] [inst_1 : LawfulHashable α]
{a : α}, (m.contains a = true) = (a ∈ m) |
Array.le_min?_iff | Init.Data.Array.MinMax | ∀ {α : Type u_1} {a : α} [inst : Min α] [inst_1 : LE α] [Std.LawfulOrderInf α] {xs : Array α},
xs.min? = some a → ∀ {x : α}, x ≤ a ↔ ∀ b ∈ xs, x ≤ b |
Lean.pp.rawOnError | Lean.Util.PPExt | Lean.Option Bool |
QuotientGroup.quotientInfEquivProdNormalQuotient.eq_1 | Mathlib.GroupTheory.QuotientGroup.Basic | ∀ {G : Type u} [inst : Group G] (H N : Subgroup G) [hN : N.Normal],
QuotientGroup.quotientInfEquivProdNormalQuotient H N = QuotientGroup.quotientInfEquivProdNormalizerQuotient H N ⋯ |
_private.Mathlib.Data.EReal.Operations.0.ENNReal.toEReal_sub._simp_1_1 | Mathlib.Data.EReal.Operations | ∀ {r p : NNReal}, ↑r - ↑p = ↑(r - p) |
CategoryTheory.Functor.mapHomologicalComplexUpToQuasiIsoFactorsh_hom_app_assoc | Mathlib.Algebra.Homology.Localization | ∀ {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] (F : CategoryTheory.Functor C D) {ι : Type u_3} {c : ComplexShape ι}
[inst_2 : CategoryTheory.Preadditive C] [inst_3 : CategoryTheory.Preadditive D]
[inst_4 : CategoryTheory.CategoryWithHomology C] [inst_5 : CategoryTheory.CategoryWithHomology D]
[inst_6 : (HomologicalComplex.quasiIso D c).HasLocalization] [inst_7 : F.Additive] [inst_8 : F.PreservesHomology]
[inst_9 : (HomologicalComplex.quasiIso C c).HasLocalization] [inst_10 : c.QFactorsThroughHomotopy C]
[inst_11 : c.QFactorsThroughHomotopy D]
[inst_12 : (HomotopyCategory.quotient C c).IsLocalization (HomologicalComplex.homotopyEquivalences C c)]
(K : HomologicalComplex C c) {Z : HomologicalComplexUpToQuasiIso D c}
(h :
HomologicalComplexUpToQuasiIso.Qh.obj ((F.mapHomotopyCategory c).obj ((HomotopyCategory.quotient C c).obj K)) ⟶ Z),
CategoryTheory.CategoryStruct.comp
((F.mapHomologicalComplexUpToQuasiIsoFactorsh c).hom.app ((HomotopyCategory.quotient C c).obj K)) h =
CategoryTheory.CategoryStruct.comp
((F.mapHomologicalComplexUpToQuasiIso c).map ((HomologicalComplexUpToQuasiIso.quotientCompQhIso C c).hom.app K))
(CategoryTheory.CategoryStruct.comp ((F.mapHomologicalComplexUpToQuasiIsoFactors c).hom.app K)
(CategoryTheory.CategoryStruct.comp
((HomologicalComplexUpToQuasiIso.quotientCompQhIso D c).inv.app ((F.mapHomologicalComplex c).obj K))
(CategoryTheory.CategoryStruct.comp
(HomologicalComplexUpToQuasiIso.Qh.map ((F.mapHomotopyCategoryFactors c).inv.app K)) h))) |
SemiNormedGrp₁.coe_of | Mathlib.Analysis.Normed.Group.SemiNormedGrp | ∀ (V : Type u) [inst : SeminormedAddCommGroup V], { carrier := V, str := inst }.carrier = V |
AdicCompletion.ofLinearEquiv.eq_1 | Mathlib.RingTheory.AdicCompletion.Basic | ∀ {R : Type u_1} [inst : CommRing R] (I : Ideal R) (M : Type u_4) [inst_1 : AddCommGroup M] [inst_2 : Module R M]
[inst_3 : IsAdicComplete I M], AdicCompletion.ofLinearEquiv I M = LinearEquiv.ofBijective (AdicCompletion.of I M) ⋯ |
Algebra.SubmersivePresentation.isStandardSmoothOfRelativeDimension | Mathlib.RingTheory.Smooth.StandardSmooth | ∀ {n : ℕ} {R : Type u} {S : Type v} {ι : Type w} {σ : Type t} [inst : CommRing R] [inst_1 : CommRing S]
[inst_2 : Algebra R S] [inst_3 : Finite σ] [Finite ι] (P : Algebra.SubmersivePresentation R S ι σ),
P.dimension = n → Algebra.IsStandardSmoothOfRelativeDimension n R S |
ContinuousMap.toNNReal_algebraMap | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Unique | ∀ {X : Type u_1} [inst : TopologicalSpace X] (r : NNReal),
((algebraMap ℝ C(X, ℝ)) ↑r).toNNReal = (algebraMap NNReal C(X, NNReal)) r |
_private.Mathlib.Algebra.Polynomial.Degree.TrailingDegree.0.Polynomial.natTrailingDegree_intCast._simp_1_1 | Mathlib.Algebra.Polynomial.Degree.TrailingDegree | ∀ {R : Type u} [inst : Ring R] (n : ℤ), ↑n = Polynomial.C ↑n |
MeasureTheory.measure_eq_top_of_setLIntegral_ne_top | Mathlib.MeasureTheory.Integral.Lebesgue.Markov | ∀ {α : Type u_1} {mα : MeasurableSpace α} {μ : MeasureTheory.Measure α} {f : α → ENNReal} {s : Set α},
AEMeasurable f (μ.restrict s) → ∫⁻ (x : α) in s, f x ∂μ ≠ ⊤ → μ {x | x ∈ s ∧ f x = ⊤} = 0 |
_private.Lean.Elab.Notation.0.Lean.Elab.Command.expandNotationItemIntoSyntaxItem._sparseCasesOn_1 | Lean.Elab.Notation | {α : Type u} →
{motive : Option α → Sort u_1} →
(t : Option α) → ((val : α) → motive (some val)) → (Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t |
CategoryTheory.CommGrp.forget | Mathlib.CategoryTheory.Monoidal.CommGrp_ | (C : Type u₁) →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
[inst_1 : CategoryTheory.CartesianMonoidalCategory C] →
[inst_2 : CategoryTheory.BraidedCategory C] → CategoryTheory.Functor (CategoryTheory.CommGrp C) C |
RootPairing.zero_notMem_range_root | Mathlib.LinearAlgebra.RootSystem.Defs | ∀ {ι : Type u_1} {R : Type u_2} {M : Type u_3} {N : Type u_4} [inst : CommRing R] [inst_1 : AddCommGroup M]
[inst_2 : Module R M] [inst_3 : AddCommGroup N] [inst_4 : Module R N] (P : RootPairing ι R M N) [NeZero 2],
0 ∉ Set.range ⇑P.root |
Mathlib.Tactic.ITauto.Proof.andIntro.inj | Mathlib.Tactic.ITauto | ∀ {ak : Mathlib.Tactic.ITauto.AndKind} {p₁ p₂ : Mathlib.Tactic.ITauto.Proof} {ak_1 : Mathlib.Tactic.ITauto.AndKind}
{p₁_1 p₂_1 : Mathlib.Tactic.ITauto.Proof},
Mathlib.Tactic.ITauto.Proof.andIntro ak p₁ p₂ = Mathlib.Tactic.ITauto.Proof.andIntro ak_1 p₁_1 p₂_1 →
ak = ak_1 ∧ p₁ = p₁_1 ∧ p₂ = p₂_1 |
ZeroHom.casesOn | Mathlib.Algebra.Group.Hom.Defs | {M : Type u_10} →
{N : Type u_11} →
[inst : Zero M] →
[inst_1 : Zero N] →
{motive : ZeroHom M N → Sort u} →
(t : ZeroHom M N) →
((toFun : M → N) → (map_zero' : toFun 0 = 0) → motive { toFun := toFun, map_zero' := map_zero' }) → motive t |
FractionalIdeal.isFractional_span_iff | Mathlib.RingTheory.FractionalIdeal.Operations | ∀ {R : Type u_1} [inst : CommRing R] {S : Submonoid R} {P : Type u_2} [inst_1 : CommRing P] [inst_2 : Algebra R P]
{s : Set P}, IsFractional S (Submodule.span R s) ↔ ∃ a ∈ S, ∀ b ∈ s, IsLocalization.IsInteger R (a • b) |
CategoryTheory.Limits.FormalCoproduct.ι_comp_coproductIsoCofanPt | Mathlib.CategoryTheory.Limits.FormalCoproducts.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {𝒜 : Type w} {f : 𝒜 → CategoryTheory.Limits.FormalCoproduct C}
(i : 𝒜),
CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.Sigma.ι f i)
(CategoryTheory.Limits.FormalCoproduct.coproductIsoCofanPt 𝒜 f).hom =
(CategoryTheory.Limits.FormalCoproduct.cofan 𝒜 f).inj i |
LinearMap.coe_toContinuousLinearMap | Mathlib.Topology.Algebra.Module.FiniteDimension | ∀ {𝕜 : Type u} [hnorm : NontriviallyNormedField 𝕜] {E : Type v} [inst : AddCommGroup E] [inst_1 : Module 𝕜 E]
[inst_2 : TopologicalSpace E] [inst_3 : IsTopologicalAddGroup E] [inst_4 : ContinuousSMul 𝕜 E] {F' : Type x}
[inst_5 : AddCommGroup F'] [inst_6 : Module 𝕜 F'] [inst_7 : TopologicalSpace F'] [inst_8 : IsTopologicalAddGroup F']
[inst_9 : ContinuousSMul 𝕜 F'] [inst_10 : CompleteSpace 𝕜] [inst_11 : T2Space E] [inst_12 : FiniteDimensional 𝕜 E]
(f : E →ₗ[𝕜] F'), ↑(LinearMap.toContinuousLinearMap f) = f |
ENNReal.add_ne_top | Mathlib.Data.ENNReal.Operations | ∀ {a b : ENNReal}, a + b ≠ ⊤ ↔ a ≠ ⊤ ∧ b ≠ ⊤ |
Int.emod_zero | Init.Data.Int.DivMod.Bootstrap | ∀ (a : ℤ), a % 0 = a |
MeasureTheory.tendsto_measure_of_null_frontier | Mathlib.MeasureTheory.Measure.Portmanteau | ∀ {Ω : Type u_1} [inst : MeasurableSpace Ω] [inst_1 : TopologicalSpace Ω] [OpensMeasurableSpace Ω] {ι : Type u_2}
{L : Filter ι} {μ : MeasureTheory.Measure Ω} {μs : ι → MeasureTheory.Measure Ω} [MeasureTheory.IsProbabilityMeasure μ]
[∀ (i : ι), MeasureTheory.IsProbabilityMeasure (μs i)],
(∀ (G : Set Ω), IsOpen G → μ G ≤ Filter.liminf (fun i => (μs i) G) L) →
∀ {E : Set Ω}, μ (frontier E) = 0 → Filter.Tendsto (fun i => (μs i) E) L (nhds (μ E)) |
RingEquiv.map_sum | Mathlib.Algebra.BigOperators.RingEquiv | ∀ {α : Type u_1} {R : Type u_2} {S : Type u_3} [inst : NonUnitalNonAssocSemiring R]
[inst_1 : NonUnitalNonAssocSemiring S] (g : R ≃+* S) (f : α → R) (s : Finset α), g (∑ x ∈ s, f x) = ∑ x ∈ s, g (f x) |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.