name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M |
|---|---|---|
inf_eq_and_sup_eq_iff | Mathlib.Order.Lattice | ∀ {α : Type u} [inst : Lattice α] {a b c : α}, a ⊓ b = c ∧ a ⊔ b = c ↔ a = c ∧ b = c |
Lean.Parser.Term.strictImplicitRightBracket.parenthesizer | Lean.Parser.Term.Basic | Lean.PrettyPrinter.Parenthesizer |
Affine.Triangle.toPolygon_toTriangle | Mathlib.Geometry.Polygon.Basic | ∀ {R : Type u_1} {V : Type u_2} {P : Type u_3} [inst : Ring R] [inst_1 : AddCommGroup V] [inst_2 : Module R V]
[inst_3 : AddTorsor V P] (t : Affine.Triangle R P), Polygon.toTriangle R (Affine.Triangle.toPolygon t) ⋯ = t |
Function.range_eq_image_or_of_mulSupport_subset | Mathlib.Algebra.Notation.Support | ∀ {ι : Type u_1} {M : Type u_3} [inst : One M] {f : ι → M} {k : Set ι},
Function.mulSupport f ⊆ k → Set.range f = f '' k ∨ Set.range f = insert 1 (f '' k) |
_private.Mathlib.MeasureTheory.Group.FundamentalDomain.0.MeasureTheory._aux_Mathlib_MeasureTheory_Group_FundamentalDomain___unexpand_AddAction_orbitRel_1 | Mathlib.MeasureTheory.Group.FundamentalDomain | Lean.PrettyPrinter.Unexpander |
DomAddAct.instFaithfulVAddForallOfNontrivial | Mathlib.GroupTheory.GroupAction.DomAct.Basic | ∀ {M : Type u_1} {β : Type u_2} {α : Type u_3} [inst : VAdd M α] [FaithfulVAdd M α] [Nontrivial β],
FaithfulVAdd Mᵈᵃᵃ (α → β) |
_private.Mathlib.Topology.Homotopy.Basic.0.ContinuousMap.Homotopic.prodMk.match_1_1 | Mathlib.Topology.Homotopy.Basic | ∀ {X : Type u_1} {Y : Type u_2} {Z : Type u_3} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y]
[inst_2 : TopologicalSpace Z] {f₀ f₁ : C(X, Y)} {g₀ g₁ : C(X, Z)} (motive : f₀.Homotopic f₁ → g₀.Homotopic g₁ → Prop)
(x : f₀.Homotopic f₁) (x_1 : g₀.Homotopic g₁),
(∀ (F : f₀.Homotopy f₁) (G : g₀.Homotopy g₁), motive ⋯ ⋯) → motive x x_1 |
CategoryTheory.StrictPseudofunctorCore.map₂_right_unitor._autoParam | Mathlib.CategoryTheory.Bicategory.Functor.StrictPseudofunctor | Lean.Syntax |
Symmetric.flip_eq | Mathlib.Logic.Relation | ∀ {α : Sort u_1} {r : α → α → Prop}, Symmetric r → flip r = r |
affineHomeomorph._proof_1 | Mathlib.Topology.Algebra.Field | ∀ {𝕜 : Type u_1} [inst : Field 𝕜] (a b : 𝕜), a ≠ 0 → ∀ (x : 𝕜), (fun y => (y - b) / a) ((fun x => a * x + b) x) = x |
Nat.ofDigits_eq_sum_mapIdx | Mathlib.Data.Nat.Digits.Lemmas | ∀ (b : ℕ) (L : List ℕ), Nat.ofDigits b L = (List.mapIdx (fun i a => a * b ^ i) L).sum |
HomRel.FactorsThroughLocalization.strictUniversalPropertyFixedTarget._proof_5 | Mathlib.CategoryTheory.Localization.Quotient | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {homRel : HomRel C}
{W : CategoryTheory.MorphismProperty C},
homRel.FactorsThroughLocalization W →
∀ {E : Type u_4} [inst_1 : CategoryTheory.Category.{u_3, u_4} E] (F : CategoryTheory.Functor C E),
W.IsInvertedBy F → ∀ (x x_1 : C) (f g : x ⟶ x_1), homRel f g → F.map f = F.map g |
AddSubgroup.index_eq_zero_iff_infinite | Mathlib.GroupTheory.Index | ∀ {G : Type u_1} [inst : AddGroup G] {H : AddSubgroup G}, H.index = 0 ↔ Infinite (G ⧸ H) |
_private.Mathlib.RingTheory.MvPolynomial.MonomialOrder.0.MonomialOrder.degree_add_le._simp_1_2 | Mathlib.RingTheory.MvPolynomial.MonomialOrder | ∀ {R : Type u} {σ : Type u_1} [inst : CommSemiring R] {p : MvPolynomial σ R} {m : σ →₀ ℕ},
(m ∉ p.support) = (MvPolynomial.coeff m p = 0) |
TopologicalSpace.Compacts.coe_toCloseds | Mathlib.Topology.Sets.Compacts | ∀ {α : Type u_1} [inst : TopologicalSpace α] [inst_1 : T2Space α] (s : TopologicalSpace.Compacts α), ↑s.toCloseds = ↑s |
_private.Mathlib.CategoryTheory.Quotient.Preadditive.0.CategoryTheory.Quotient.Preadditive.add._simp_1 | Mathlib.CategoryTheory.Quotient.Preadditive | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] (r : HomRel C)
[CategoryTheory.HomRel.IsStableUnderPrecomp r] [CategoryTheory.HomRel.IsStableUnderPostcomp r] {X Y : C}
(f g : X ⟶ Y), CategoryTheory.HomRel.CompClosure r f g = r f g |
ULift.addLeftCancelSemigroup.eq_1 | Mathlib.Algebra.Group.ULift | ∀ {α : Type u} [inst : AddLeftCancelSemigroup α],
ULift.addLeftCancelSemigroup = Function.Injective.addLeftCancelSemigroup ⇑Equiv.ulift ⋯ ⋯ |
ModuleCat.MonModuleEquivalenceAlgebra.Algebra_of_Mon_._proof_5 | Mathlib.CategoryTheory.Monoidal.Internal.Module | ∀ {R : Type u_1} [inst : CommRing R] (A : ModuleCat R) [inst_1 : CategoryTheory.MonObj A]
(x y : ↑(CategoryTheory.MonoidalCategoryStruct.tensorUnit (ModuleCat R))),
(ModuleCat.Hom.hom CategoryTheory.MonObj.one).toFun (x + y) =
(ModuleCat.Hom.hom CategoryTheory.MonObj.one).toFun x + (ModuleCat.Hom.hom CategoryTheory.MonObj.one).toFun y |
String.Slice.Pattern.Model.matchAt?_eq_none_iff | Init.Data.String.Lemmas.Pattern.Basic | ∀ {ρ : Type} {pat : ρ} [inst : String.Slice.Pattern.Model.ForwardPatternModel pat] {s : String.Slice}
{startPos : s.Pos},
String.Slice.Pattern.Model.matchAt? pat startPos = none ↔ ¬String.Slice.Pattern.Model.MatchesAt pat startPos |
SeparatelyContinuousMul.continuous_mul_const | Mathlib.Topology.Algebra.Monoid.Defs | ∀ {M : Type u_1} {inst : TopologicalSpace M} {inst_1 : Mul M} [self : SeparatelyContinuousMul M] {a : M},
Continuous fun x => x * a |
List.reverse_replicate | Init.Data.List.Lemmas | ∀ {α : Type u_1} {n : ℕ} {a : α}, (List.replicate n a).reverse = List.replicate n a |
CategoryTheory.Monad.monadMonEquiv._proof_28 | Mathlib.CategoryTheory.Monad.EquivMon | ∀ (C : Type u_1) [inst : CategoryTheory.Category.{u_2, u_1} C],
CategoryTheory.CategoryStruct.comp
{
app := fun x =>
{
hom :=
CategoryTheory.CategoryStruct.id
((CategoryTheory.Functor.id (CategoryTheory.Mon (CategoryTheory.Functor C C))).obj x).X,
isMonHom_hom := ⋯ },
naturality := ⋯ }
{
app := fun x =>
{
hom :=
CategoryTheory.CategoryStruct.id
(((CategoryTheory.Monad.monToMonad C).comp (CategoryTheory.Monad.monadToMon C)).obj x).X,
isMonHom_hom := ⋯ },
naturality := ⋯ } =
CategoryTheory.CategoryStruct.id (CategoryTheory.Functor.id (CategoryTheory.Mon (CategoryTheory.Functor C C))) |
ConditionallyCompleteLinearOrder.compare_eq_compareOfLessAndEq | Mathlib.Order.ConditionallyCompleteLattice.Defs | ∀ {α : Type u_5} [self : ConditionallyCompleteLinearOrder α] (a b : α), compare a b = compareOfLessAndEq a b |
ProperSpace.of_isCompact_closedBall_of_le | Mathlib.Topology.MetricSpace.ProperSpace | ∀ {α : Type u} [inst : PseudoMetricSpace α] (R : ℝ),
(∀ (x : α) (r : ℝ), R ≤ r → IsCompact (Metric.closedBall x r)) → ProperSpace α |
SimpleGraph.Walk.lastDart_mem_darts._simp_1 | Mathlib.Combinatorics.SimpleGraph.Walks.Traversal | ∀ {V : Type u} {G : SimpleGraph V} {v w : V} {p : G.Walk v w} (hnil : ¬p.Nil), (p.lastDart hnil ∈ p.darts) = True |
Locale.PT.instTopologicalSpace._proof_3 | Mathlib.Topology.Order.Category.FrameAdjunction | ∀ (L : Type u_1) [inst : CompleteLattice L] (S : Set (Set (Locale.PT L))),
(∀ t ∈ S, ∃ u, {x | x u} = t) → ∃ u, {x | x u} = ⋃₀ S |
_private.Batteries.Data.RBMap.WF.0.Batteries.RBNode.Balanced.reverse.match_1_4 | Batteries.Data.RBMap.WF | ∀ {α : Type u_1},
let funType_1 := fun {c} {n} {t} x => t.reverse.Balanced c n;
∀
(motive :
(n : ℕ) →
(c : Batteries.RBColor) →
(t : Batteries.RBNode α) → (x : t.Balanced c n) → Batteries.RBNode.Balanced.below x → Prop)
(n : ℕ) (c : Batteries.RBColor) (t : Batteries.RBNode α) (x : t.Balanced c n)
(below : Batteries.RBNode.Balanced.below x),
(∀ (a : Unit), motive 0 Batteries.RBColor.black Batteries.RBNode.nil ⋯ ⋯) →
(∀ (x : Batteries.RBNode α) (c₁ : Batteries.RBColor) (n : ℕ) (y : Batteries.RBNode α) (c₂ : Batteries.RBColor)
(v : α) (hl : x.Balanced c₁ n) (hr : y.Balanced c₂ n) (ih : Batteries.RBNode.Balanced.below hl)
(a_ih : funType_1 hl) (ih_1 : Batteries.RBNode.Balanced.below hr) (a_ih_1 : funType_1 hr),
motive (n + 1) Batteries.RBColor.black (Batteries.RBNode.node Batteries.RBColor.black x v y) ⋯ ⋯) →
(∀ (n : ℕ) (x y : Batteries.RBNode α) (v : α) (hl : x.Balanced Batteries.RBColor.black n)
(hr : y.Balanced Batteries.RBColor.black n) (ih : Batteries.RBNode.Balanced.below hl) (a_ih : funType_1 hl)
(ih_1 : Batteries.RBNode.Balanced.below hr) (a_ih_1 : funType_1 hr),
motive n Batteries.RBColor.red (Batteries.RBNode.node Batteries.RBColor.red x v y) ⋯ ⋯) →
motive n c t x below |
_private.Lean.Elab.StructInst.0.Lean.Elab.Term.StructInst.mkCtorHeader.match_4 | Lean.Elab.StructInst | (motive : MProd (Array Lean.MVarId) (MProd (Array Lean.Expr) Lean.Expr) → Sort u_1) →
(r : MProd (Array Lean.MVarId) (MProd (Array Lean.Expr) Lean.Expr)) →
((instMVars : Array Lean.MVarId) →
(params : Array Lean.Expr) → (type : Lean.Expr) → motive ⟨instMVars, params, type⟩) →
motive r |
_private.Init.Data.Int.DivMod.Lemmas.0.Int.fdiv_eq_ediv._simp_1_3 | Init.Data.Int.DivMod.Lemmas | ∀ (n : ℕ), (0 ≤ Int.negSucc n) = False |
Submodule.starProjection_singleton | Mathlib.Analysis.InnerProductSpace.Projection.Basic | ∀ (𝕜 : Type u_1) {E : Type u_2} [inst : RCLike 𝕜] [inst_1 : NormedAddCommGroup E] [inst_2 : InnerProductSpace 𝕜 E]
{v : E} (w : E), (𝕜 ∙ v).starProjection w = (inner 𝕜 v w / ↑(‖v‖ ^ 2)) • v |
Finset.measurable_range_sup' | Mathlib.MeasureTheory.Order.Lattice | ∀ {α : Type u_2} {m : MeasurableSpace α} {δ : Type u_3} [inst : MeasurableSpace δ] [inst_1 : SemilatticeSup α]
[MeasurableSup₂ α] {f : ℕ → δ → α} {n : ℕ}, (∀ k ≤ n, Measurable (f k)) → Measurable ((Finset.range (n + 1)).sup' ⋯ f) |
AddSubgroup.coe_add_of_left_le_normalizer_right | Mathlib.Algebra.Group.Subgroup.Pointwise | ∀ {G : Type u_2} [inst : AddGroup G] (H N : AddSubgroup G), H ≤ N.normalizer → ↑(H ⊔ N) = ↑H + ↑N |
ContinuousMapZero.instStarRing._proof_3 | Mathlib.Topology.ContinuousMap.ContinuousMapZero | ∀ {X : Type u_1} {R : Type u_2} [inst : Zero X] [inst_1 : TopologicalSpace X] [inst_2 : TopologicalSpace R]
[inst_3 : CommSemiring R] [inst_4 : StarRing R] [inst_5 : ContinuousStar R] (x : ContinuousMapZero X R),
{ toContinuousMap := star ↑{ toContinuousMap := star ↑x, map_zero' := ⋯ }, map_zero' := ⋯ } = x |
Mathlib.Tactic.BicategoryLike.AtomIso.recOn | Mathlib.Tactic.CategoryTheory.Coherence.Datatypes | {motive : Mathlib.Tactic.BicategoryLike.AtomIso → Sort u} →
(t : Mathlib.Tactic.BicategoryLike.AtomIso) →
((e : Lean.Expr) → (src tgt : Mathlib.Tactic.BicategoryLike.Mor₁) → motive { e := e, src := src, tgt := tgt }) →
motive t |
MeasureTheory.Integrable.integral_norm_condDistrib_map | Mathlib.Probability.Kernel.CondDistrib | ∀ {α : Type u_1} {β : Type u_2} {Ω : Type u_3} {F : Type u_4} [inst : MeasurableSpace Ω] [inst_1 : StandardBorelSpace Ω]
[inst_2 : Nonempty Ω] [inst_3 : NormedAddCommGroup F] {mα : MeasurableSpace α} {μ : MeasureTheory.Measure α}
[inst_4 : MeasureTheory.IsFiniteMeasure μ] {X : α → β} {Y : α → Ω} {mβ : MeasurableSpace β} {f : β × Ω → F},
AEMeasurable Y μ →
MeasureTheory.Integrable f (MeasureTheory.Measure.map (fun a => (X a, Y a)) μ) →
MeasureTheory.Integrable (fun x => ∫ (y : Ω), ‖f (x, y)‖ ∂(ProbabilityTheory.condDistrib Y X μ) x)
(MeasureTheory.Measure.map X μ) |
CategoryTheory.SmallObject.SuccStruct.extendToSucc.objSuccIso | Mathlib.CategoryTheory.SmallObject.Iteration.ExtendToSucc | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
{J : Type u} →
[inst_1 : LinearOrder J] →
[inst_2 : SuccOrder J] →
{j : J} →
¬IsMax j →
(F : CategoryTheory.Functor (↑(Set.Iic j)) C) →
(X : C) → CategoryTheory.SmallObject.SuccStruct.extendToSucc.obj F X ⟨Order.succ j, ⋯⟩ ≅ X |
SchwartzMap.smulLeftCLM.eq_1 | Mathlib.Analysis.Distribution.SchwartzSpace.Basic | ∀ {𝕜 : Type u_2} {E : Type u_5} (F : Type u_6) [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E]
[inst_2 : NormedAddCommGroup F] [inst_3 : NormedSpace ℝ F] [inst_4 : NontriviallyNormedField 𝕜]
[inst_5 : NormedAlgebra ℝ 𝕜] [inst_6 : NormedSpace 𝕜 F] (g : E → 𝕜),
SchwartzMap.smulLeftCLM F g =
if hg : Function.HasTemperateGrowth g then SchwartzMap.bilinLeftCLM (ContinuousLinearMap.lsmul 𝕜 𝕜).flip hg else 0 |
Nat.Partrec.Code.primrec_pappAck | Mathlib.Computability.Ackermann | Primrec Nat.Partrec.Code.pappAck |
_private.Mathlib.NumberTheory.FLT.Three.0.FermatLastTheoremForThreeGen.Solution.y | Mathlib.NumberTheory.FLT.Three | {K : Type u_1} →
[inst : Field K] →
{ζ : K} → {hζ : IsPrimitiveRoot ζ 3} → FermatLastTheoremForThreeGen.Solution hζ → NumberField.RingOfIntegers K |
ProbabilityTheory.geometricPMFRealSum | Mathlib.Probability.Distributions.Geometric | ∀ {p : ℝ}, 0 < p → p ≤ 1 → HasSum (fun n => ProbabilityTheory.geometricPMFReal p n) 1 |
ContMDiff.piecewise_Iic | Mathlib.Geometry.Manifold.ContMDiff.Basic | ∀ {n : WithTop ℕ∞} {E : Type u_11} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] {H : Type u_12}
[inst_2 : TopologicalSpace H] {I : ModelWithCorners ℝ E H} {M : Type u_13} [inst_3 : TopologicalSpace M]
[inst_4 : ChartedSpace H M] {f g : ℝ → M} {s : ℝ},
ContMDiff (modelWithCornersSelf ℝ ℝ) I n f →
ContMDiff (modelWithCornersSelf ℝ ℝ) I n g →
f =ᶠ[nhds s] g → ContMDiff (modelWithCornersSelf ℝ ℝ) I n ((Set.Iic s).piecewise f g) |
CategoryTheory.Adjunction.functorialityCounit._proof_2 | Mathlib.CategoryTheory.Adjunction.Limits | ∀ {C : Type u_6} [inst : CategoryTheory.Category.{u_5, u_6} C] {D : Type u_2}
[inst_1 : CategoryTheory.Category.{u_1, u_2} D] {F : CategoryTheory.Functor C D} {G : CategoryTheory.Functor D C}
(adj : F ⊣ G) {J : Type u_4} [inst_2 : CategoryTheory.Category.{u_3, u_4} J] (K : CategoryTheory.Functor J C)
(c : CategoryTheory.Limits.Cocone (K.comp F)) (j : J),
CategoryTheory.CategoryStruct.comp
((((adj.functorialityRightAdjoint K).comp (CategoryTheory.Limits.Cocones.functoriality K F)).obj c).ι.app j)
(adj.counit.app c.pt) =
((CategoryTheory.Functor.id (CategoryTheory.Limits.Cocone (K.comp F))).obj c).ι.app j |
Submodule.map_comap_subtype | Mathlib.Algebra.Module.Submodule.Map | ∀ {R : Type u_1} {M : Type u_5} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
(p p' : Submodule R M), Submodule.map p.subtype (Submodule.comap p.subtype p') = p ⊓ p' |
LinearPMap.adjointDomainMkCLMExtend._proof_6 | Mathlib.Analysis.InnerProductSpace.LinearPMap | ∀ {𝕜 : Type u_1} [inst : RCLike 𝕜], ContinuousConstSMul 𝕜 𝕜 |
CategoryTheory.FreeBicategory.Hom₂ | Mathlib.CategoryTheory.Bicategory.Free | {B : Type u} → [inst : Quiver B] → {a b : CategoryTheory.FreeBicategory B} → (a ⟶ b) → (a ⟶ b) → Type (max u v) |
RegularExpression.char.elim | Mathlib.Computability.RegularExpressions | {α : Type u} →
{motive : RegularExpression α → Sort u_1} →
(t : RegularExpression α) → t.ctorIdx = 2 → ((a : α) → motive (RegularExpression.char a)) → motive t |
_private.Mathlib.Data.List.PeriodicityLemma.0.List.HasPeriod.factor._proof_1_6 | Mathlib.Data.List.PeriodicityLemma | ∀ {α : Type u_1} {u : List α} {p : ℕ} (j : ℕ), u.length ≤ j + u.length + p |
AlgebraicGeometry.Scheme.IdealSheafData.inclusion.congr_simp | Mathlib.AlgebraicGeometry.IdealSheaf.Subscheme | ∀ {X : AlgebraicGeometry.Scheme} {I J : X.IdealSheafData} (h : I ≤ J),
AlgebraicGeometry.Scheme.IdealSheafData.inclusion h = AlgebraicGeometry.Scheme.IdealSheafData.inclusion h |
Std.Sat.AIG.IsPrefix_push._simp_1 | Std.Sat.AIG.LawfulOperator | ∀ {α : Type} {decl : Std.Sat.AIG.Decl α} {decls : Array (Std.Sat.AIG.Decl α)},
Std.Sat.AIG.IsPrefix decls (decls.push decl) = True |
Mathlib.Tactic.BicategoryCoherence.LiftHom.mk._flat_ctor | Mathlib.Tactic.CategoryTheory.BicategoryCoherence | {B : Type u} →
[inst : CategoryTheory.Bicategory B] →
{a b : B} →
{f : a ⟶ b} →
(CategoryTheory.FreeBicategory.of.obj a ⟶ CategoryTheory.FreeBicategory.of.obj b) →
Mathlib.Tactic.BicategoryCoherence.LiftHom f |
IsRegular.mem_nonZeroDivisors | Mathlib.Algebra.GroupWithZero.NonZeroDivisors | ∀ {M₀ : Type u_2} [inst : MonoidWithZero M₀] {r : M₀}, IsRegular r → r ∈ nonZeroDivisors M₀ |
_private.Lean.Server.Completion.CompletionCollectors.0.Lean.Server.Completion.Context.casesOn | Lean.Server.Completion.CompletionCollectors | {motive : Lean.Server.Completion.Context✝ → Sort u} →
(t : Lean.Server.Completion.Context✝¹) →
((uri : Lean.Lsp.DocumentUri) →
(pos : Lean.Lsp.Position) →
(completionInfoPos : ℕ) → motive { uri := uri, pos := pos, completionInfoPos := completionInfoPos }) →
motive t |
Std.TreeMap.Raw.minKey?_insertIfNew_le_self | Std.Data.TreeMap.Raw.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.TreeMap.Raw α β cmp} [inst : Std.TransCmp cmp] (h : t.WF)
{k : α} {v : β} {kmi : α}, (t.insertIfNew k v).minKey?.get ⋯ = kmi → (cmp kmi k).isLE = true |
WithZero.instDivisionMonoid | Mathlib.Algebra.GroupWithZero.WithZero | {α : Type u_1} → [DivisionMonoid α] → DivisionMonoid (WithZero α) |
Nat.clog | Mathlib.Data.Nat.Log | ℕ → ℕ → ℕ |
SheafOfModules.instIsRightAdjointPushforward | Mathlib.Algebra.Category.ModuleCat.Sheaf.PullbackContinuous | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
{J : CategoryTheory.GrothendieckTopology C} {K : CategoryTheory.GrothendieckTopology D}
{F : CategoryTheory.Functor C D} {S : CategoryTheory.Sheaf J RingCat} {R : CategoryTheory.Sheaf K RingCat}
[inst_2 : F.IsContinuous J K] [inst_3 : F.IsContinuous J K] (φ : S ⟶ (F.sheafPushforwardContinuous RingCat J K).obj R)
[(PresheafOfModules.pushforward φ.hom).IsRightAdjoint] [CategoryTheory.HasWeakSheafify K AddCommGrpCat]
[K.WEqualsLocallyBijective AddCommGrpCat], (SheafOfModules.pushforward φ).IsRightAdjoint |
Array.idRun_ofFnM | Init.Data.Array.OfFn | ∀ {n : ℕ} {α : Type u_1} {f : Fin n → Id α}, (Array.ofFnM f).run = Array.ofFn fun i => (f i).run |
Std.ExtDHashMap.getD_union | Std.Data.ExtDHashMap.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {β : α → Type v} {m₁ m₂ : Std.ExtDHashMap α β} [inst : LawfulBEq α]
{k : α} {fallback : β k}, (m₁ ∪ m₂).getD k fallback = m₂.getD k (m₁.getD k fallback) |
Submonoid.comap_strictMono_of_surjective | 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}, Function.Surjective ⇑f → StrictMono (Submonoid.comap f) |
MeasureTheory.setLIntegral_trim_ae | Mathlib.MeasureTheory.Integral.Lebesgue.Add | ∀ {α : Type u_1} {m m0 : MeasurableSpace α} {μ : MeasureTheory.Measure α} (hm : m ≤ m0) {f : α → ENNReal},
AEMeasurable f (μ.trim hm) →
∀ {s : Set α}, MeasurableSet s → ∫⁻ (x : α) in s, f x ∂μ.trim hm = ∫⁻ (x : α) in s, f x ∂μ |
Lean.CollectLevelParams.visitExpr | Lean.Util.CollectLevelParams | Lean.Expr → Lean.CollectLevelParams.Visitor |
CategoryTheory.ShortComplex.HomologyData.ofEpiMonoFactorisation.rightHomologyData_H | Mathlib.Algebra.Homology.ShortComplex.Abelian | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Abelian C]
(S : CategoryTheory.ShortComplex C) {kf : CategoryTheory.Limits.KernelFork S.g}
{cc : CategoryTheory.Limits.CokernelCofork S.f} (hkf : CategoryTheory.Limits.IsLimit kf)
(hcc : CategoryTheory.Limits.IsColimit cc) {H : C} {π : kf.pt ⟶ H} {ι : H ⟶ cc.pt}
(fac :
CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.Fork.ι kf) (CategoryTheory.Limits.Cofork.π cc) =
CategoryTheory.CategoryStruct.comp π ι)
[inst_2 : CategoryTheory.Epi π] [inst_3 : CategoryTheory.Mono ι],
(CategoryTheory.ShortComplex.HomologyData.ofEpiMonoFactorisation.rightHomologyData S hkf hcc fac).H = H |
CategoryTheory.Pi.laxMonoidalPi._proof_4 | Mathlib.CategoryTheory.Pi.Monoidal | ∀ {I : Type u_2} {C : I → Type u_5} [inst : (i : I) → CategoryTheory.Category.{u_4, u_5} (C i)]
[inst_1 : (i : I) → CategoryTheory.MonoidalCategory (C i)] {D : I → Type u_3}
[inst_2 : (i : I) → CategoryTheory.Category.{u_1, u_3} (D i)]
[inst_3 : (i : I) → CategoryTheory.MonoidalCategory (D i)] (F : (i : I) → CategoryTheory.Functor (D i) (C i))
[inst_4 : (i : I) → (F i).LaxMonoidal] {X Y : (i : I) → D i} (X' : (i : I) → D i) (f : X ⟶ Y),
(CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCategoryStruct.whiskerLeft ((CategoryTheory.Functor.pi F).obj X')
((CategoryTheory.Functor.pi F).map f))
fun i => CategoryTheory.Functor.LaxMonoidal.μ (F i) (X' i) (Y i)) =
CategoryTheory.CategoryStruct.comp (fun i => CategoryTheory.Functor.LaxMonoidal.μ (F i) (X' i) (X i))
((CategoryTheory.Functor.pi F).map (CategoryTheory.MonoidalCategoryStruct.whiskerLeft X' f)) |
Lean.withoutModifyingEnv | Lean.MonadEnv | {m : Type → Type} → [Monad m] → [Lean.MonadEnv m] → [MonadFinally m] → {α : Type} → m α → m α |
sInf_within_of_ordConnected | Mathlib.Order.CompleteLatticeIntervals | ∀ {α : Type u_2} [inst : ConditionallyCompleteLinearOrder α] {s : Set α} [hs : s.OrdConnected] ⦃t : Set ↑s⦄,
t.Nonempty → BddBelow t → sInf (Subtype.val '' t) ∈ s |
Real.arccos_eq_pi_div_two | Mathlib.Analysis.SpecialFunctions.Trigonometric.Inverse | ∀ {x : ℝ}, Real.arccos x = Real.pi / 2 ↔ x = 0 |
_private.Mathlib.Data.Nat.ChineseRemainder.0.Nat.modEq_list_map_prod_iff._simp_1_5 | Mathlib.Data.Nat.ChineseRemainder | ∀ {a b c : Prop}, (a ∧ b → c) = (a → b → c) |
InnerProductSpace.Core.normSq.eq_1 | Mathlib.Analysis.InnerProductSpace.Defs | ∀ {𝕜 : Type u_1} {F : Type u_3} [inst : RCLike 𝕜] [inst_1 : AddCommGroup F] [inst_2 : Module 𝕜 F]
[c : PreInnerProductSpace.Core 𝕜 F] (x : F), InnerProductSpace.Core.normSq x = RCLike.re (inner 𝕜 x x) |
Bornology.isBounded_univ | Mathlib.Topology.Bornology.Basic | ∀ {α : Type u_2} [inst : Bornology α], Bornology.IsBounded Set.univ ↔ BoundedSpace α |
Std.Rxi.Iterator.instIteratorLoop.loop.eq_1 | Init.Data.Range.Polymorphic.RangeIterator | ∀ {α : Type u} [inst : Std.PRange.UpwardEnumerable α] [inst_1 : Std.PRange.LawfulUpwardEnumerable α]
{n : Type u → Type w} [inst_2 : Monad n] (γ : Type u) (Pl : α → γ → ForInStep γ → Prop) (LargeEnough : α → Prop)
(hl : ∀ (a b : α), Std.PRange.UpwardEnumerable.LE a b → LargeEnough a → LargeEnough b) (acc : γ) (next : α)
(h : LargeEnough next) (f : (out : α) → LargeEnough out → (c : γ) → n (Subtype (Pl out c))),
Std.Rxi.Iterator.instIteratorLoop.loop γ Pl LargeEnough hl acc next h f =
WellFounded.extrinsicFix₃
(InvImage (Std.IteratorLoop.rel (Std.Rxi.Iterator α) Id Pl) fun x =>
({ internalState := { next := some x.fst } }, x.snd.fst))
(fun next acc h G => do
let __do_lift ← f next h acc
match __do_lift with
| ⟨ForInStep.yield acc', h'⟩ =>
match hs : Std.PRange.succ? next with
| some next' => G next' acc' ⋯ ⋯
| none => pure acc'
| ⟨ForInStep.done acc', property⟩ => pure acc')
next acc h |
Equiv.group._proof_3 | Mathlib.Algebra.Group.TransferInstance | ∀ {α : Type u_2} {β : Type u_1} (e : α ≃ β) [inst : Group β] (x : α), e (e.symm (e x)⁻¹) = (e x)⁻¹ |
Metric.gluePremetric._proof_5 | Mathlib.Topology.MetricSpace.Gluing | ∀ {X : Type u_1} {Y : Type u_2} {Z : Type u_3} [inst : MetricSpace X] [inst_1 : MetricSpace Y] {Φ : Z → X} {Ψ : Z → Y}
(x : X ⊕ Y), Metric.glueDist Φ Ψ 0 x x = 0 |
ContinuousAddEquiv.symm_apply_eq | Mathlib.Topology.Algebra.ContinuousMonoidHom | ∀ {M : Type u_1} {N : Type u_2} [inst : TopologicalSpace M] [inst_1 : TopologicalSpace N] [inst_2 : Add M]
[inst_3 : Add N] (e : M ≃ₜ+ N) {x : N} {y : M}, e.symm x = y ↔ x = e y |
Set.IicExtend | Mathlib.Order.Interval.Set.ProjIcc | {α : Type u_1} → {β : Type u_2} → [inst : LinearOrder α] → {b : α} → (↑(Set.Iic b) → β) → α → β |
EMetric.cauchy_iff | Mathlib.Topology.EMetricSpace.Basic | ∀ {α : Type u} [inst : PseudoEMetricSpace α] {f : Filter α},
Cauchy f ↔ f ≠ ⊥ ∧ ∀ ε > 0, ∃ t ∈ f, ∀ x ∈ t, ∀ y ∈ t, edist x y < ε |
TensorAlgebra.ι_eq_zero_iff._simp_1 | Mathlib.LinearAlgebra.TensorAlgebra.Basic | ∀ (R : Type u_1) [inst : CommSemiring R] {M : Type u_2} [inst_1 : AddCommMonoid M] [inst_2 : Module R M] (x : M),
((TensorAlgebra.ι R) x = 0) = (x = 0) |
_private.Mathlib.Algebra.Group.Subsemigroup.Operations.0.Subsemigroup.prod_top._simp_1_1 | Mathlib.Algebra.Group.Subsemigroup.Operations | ∀ {M : Type u_1} {N : Type u_2} [inst : Mul M] [inst_1 : Mul N] {s : Subsemigroup M} {t : Subsemigroup N} {p : M × N},
(p ∈ s.prod t) = (p.1 ∈ s ∧ p.2 ∈ t) |
Batteries.RBNode.Any.eq_def | Batteries.Data.RBMap.Basic | ∀ {α : Type u_1} (p : α → Prop) (x : Batteries.RBNode α),
Batteries.RBNode.Any p x =
match x with
| Batteries.RBNode.nil => False
| Batteries.RBNode.node c l v r => p v ∨ Batteries.RBNode.Any p l ∨ Batteries.RBNode.Any p r |
Lean.Parser.ParserState.ctorIdx | Lean.Parser.Types | Lean.Parser.ParserState → ℕ |
Asymptotics.isBigOWith_const_one | Mathlib.Analysis.Asymptotics.Lemmas | ∀ {α : Type u_1} {E : Type u_3} (F : Type u_4) [inst : Norm E] [inst_1 : Norm F] [inst_2 : One F] [NormOneClass F]
(c : E) (l : Filter α), Asymptotics.IsBigOWith ‖c‖ l (fun _x => c) fun _x => 1 |
WithBot.noMaxOrder | Mathlib.Order.WithBot | ∀ {α : Type u_1} [inst : LT α] [NoMaxOrder α] [Nonempty α], NoMaxOrder (WithBot α) |
riemannZeta_neg_nat_eq_bernoulli' | Mathlib.NumberTheory.LSeries.HurwitzZetaValues | ∀ (k : ℕ), riemannZeta (-↑k) = -↑(bernoulli' (k + 1)) / (↑k + 1) |
Lean.Grind.Nat.le_lo | Init.Grind.Offset | ∀ (u w v k : ℕ), u ≤ w → w + k ≤ v → u + k ≤ v |
FixedPoints.minpoly.eval₂' | Mathlib.FieldTheory.Fixed | ∀ (G : Type u) [inst : Group G] (F : Type v) [inst_1 : Field F] [inst_2 : MulSemiringAction G F] [inst_3 : Fintype G]
(x : F), Polynomial.eval₂ (FixedPoints.subfield G F).subtype x (FixedPoints.minpoly G F x) = 0 |
_private.Mathlib.Tactic.DefEqAbuse.0.Lean.MessageData.VisitStep | Mathlib.Tactic.DefEqAbuse | Type u_1 → Type u_1 |
ENNReal.truncateToReal.eq_1 | Mathlib.Topology.Instances.ENNReal.Lemmas | ∀ (t x : ENNReal), t.truncateToReal x = (min t x).toReal |
CategoryTheory.groupoidOfElements._proof_4 | Mathlib.CategoryTheory.Elements | ∀ {G : Type u_2} [inst : CategoryTheory.Groupoid G] (F : CategoryTheory.Functor G (Type u_3)) {X Y : F.Elements}
(x : X ⟶ Y),
CategoryTheory.CategoryStruct.comp x ⟨CategoryTheory.Groupoid.inv ↑x, ⋯⟩ = CategoryTheory.CategoryStruct.id X |
FinBddDistLat.Hom | Mathlib.Order.Category.FinBddDistLat | FinBddDistLat → FinBddDistLat → Type u |
_private.Mathlib.Tactic.Translate.Reorder.0.Mathlib.Tactic.Translate.depForallDepth | Mathlib.Tactic.Translate.Reorder | Lean.Expr → ℕ |
CategoryTheory.Functor.leftKanExtensionUnit_leftKanExtension_map_leftKanExtensionObjIsoColimit_hom | Mathlib.CategoryTheory.Functor.KanExtension.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] (L : CategoryTheory.Functor C D) {H : Type u_3}
[inst_2 : CategoryTheory.Category.{v_3, u_3} H] (F : CategoryTheory.Functor C H)
[inst_3 : L.HasPointwiseLeftKanExtension F] (X : D) (f : CategoryTheory.CostructuredArrow L X),
CategoryTheory.CategoryStruct.comp ((L.leftKanExtensionUnit F).app f.left)
(CategoryTheory.CategoryStruct.comp ((L.leftKanExtension F).map f.hom)
(L.leftKanExtensionObjIsoColimit F X).hom) =
CategoryTheory.Limits.colimit.ι ((CategoryTheory.CostructuredArrow.proj L X).comp F) f |
Std.DTreeMap.Internal.Impl.alter._sunfold | Std.Data.DTreeMap.Internal.Operations | {α : Type u} →
{β : α → Type v} →
[inst : Ord α] →
[Std.LawfulEqOrd α] →
(k : α) →
(Option (β k) → Option (β k)) →
(t : Std.DTreeMap.Internal.Impl α β) →
t.Balanced → Std.DTreeMap.Internal.Impl.SizedBalancedTree α β (t.size - 1) (t.size + 1) |
Lean.Meta.Simp.initFn._@.Lean.Meta.Tactic.Simp.Main.3634004939._hygCtx._hyg.4 | Lean.Meta.Tactic.Simp.Main | IO (Lean.Option Bool) |
CategoryTheory.rightDistrib | Mathlib.CategoryTheory.Distributive.Monoidal | {C : Type u_1} →
[inst : CategoryTheory.Category.{v, u_1} C] →
[inst_1 : CategoryTheory.MonoidalCategory C] →
[inst_2 : CategoryTheory.Limits.HasBinaryCoproducts C] →
[CategoryTheory.IsMonoidalRightDistrib C] →
(X Y Z : C) →
CategoryTheory.MonoidalCategoryStruct.tensorObj Y X ⨿ CategoryTheory.MonoidalCategoryStruct.tensorObj Z X ≅
CategoryTheory.MonoidalCategoryStruct.tensorObj (Y ⨿ Z) X |
Set.list_sum_subset_list_sum | Mathlib.Algebra.Group.Pointwise.Set.BigOperators | ∀ {ι : Type u_1} {α : Type u_2} [inst : AddCommMonoid α] (t : List ι) (f₁ f₂ : ι → Set α),
(∀ i ∈ t, f₁ i ⊆ f₂ i) → (List.map f₁ t).sum ⊆ (List.map f₂ t).sum |
UInt64.add_comm | Init.Data.UInt.Lemmas | ∀ (a b : UInt64), a + b = b + a |
Ordinal.veblen_gamma_zero | Mathlib.SetTheory.Ordinal.Veblen | ∀ (o : Ordinal.{u_1}), Ordinal.veblen o.gamma 0 = o.gamma |
CategoryTheory.Subgroupoid.hom | Mathlib.CategoryTheory.Groupoid.Subgroupoid | {C : Type u} →
[inst : CategoryTheory.Groupoid C] → (S : CategoryTheory.Subgroupoid C) → CategoryTheory.Functor (↑S.objs) C |
_private.Init.Data.String.FindPos.0.String.Slice.posGE._unary._proof_3 | Init.Data.String.FindPos | ∀ (s : String.Slice) (offset : String.Pos.Raw) (h : offset ≤ s.rawEndPos) (this : offset < s.rawEndPos),
InvImage (fun x1 x2 => x1 < x2) (fun x => PSigma.casesOn x fun offset h => s.utf8ByteSize - offset.byteIdx)
⟨offset.inc, ⋯⟩ ⟨offset, h⟩ |
_private.Mathlib.Analysis.InnerProductSpace.PiL2.0.OrthonormalBasis.singleton._simp_1 | Mathlib.Analysis.InnerProductSpace.PiL2 | ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : RCLike 𝕜] [inst_1 : SeminormedAddCommGroup E] [inst_2 : InnerProductSpace 𝕜 E]
{ι : Type u_4} [inst_3 : DecidableEq ι] {v : ι → E},
Orthonormal 𝕜 v = ∀ (i j : ι), inner 𝕜 (v i) (v j) = if i = j then 1 else 0 |
Lean.Meta.mkSub | Lean.Meta.AppBuilder | Lean.Expr → Lean.Expr → Lean.MetaM Lean.Expr |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.