name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M |
|---|---|---|
ConcaveOn.mul_convexOn' | Mathlib.Analysis.Convex.Mul | ∀ {𝕜 : Type u_1} {E : Type u_2} {G : Type u_4} [inst : CommRing 𝕜] [inst_1 : LinearOrder 𝕜] [IsStrictOrderedRing 𝕜]
[inst_3 : CommRing E] [inst_4 : LinearOrder E] [IsStrictOrderedRing E] [inst_6 : AddCommGroup G] [inst_7 : Module 𝕜 G]
[inst_8 : Module 𝕜 E] {s : Set G} [IsOrderedModule 𝕜 E] [IsScalarTower 𝕜 E E] [SMulCommClass 𝕜 E E] {f g : G → E},
ConcaveOn 𝕜 s f →
ConvexOn 𝕜 s g →
(∀ ⦃x : G⦄, x ∈ s → f x ≤ 0) → (∀ ⦃x : G⦄, x ∈ s → 0 ≤ g x) → AntivaryOn f g s → ConcaveOn 𝕜 s (f • g) |
Std.TreeMap.Raw.compare_maxKeyD_modify_eq | Std.Data.TreeMap.Raw.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.TreeMap.Raw α β cmp} [Std.TransCmp cmp],
t.WF → ∀ {k : α} {f : β → β} {fallback : α}, cmp ((t.modify k f).maxKeyD fallback) (t.maxKeyD fallback) = Ordering.eq |
Function.isFixedPt_piMap | Mathlib.Dynamics.PeriodicPts.Defs | ∀ {ι : Type u_1} {α : ι → Type u_2} {f : (i : ι) → α i → α i} {x : (i : ι) → α i},
Function.IsFixedPt (Pi.map f) x ↔ ∀ (i : ι), Function.IsFixedPt (f i) (x i) |
Affine.Triangle.mem_circumsphere_of_two_zsmul_oangle_eq | Mathlib.Geometry.Euclidean.Angle.Sphere | ∀ {V : Type u_1} {P : Type u_2} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V] [inst_2 : MetricSpace P]
[inst_3 : NormedAddTorsor V P] [hd2 : Fact (Module.finrank ℝ V = 2)] [inst_4 : Module.Oriented ℝ V (Fin 2)]
{t : Affine.Triangle ℝ P} {p : P} {i₁ i₂ i₃ : Fin 3},
i₁ ≠ i₂ →
i₁ ≠ i₃ →
i₂ ≠ i₃ →
2 • EuclideanGeometry.oangle (t.points i₁) p (t.points i₃) =
2 • EuclideanGeometry.oangle (t.points i₁) (t.points i₂) (t.points i₃) →
p ∈ Affine.Simplex.circumsphere t |
Lean.Server.FileWorker.Insertion.mk | Lean.Server.CodeActions.UnknownIdentifier | Lean.Name → Lean.Lsp.TextEdit → Lean.Server.FileWorker.Insertion |
_private.Mathlib.Order.SuccPred.Basic.0.WithBot.succ_unbot.match_1_1 | Mathlib.Order.SuccPred.Basic | ∀ {α : Type u_1} (motive : (x : WithBot α) → x ≠ ⊥ → Prop) (x : WithBot α) (x_1 : x ≠ ⊥),
(∀ (ha : ⊥ ≠ ⊥), motive none ha) → (∀ (a : α) (x : ↑a ≠ ⊥), motive (some a) x) → motive x x_1 |
Lean.Lsp.TextDocumentPositionParams._sizeOf_inst | Lean.Data.Lsp.Basic | SizeOf Lean.Lsp.TextDocumentPositionParams |
Vector.range'_eq_mk_range'._proof_1 | Init.Data.Vector.Range | ∀ {start size step : ℕ}, (Array.range' start size step).size = size |
CategoryTheory.MorphismProperty.CodescendsAlong.mk._flat_ctor | Mathlib.CategoryTheory.MorphismProperty.Descent | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {P Q : CategoryTheory.MorphismProperty C},
(∀ {Z X Y A : C} {f : Z ⟶ X} {g : Z ⟶ Y} {inl : X ⟶ A} {inr : Y ⟶ A},
CategoryTheory.IsPushout f g inl inr → Q f → P inl → P g) →
P.CodescendsAlong Q |
Cubic.discr._proof_3 | Mathlib.Algebra.CubicDiscriminant | (17 + 1).AtLeastTwo |
FirstOrder.Language.presburger.instSMulNatTerm | Mathlib.ModelTheory.Arithmetic.Presburger.Basic | {α : Type u_1} → SMul ℕ (FirstOrder.Language.presburger.Term α) |
instLEOption | Init.Data.Option.Basic | {α : Type u_1} → [LE α] → LE (Option α) |
MulEquiv.rec | Mathlib.Algebra.Group.Equiv.Defs | {M : Type u_9} →
{N : Type u_10} →
[inst : Mul M] →
[inst_1 : Mul N] →
{motive : M ≃* N → Sort u} →
((toEquiv : M ≃ N) →
(map_mul' : ∀ (x y : M), toEquiv.toFun (x * y) = toEquiv.toFun x * toEquiv.toFun y) →
motive { toEquiv := toEquiv, map_mul' := map_mul' }) →
(t : M ≃* N) → motive t |
AddSubgroup.mem_goursatSnd._simp_1 | Mathlib.GroupTheory.Goursat | ∀ {G : Type u_1} {H : Type u_2} [inst : AddGroup G] [inst_1 : AddGroup H] {I : AddSubgroup (G × H)} {h : H},
(h ∈ I.goursatSnd) = ((0, h) ∈ I) |
_private.Mathlib.CategoryTheory.WithTerminal.Basic.0.CategoryTheory.WithInitial.id.match_1.eq_2 | Mathlib.CategoryTheory.WithTerminal.Basic | ∀ {C : Type u_1} (motive : CategoryTheory.WithInitial C → Sort u_2)
(h_1 : (a : C) → motive (CategoryTheory.WithInitial.of a)) (h_2 : Unit → motive CategoryTheory.WithInitial.star),
(match CategoryTheory.WithInitial.star with
| CategoryTheory.WithInitial.of a => h_1 a
| CategoryTheory.WithInitial.star => h_2 ()) =
h_2 () |
_private.Mathlib.Data.Set.Subsingleton.0.Set.not_subsingleton_iff._simp_1_3 | Mathlib.Data.Set.Subsingleton | ∀ {α : Sort u_1} {p : α → Prop}, (¬∀ (x : α), p x) = ∃ x, ¬p x |
CommRingCat.equalizer_ι_isLocalHom | Mathlib.Algebra.Category.Ring.Constructions | ∀ (F : CategoryTheory.Functor CategoryTheory.Limits.WalkingParallelPair CommRingCat),
IsLocalHom (CommRingCat.Hom.hom (CategoryTheory.Limits.limit.π F CategoryTheory.Limits.WalkingParallelPair.zero)) |
FirstOrder.Language.BoundedFormula.realize_rel₁ | Mathlib.ModelTheory.Semantics | ∀ {L : FirstOrder.Language} {M : Type w} [inst : L.Structure M] {α : Type u'} {l : ℕ} {v : α → M} {xs : Fin l → M}
{R : L.Relations 1} {t : L.Term (α ⊕ Fin l)},
(R.boundedFormula₁ t).Realize v xs ↔
FirstOrder.Language.Structure.RelMap R ![FirstOrder.Language.Term.realize (Sum.elim v xs) t] |
Valuation.IsEquiv.valueGroup₀Fun._proof_1 | Mathlib.RingTheory.Valuation.Basic | ∀ {R : Type u_1} {Γ₀ : Type u_2} [inst : LinearOrderedCommGroupWithZero Γ₀] [inst_1 : Ring R],
MonoidWithZeroHomClass (Valuation R Γ₀) R Γ₀ |
ModelWithCorners.continuous_invFun._autoParam | Mathlib.Geometry.Manifold.IsManifold.Basic | Lean.Syntax |
CategoryTheory.MorphismProperty.transfiniteCompositions_le | Mathlib.CategoryTheory.MorphismProperty.TransfiniteComposition | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (W : CategoryTheory.MorphismProperty C)
[W.IsStableUnderTransfiniteComposition], CategoryTheory.MorphismProperty.transfiniteCompositions.{w, v, u} W ≤ W |
ContinuousAlternatingMap.ext | Mathlib.Topology.Algebra.Module.Alternating.Basic | ∀ {R : Type u_1} {M : Type u_2} {N : Type u_4} {ι : Type u_6} [inst : Semiring R] [inst_1 : AddCommMonoid M]
[inst_2 : Module R M] [inst_3 : TopologicalSpace M] [inst_4 : AddCommMonoid N] [inst_5 : Module R N]
[inst_6 : TopologicalSpace N] {f g : M [⋀^ι]→L[R] N}, (∀ (x : ι → M), f x = g x) → f = g |
_private.Std.Data.ExtDTreeMap.Lemmas.0.Std.ExtDTreeMap.Const.insertManyIfNewUnit_list_eq_empty_iff._simp_1_2 | Std.Data.ExtDTreeMap.Lemmas | ∀ {α : Type u_1} {l : List α}, (l.isEmpty = true) = (l = []) |
Finset.affineCombinationLineMapWeights_apply_left | Mathlib.LinearAlgebra.AffineSpace.Combination | ∀ {k : Type u_1} [inst : Ring k] {ι : Type u_4} [inst_1 : DecidableEq ι] {i j : ι},
i ≠ j → ∀ (c : k), Finset.affineCombinationLineMapWeights i j c i = 1 - c |
FirstOrder.Language.LHom.id_comp | Mathlib.ModelTheory.LanguageMap | ∀ {L : FirstOrder.Language} {L' : FirstOrder.Language} (F : L →ᴸ L'), (FirstOrder.Language.LHom.id L').comp F = F |
liminf_eq_top._simp_1 | Mathlib.Topology.Order.LiminfLimsup | ∀ {α : Type u_2} {β : Type u_3} [inst : CompleteLinearOrder α] [inst_1 : TopologicalSpace α] [FirstCountableTopology α]
[OrderTopology α] {f : Filter β} [CountableInterFilter f] {u : β → α}, (Filter.liminf u f = ⊤) = (u =ᶠ[f] ⊤) |
toIcoMod_add_nsmul' | Mathlib.Algebra.Order.ToIntervalMod | ∀ {α : Type u_1} [inst : AddCommGroup α] [inst_1 : LinearOrder α] [inst_2 : IsOrderedAddMonoid α] [hα : Archimedean α]
{p : α} (hp : 0 < p) (a b : α) (m : ℕ), toIcoMod hp (a + m • p) b = toIcoMod hp a b + m • p |
_private.Init.Data.Int.Linear.0.Int.Linear.le_of_le'._proof_1_3 | Init.Data.Int.Linear | ∀ (ctx : Int.Linear.Context) (p₁ : Int.Linear.Poly) (a₂ : ℤ) (x₂ : Int.Linear.Var) (p₂ : Int.Linear.Poly) (k : ℤ),
Int.Linear.Poly.denote ctx p₂ ≤ k - a₂ * Int.Linear.Var.denote ctx x₂ →
¬Int.Linear.Poly.denote ctx p₂ + a₂ * Int.Linear.Var.denote ctx x₂ ≤ k → False |
exp_neg_mul_sq_isLittleO_exp_neg | Mathlib.Analysis.SpecialFunctions.Gaussian.GaussianIntegral | ∀ {b : ℝ}, 0 < b → (fun x => Real.exp (-b * x ^ 2)) =o[Filter.atTop] fun x => Real.exp (-x) |
Set.Ioc.instMul._proof_1 | Mathlib.Algebra.Order.Interval.Set.Instances | ∀ {R : Type u_1} [inst : Semiring R] [inst_1 : PartialOrder R] [IsStrictOrderedRing R] (p q : ↑(Set.Ioc 0 1)),
0 < ↑p * ↑q ∧ ↑p * ↑q ≤ 1 |
Lean.Compiler.LCNF.Probe.filterByFunDecl | Lean.Compiler.LCNF.Probing | (pu : Lean.Compiler.LCNF.Purity) →
(Lean.Compiler.LCNF.FunDecl pu → Lean.Compiler.LCNF.CompilerM Bool) →
Lean.Compiler.LCNF.Probe (Lean.Compiler.LCNF.Decl pu) (Lean.Compiler.LCNF.Decl pu) |
Algebra.Generators.CotangentSpace.compEquiv.eq_1 | Mathlib.RingTheory.Kaehler.JacobiZariski | ∀ {R : Type u₁} {S : Type u₂} [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S] {T : Type u₃}
[inst_3 : CommRing T] [inst_4 : Algebra R T] [inst_5 : Algebra S T] [inst_6 : IsScalarTower R S T] {ι : Type w₁}
{σ : Type w₂} (Q : Algebra.Generators S T ι) (P : Algebra.Generators R S σ),
Algebra.Generators.CotangentSpace.compEquiv Q P =
(Q.comp P).cotangentSpaceBasis.repr.trans
(Q.cotangentSpaceBasis.prod (Module.Basis.baseChange T P.cotangentSpaceBasis)).repr.symm |
_aux_Mathlib_Data_Complex_Basic___macroRules_termℂ_1 | Mathlib.Data.Complex.Basic | Lean.Macro |
QuotSMulTop.map_exact | Mathlib.RingTheory.QuotSMulTop | ∀ {R : Type u_2} [inst : CommRing R] (r : R) {M : Type u_1} {M' : Type u_3} {M'' : Type u_4} [inst_1 : AddCommGroup M]
[inst_2 : Module R M] [inst_3 : AddCommGroup M'] [inst_4 : Module R M'] [inst_5 : AddCommGroup M'']
[inst_6 : Module R M''] {f : M →ₗ[R] M'} {g : M' →ₗ[R] M''},
Function.Exact ⇑f ⇑g → Function.Surjective ⇑g → Function.Exact ⇑((QuotSMulTop.map r) f) ⇑((QuotSMulTop.map r) g) |
Sum.LiftRel.isRight_left | Mathlib.Data.Sum.Basic | ∀ {α : Type u} {β : Type v} {γ : Type u_1} {δ : Type u_2} {r : α → γ → Prop} {s : β → δ → Prop} {x : α ⊕ β} {d : δ},
Sum.LiftRel r s x (Sum.inr d) → x.isRight = true |
Polynomial.leadingCoeff_divByMonic_of_monic | Mathlib.Algebra.Polynomial.Div | ∀ {R : Type u} [inst : CommRing R] {p q : Polynomial R},
q.Monic → q.degree ≤ p.degree → (p /ₘ q).leadingCoeff = p.leadingCoeff |
Module.Dual.eq_of_ker_eq_of_apply_eq | Mathlib.LinearAlgebra.Dual.Lemmas | ∀ {K : Type u_1} {V₁ : Type u_2} [inst : DivisionRing K] [inst_1 : AddCommGroup V₁] [inst_2 : Module K V₁]
[FiniteDimensional K V₁] {f g : Module.Dual K V₁} (x : V₁),
LinearMap.ker f = LinearMap.ker g → f x = g x → f x ≠ 0 → f = g |
UniformSpace.hasBasis_nhds_prod | Mathlib.Topology.UniformSpace.Basic | ∀ {α : Type ua} [inst : UniformSpace α] (x y : α),
(nhds (x, y)).HasBasis (fun s => s ∈ uniformity α ∧ SetRel.IsSymm s) fun s =>
UniformSpace.ball x s ×ˢ UniformSpace.ball y s |
CategoryTheory.FreeMonoidalCategory.NormalMonoidalObject.tensor.elim | Mathlib.CategoryTheory.Monoidal.Free.Coherence | {C : Type u} →
{motive : CategoryTheory.FreeMonoidalCategory.NormalMonoidalObject C → Sort u_1} →
(t : CategoryTheory.FreeMonoidalCategory.NormalMonoidalObject C) →
t.ctorIdx = 1 →
((a : CategoryTheory.FreeMonoidalCategory.NormalMonoidalObject C) → (a_1 : C) → motive (a.tensor a_1)) →
motive t |
Fin.getElem?_fin | Init.GetElem | ∀ {Cont : Type u_1} {Elem : Type u_2} {Dom : Cont → ℕ → Prop} {n : ℕ} [h : GetElem? Cont ℕ Elem Dom] (a : Cont)
(i : Fin n), a[i]? = a[↑i]? |
OrderIso.image_eq_preimage_symm | Mathlib.Order.Hom.Set | ∀ {α : Type u_1} {β : Type u_2} [inst : LE α] [inst_1 : LE β] (e : α ≃o β) (s : Set α), ⇑e '' s = ⇑e.symm ⁻¹' s |
Set.FiniteExhaustion.mk.injEq | Mathlib.Data.Set.FiniteExhaustion | ∀ {α : Type u_1} {s : Set α} (toFun : ℕ → Set α) (finite' : ∀ (n : ℕ), Finite ↑(toFun n))
(subset_succ' : ∀ (n : ℕ), toFun n ⊆ toFun (n + 1)) (iUnion_eq' : ⋃ n, toFun n = s) (toFun_1 : ℕ → Set α)
(finite'_1 : ∀ (n : ℕ), Finite ↑(toFun_1 n)) (subset_succ'_1 : ∀ (n : ℕ), toFun_1 n ⊆ toFun_1 (n + 1))
(iUnion_eq'_1 : ⋃ n, toFun_1 n = s),
({ toFun := toFun, finite' := finite', subset_succ' := subset_succ', iUnion_eq' := iUnion_eq' } =
{ toFun := toFun_1, finite' := finite'_1, subset_succ' := subset_succ'_1, iUnion_eq' := iUnion_eq'_1 }) =
(toFun = toFun_1) |
_private.Mathlib.Util.Export.0.Lean.Export.exportDef.defn._unsafe_rec | Mathlib.Util.Export | String → Lean.Name → Lean.Expr → Lean.Expr → List Lean.Name → Lean.ExportM Unit |
_private.Mathlib.Combinatorics.SetFamily.Shadow.0.Finset.upShadow_compls._simp_1_1 | Mathlib.Combinatorics.SetFamily.Shadow | ∀ {α : Type u_1} [inst : DecidableEq α] {𝒜 : Finset (Finset α)} {t : Finset α},
(t ∈ 𝒜.shadow) = ∃ s ∈ 𝒜, ∃ a ∈ s, s.erase a = t |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.contains_maxKeyD._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) |
OrderHom.le_prevFixed | Mathlib.Order.FixedPoints | ∀ {α : Type u} [inst : CompleteLattice α] (f : α →o α) {x : α} (hx : f x ≤ x) {y : ↑(Function.fixedPoints ⇑f)},
↑y ≤ x → y ≤ f.prevFixed x hx |
Aesop.UnorderedArraySet.singleton | Aesop.Util.UnorderedArraySet | {α : Type u_1} → [inst : BEq α] → α → Aesop.UnorderedArraySet α |
AddGroup.fintypeOfDomOfCoker._proof_1 | Mathlib.GroupTheory.QuotientGroup.Finite | ∀ {F : Type u_2} {G : Type u_1} [inst : AddGroup F] [inst_1 : AddGroup G] (f : F →+ G) [inst_2 : f.range.Normal]
(x : G), ↑x = 0 → x ∈ f.range |
CategoryTheory.Under.liftCocone._proof_4 | Mathlib.CategoryTheory.Comma.Over.Basic | ∀ {T : Type u_4} [inst : CategoryTheory.Category.{u_3, u_4} T] {J : Type u_2}
[inst_1 : CategoryTheory.Category.{u_1, u_2} J] (D : CategoryTheory.Functor J T) {X : T}
(s : (CategoryTheory.Functor.const J).obj X ⟶ D) (c : CategoryTheory.Limits.Cocone D) (p : X ⟶ c.pt)
(hp : ∀ (j : J), CategoryTheory.CategoryStruct.comp (s.app j) (c.ι.app j) = p) ⦃X_1 Y : J⦄ (f : X_1 ⟶ Y),
CategoryTheory.CategoryStruct.comp ((CategoryTheory.Under.lift D s).map f)
(CategoryTheory.Under.homMk (c.ι.app Y) ⋯) =
CategoryTheory.CategoryStruct.comp (CategoryTheory.Under.homMk (c.ι.app X_1) ⋯)
(((CategoryTheory.Functor.const J).obj (CategoryTheory.Under.mk p)).map f) |
Finsupp.toAList_lookupFinsupp | Mathlib.Data.Finsupp.AList | ∀ {α : Type u_1} {M : Type u_2} [inst : Zero M] (f : α →₀ M), f.toAList.lookupFinsupp = f |
FirstOrder.Language.FGEquiv.symm | Mathlib.ModelTheory.PartialEquiv | {L : FirstOrder.Language} →
{M : Type w} → {N : Type w'} → [inst : L.Structure M] → [inst_1 : L.Structure N] → L.FGEquiv M N → L.FGEquiv N M |
HurwitzZeta.hasSum_expZeta_of_one_lt_re | Mathlib.NumberTheory.LSeries.HurwitzZeta | ∀ (a : ℝ) {s : ℂ},
1 < s.re → HasSum (fun n => Complex.exp (2 * ↑Real.pi * Complex.I * ↑a * ↑n) / ↑n ^ s) (HurwitzZeta.expZeta (↑a) s) |
LinearEquiv.restrictScalars._proof_3 | Mathlib.Algebra.Module.Equiv.Basic | ∀ {S : Type u_3} {M : Type u_1} {M₂ : Type u_2} [inst : Semiring S] [inst_1 : AddCommMonoid M]
[inst_2 : AddCommMonoid M₂] [inst_3 : Module S M] [inst_4 : Module S M₂] (f : M ≃ₗ[S] M₂),
Function.LeftInverse f.invFun (↑f).toFun |
LinearMap.IsPerfectCompl.left_top_iff | Mathlib.LinearAlgebra.PerfectPairing.Basic | ∀ {R : Type u_1} {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 : M →ₗ[R] N →ₗ[R] R} [inst_5 : p.IsPerfPair] {V : Submodule R N},
p.IsPerfectCompl ⊤ V ↔ V = ⊤ |
Std.DHashMap.Internal.Raw₀.diff | Std.Data.DHashMap.Internal.Defs | {α : Type u} →
{β : α → Type v} →
[BEq α] →
[Hashable α] → Std.DHashMap.Internal.Raw₀ α β → Std.DHashMap.Internal.Raw₀ α β → Std.DHashMap.Internal.Raw₀ α β |
PseudoMetricSpace.induced._proof_3 | Mathlib.Topology.MetricSpace.Pseudo.Constructions | ∀ {α : Type u_2} {β : Type u_1} (f : α → β) (m : PseudoMetricSpace β) (x x_1 x_2 : α),
dist (f x) (f x_2) ≤ dist (f x) (f x_1) + dist (f x_1) (f x_2) |
CategoryTheory.Functor.PreservesLeftHomologyOf.congr_simp | Mathlib.Algebra.Homology.ShortComplex.PreservesHomology | ∀ {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] [inst_2 : CategoryTheory.Limits.HasZeroMorphisms C]
[inst_3 : CategoryTheory.Limits.HasZeroMorphisms D] (F F_1 : CategoryTheory.Functor C D) (e_F : F = F_1)
[inst_4 : F.PreservesZeroMorphisms] (S S_1 : CategoryTheory.ShortComplex C),
S = S_1 → F.PreservesLeftHomologyOf S = F_1.PreservesLeftHomologyOf S_1 |
Lean.Server.RefInfo.noConfusion | Lean.Server.References | {P : Sort u} → {t t' : Lean.Server.RefInfo} → t = t' → Lean.Server.RefInfo.noConfusionType P t t' |
Lean.Meta.Grind.Arith.Cutsat.LeCnstr.pp | Lean.Meta.Tactic.Grind.Arith.Cutsat.Util | Lean.Meta.Grind.Arith.Cutsat.LeCnstr → Lean.Meta.Grind.GoalM Lean.MessageData |
Std.Sat.AIG.Fanin.invert_flip | Std.Sat.AIG.Basic | ∀ {v : Bool} (f : Std.Sat.AIG.Fanin), (decide ((f.flip v).invert = f.invert) ^^ v) = true |
Lean.Data.AC.Expr.brecOn | Init.Data.AC | {motive : Lean.Data.AC.Expr → Sort u} →
(t : Lean.Data.AC.Expr) → ((t : Lean.Data.AC.Expr) → Lean.Data.AC.Expr.below t → motive t) → motive t |
_private.Init.Data.Subtype.Order.0.Subtype.instLawfulOrderLT._simp_1 | Init.Data.Subtype.Order | ∀ {α : Type u} {inst : LT α} {inst_1 : LE α} [self : Std.LawfulOrderLT α] (a b : α), (a < b) = (a ≤ b ∧ ¬b ≤ a) |
Real.strictMonoOn_rpow_Ici_of_exponent_pos | Mathlib.Analysis.SpecialFunctions.Pow.Real | ∀ {r : ℝ}, 0 < r → StrictMonoOn (fun x => x ^ r) (Set.Ici 0) |
NonUnitalSubsemiringClass.subtype_injective | Mathlib.RingTheory.NonUnitalSubsemiring.Defs | ∀ {R : Type u} {S : Type v} [inst : NonUnitalNonAssocSemiring R] [inst_1 : SetLike S R]
[inst_2 : NonUnitalSubsemiringClass S R] (s : S), Function.Injective ⇑(NonUnitalSubsemiringClass.subtype s) |
AlgebraicGeometry.Scheme.Cover.sigma | Mathlib.AlgebraicGeometry.Cover.Sigma | {P : CategoryTheory.MorphismProperty AlgebraicGeometry.Scheme} →
{S : AlgebraicGeometry.Scheme} →
[AlgebraicGeometry.IsZariskiLocalAtSource P] →
[UnivLE.{v, u}] →
AlgebraicGeometry.Scheme.Cover (AlgebraicGeometry.Scheme.precoverage P) S →
AlgebraicGeometry.Scheme.Cover (AlgebraicGeometry.Scheme.precoverage P) S |
Lean.Elab.MacroStackElem.before | Lean.Elab.Util | Lean.Elab.MacroStackElem → Lean.Syntax |
Lean.Lsp.InlayHintClientCapabilities.resolveSupport?._default | Lean.Data.Lsp.LanguageFeatures | Option Lean.Lsp.ResolveSupport |
CategoryTheory.Functor.HomObj.mk.inj | Mathlib.CategoryTheory.Functor.FunctorHom | ∀ {C : Type u} {inst : CategoryTheory.Category.{v, u} C} {D : Type u'} {inst_1 : CategoryTheory.Category.{v', u'} D}
{F G : CategoryTheory.Functor C D} {A : CategoryTheory.Functor C (Type w)}
{app : (c : C) → A.obj c → (F.obj c ⟶ G.obj c)}
{naturality :
autoParam
(∀ {c d : C} (f : c ⟶ d) (a : A.obj c),
CategoryTheory.CategoryStruct.comp (F.map f) (app d (A.map f a)) =
CategoryTheory.CategoryStruct.comp (app c a) (G.map f))
CategoryTheory.Functor.HomObj.naturality._autoParam}
{app_1 : (c : C) → A.obj c → (F.obj c ⟶ G.obj c)}
{naturality_1 :
autoParam
(∀ {c d : C} (f : c ⟶ d) (a : A.obj c),
CategoryTheory.CategoryStruct.comp (F.map f) (app_1 d (A.map f a)) =
CategoryTheory.CategoryStruct.comp (app_1 c a) (G.map f))
CategoryTheory.Functor.HomObj.naturality._autoParam},
{ app := app, naturality := naturality } = { app := app_1, naturality := naturality_1 } → app = app_1 |
_private.Mathlib.AlgebraicGeometry.ColimitsOver.0.AlgebraicGeometry.Scheme.Cover.ColimitGluingData.transitionMap_comp._simp_1_1 | Mathlib.AlgebraicGeometry.ColimitsOver | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v_1, u₁} C] {D : Type u₂}
[inst_1 : CategoryTheory.Category.{v_2, u₂} D] (F : CategoryTheory.Functor C D) {X Y Z : C} (f : X ⟶ Y) (g : Y ⟶ Z)
{W : D} (h : F.obj Z ⟶ W),
CategoryTheory.CategoryStruct.comp (F.map f) (CategoryTheory.CategoryStruct.comp (F.map g) h) =
CategoryTheory.CategoryStruct.comp (F.map (CategoryTheory.CategoryStruct.comp f g)) h |
Std.ExtTreeMap.getD_map_of_getKey?_eq_some | Std.Data.ExtTreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {γ : Type w} {cmp : α → α → Ordering} {t : Std.ExtTreeMap α β cmp} [inst : Std.TransCmp cmp]
[Inhabited γ] {f : α → β → γ} {k k' : α} {fallback : γ},
t.getKey? k = some k' → (Std.ExtTreeMap.map f t).getD k fallback = (Option.map (f k') t[k]?).getD fallback |
PresheafOfModules.Sheafify.zero_smul | Mathlib.Algebra.Category.ModuleCat.Presheaf.Sheafify | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {J : CategoryTheory.GrothendieckTopology C}
{R₀ : CategoryTheory.Functor Cᵒᵖ RingCat} {R : CategoryTheory.Sheaf J RingCat} (α : R₀ ⟶ R.obj)
[inst_1 : CategoryTheory.Presheaf.IsLocallyInjective J α] [inst_2 : CategoryTheory.Presheaf.IsLocallySurjective J α]
{M₀ : PresheafOfModules R₀} {A : CategoryTheory.Sheaf J AddCommGrpCat} (φ : M₀.presheaf ⟶ A.obj)
[inst_3 : CategoryTheory.Presheaf.IsLocallyInjective J φ] [inst_4 : CategoryTheory.Presheaf.IsLocallySurjective J φ]
{X : Cᵒᵖ} (m : ↑(A.obj.obj X)), PresheafOfModules.Sheafify.smul α φ 0 m = 0 |
NumberField.mixedEmbedding.negAt_symm | Mathlib.NumberTheory.NumberField.CanonicalEmbedding.Basic | ∀ {K : Type u_1} [inst : Field K] {s : Set { w // w.IsReal }},
(NumberField.mixedEmbedding.negAt s).symm = NumberField.mixedEmbedding.negAt s |
Submodule.starProjection_orthogonal' | Mathlib.Analysis.InnerProductSpace.Projection.Basic | ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : RCLike 𝕜] [inst_1 : NormedAddCommGroup E] [inst_2 : InnerProductSpace 𝕜 E]
(U : Submodule 𝕜 E) [inst_3 : U.HasOrthogonalProjection], Uᗮ.starProjection = 1 - U.starProjection |
List.map_append_flatMap_perm | Mathlib.Data.List.Perm.Basic | ∀ {α : Type u_1} {β : Type u_2} (l : List α) (f : α → β) (g : α → List β),
(List.map f l ++ List.flatMap g l).Perm (List.flatMap (fun x => f x :: g x) l) |
MeasureTheory.SimpleFunc.instInf | Mathlib.MeasureTheory.Function.SimpleFunc | {α : Type u_1} → {β : Type u_2} → [inst : MeasurableSpace α] → [Min β] → Min (MeasureTheory.SimpleFunc α β) |
Lean.IR.IRType.brecOn.go | Lean.Compiler.IR.Basic | {motive_1 : Lean.IR.IRType → Sort u} →
{motive_2 : Array Lean.IR.IRType → Sort u} →
{motive_3 : List Lean.IR.IRType → Sort u} →
(t : Lean.IR.IRType) →
((t : Lean.IR.IRType) → t.below → motive_1 t) →
((t : Array Lean.IR.IRType) → Lean.IR.IRType.below_1 t → motive_2 t) →
((t : List Lean.IR.IRType) → Lean.IR.IRType.below_2 t → motive_3 t) → motive_1 t ×' t.below |
CategoryTheory.instMonoidalCategoryHom._proof_6 | Mathlib.CategoryTheory.Bicategory.End | ∀ {C : Type u_2} [inst : CategoryTheory.Bicategory C] (X : C) (X_1 Y : X ⟶ X),
CategoryTheory.Bicategory.whiskerLeft X_1 (CategoryTheory.CategoryStruct.id Y) =
CategoryTheory.CategoryStruct.id (CategoryTheory.CategoryStruct.comp X_1 Y) |
Lean.Elab.Command.initFn._@.Lean.Elab.MutualInductive.3413988523._hygCtx._hyg.2 | Lean.Elab.MutualInductive | IO (Lean.KeyedDeclsAttribute Lean.Elab.Command.InductiveElabDescr) |
CategoryTheory.Functor.Fiber.fiberInclusion_mk | Mathlib.CategoryTheory.FiberedCategory.Fiber | ∀ {𝒮 : Type u₁} {𝒳 : Type u₂} [inst : CategoryTheory.Category.{v₁, u₁} 𝒮] [inst_1 : CategoryTheory.Category.{v₂, u₂} 𝒳]
{p : CategoryTheory.Functor 𝒳 𝒮} {S : 𝒮} {a : 𝒳} (ha : p.obj a = S),
CategoryTheory.Functor.Fiber.fiberInclusion.obj (CategoryTheory.Functor.Fiber.mk ha) = a |
Lean.CollectMVars.State._sizeOf_1 | Lean.Util.CollectMVars | Lean.CollectMVars.State → ℕ |
AlgebraicGeometry.Scheme.IdealSheafData.subschemeCover._proof_2 | Mathlib.AlgebraicGeometry.IdealSheaf.Subscheme | ∀ {X : AlgebraicGeometry.Scheme} (I : X.IdealSheafData) (j : ↑X.affineOpens),
AlgebraicGeometry.IsOpenImmersion
(CategoryTheory.CategoryStruct.comp ((AlgebraicGeometry.Scheme.IdealSheafData.glueData✝ I).ι j)
(AlgebraicGeometry.Scheme.IdealSheafData.subschemeIso✝ I).inv) |
CompactlyCoherentSpace | Mathlib.Topology.Compactness.CompactlyCoherentSpace | (X : Type u_1) → [TopologicalSpace X] → Prop |
LinearMap.mapMatrixModule_comp_apply | Mathlib.LinearAlgebra.Matrix.Module | ∀ {ι : Type u_1} {R : Type u_2} {M : Type u_3} {N : Type u_4} {P : Type u_5} [inst : Ring R] [inst_1 : Fintype ι]
[inst_2 : DecidableEq ι] [inst_3 : AddCommGroup M] [inst_4 : Module R M] [inst_5 : AddCommGroup N]
[inst_6 : Module R N] [inst_7 : AddCommGroup P] [inst_8 : Module R P] (f : M →ₗ[R] N) (g : N →ₗ[R] P) (v : ι → M),
(LinearMap.mapMatrixModule ι (g ∘ₗ f)) v = (LinearMap.mapMatrixModule ι g) ((LinearMap.mapMatrixModule ι f) v) |
DoubleCentralizer.mk.noConfusion | Mathlib.Analysis.CStarAlgebra.Multiplier | {𝕜 : Type u} →
{A : Type v} →
{inst : NontriviallyNormedField 𝕜} →
{inst_1 : NonUnitalNormedRing A} →
{inst_2 : NormedSpace 𝕜 A} →
{inst_3 : SMulCommClass 𝕜 A A} →
{inst_4 : IsScalarTower 𝕜 A A} →
{P : Sort u_1} →
{toProd : (A →L[𝕜] A) × (A →L[𝕜] A)} →
{central : ∀ (x y : A), toProd.2 x * y = x * toProd.1 y} →
{toProd' : (A →L[𝕜] A) × (A →L[𝕜] A)} →
{central' : ∀ (x y : A), toProd'.2 x * y = x * toProd'.1 y} →
{ toProd := toProd, central := central } = { toProd := toProd', central := central' } →
(toProd ≍ toProd' → P) → P |
SeparationQuotient.instNonUnitalRing._proof_2 | Mathlib.Topology.Algebra.SeparationQuotient.Basic | ∀ {R : Type u_1} [inst : TopologicalSpace R] [inst_1 : NonUnitalRing R] [IsTopologicalRing R], ContinuousMul R |
CategoryTheory.ComposableArrows.isIso_iff₂ | Mathlib.CategoryTheory.ComposableArrows.Basic | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {F G : CategoryTheory.ComposableArrows C 2} (f : F ⟶ G),
CategoryTheory.IsIso f ↔
CategoryTheory.IsIso (f.app 0) ∧ CategoryTheory.IsIso (f.app 1) ∧ CategoryTheory.IsIso (f.app 2) |
ProbabilityTheory.IsGaussianProcess | Mathlib.Probability.Distributions.Gaussian.IsGaussianProcess.Def | {Ω : Type u_1} →
{E : Type u_2} →
{T : Type u_3} →
{mΩ : MeasurableSpace Ω} →
[MeasurableSpace E] →
[TopologicalSpace E] →
[inst : AddCommMonoid E] →
[Module ℝ E] →
(T → Ω → E) → autoParam (MeasureTheory.Measure Ω) ProbabilityTheory.IsGaussianProcess._auto_1 → Prop |
instHashableInt64 | Init.Data.SInt.Basic | Hashable Int64 |
Nat.findX._proof_4 | Mathlib.Data.Nat.Find | ∀ {p : ℕ → Prop} (m : ℕ), (∀ n ≤ m, ¬p n) → m + 1 = m + 1 ∧ ∀ k ≤ m, ¬p k |
Metric.hausdorffEDist_le_of_infEDist | Mathlib.Topology.MetricSpace.HausdorffDistance | ∀ {α : Type u} [inst : PseudoEMetricSpace α] {s t : Set α} {r : ENNReal},
(∀ x ∈ s, Metric.infEDist x t ≤ r) → (∀ x ∈ t, Metric.infEDist x s ≤ r) → Metric.hausdorffEDist s t ≤ r |
SimpleGraph.toSubgraph | Mathlib.Combinatorics.SimpleGraph.Subgraph | {V : Type u} → {G : SimpleGraph V} → (H : SimpleGraph V) → H ≤ G → G.Subgraph |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.getD_filterMap._simp_1_1 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {x : Ord α} {x_1 : BEq α} [Std.LawfulBEqOrd α] {a b : α}, (compare a b = Ordering.eq) = ((a == b) = true) |
_private.Init.Data.SInt.Lemmas.0.Int32.le_total._simp_1_1 | Init.Data.SInt.Lemmas | ∀ {x y : Int32}, (x ≤ y) = (x.toInt ≤ y.toInt) |
_private.Mathlib.MeasureTheory.Measure.LevyProkhorovMetric.0.MeasureTheory.LevyProkhorov.continuous_ofMeasure_probabilityMeasure._simp_1_9 | Mathlib.MeasureTheory.Measure.LevyProkhorovMetric | ∀ {α : Type u} (s : Set α) (x : α), (x ∈ sᶜ) = (x ∉ s) |
Finset.sup_eq_zero._simp_1 | Mathlib.Algebra.Order.Monoid.Canonical.Basic | ∀ {ι : Type u_1} {α : Type u_2} [inst : AddCommMonoid α] [inst_1 : LinearOrder α] [inst_2 : OrderBot α]
[CanonicallyOrderedAdd α] {s : Finset ι} {f : ι → α}, (s.sup f = 0) = ∀ i ∈ s, f i = 0 |
ContinuousMonoidHom.comp_toFun | Mathlib.Topology.Algebra.ContinuousMonoidHom | ∀ {A : Type u_2} {B : Type u_3} {C : Type u_4} [inst : Monoid A] [inst_1 : Monoid B] [inst_2 : Monoid C]
[inst_3 : TopologicalSpace A] [inst_4 : TopologicalSpace B] [inst_5 : TopologicalSpace C] (g : B →ₜ* C) (f : A →ₜ* B)
(a : A), (g.comp f) a = g (f a) |
Nat.ceil_eq_zero._simp_1 | Mathlib.Algebra.Order.Floor.Semiring | ∀ {R : Type u_1} [inst : Semiring R] [inst_1 : LinearOrder R] [inst_2 : FloorSemiring R] {a : R}, (⌈a⌉₊ = 0) = (a ≤ 0) |
_private.Mathlib.Order.Interval.Set.LinearOrder.0.Set.Ioc_eq_Ioc_iff._proof_1_2 | Mathlib.Order.Interval.Set.LinearOrder | ∀ {α : Type u_1} [inst : LinearOrder α] {a b c d : α}, a < b ∨ c < d → Set.Ioc a b = Set.Ioc c d → a < b |
CategoryTheory.Limits.CategoricalPullback.CatCommSqOver.sndFunctor._proof_2 | Mathlib.CategoryTheory.Limits.Shapes.Pullback.Categorical.Basic | ∀ {A : Type u_5} {B : Type u_6} {C : Type u_7} [inst : CategoryTheory.Category.{u_1, u_5} A]
[inst_1 : CategoryTheory.Category.{u_2, u_6} B] [inst_2 : CategoryTheory.Category.{u_3, u_7} C]
(F : CategoryTheory.Functor A B) (G : CategoryTheory.Functor C B) (X : Type u_8)
[inst_3 : CategoryTheory.Category.{u_4, u_8} X]
{X_1 Y Z : CategoryTheory.Limits.CategoricalPullback.CatCommSqOver F G X} (f : X_1 ⟶ Y) (g : Y ⟶ Z),
(CategoryTheory.CategoryStruct.comp f g).snd = CategoryTheory.CategoryStruct.comp f.snd g.snd |
FirstOrder.Language.Equiv.comp_refl | Mathlib.ModelTheory.Basic | ∀ {L : FirstOrder.Language} {M : Type w} {N : Type w'} [inst : L.Structure M] [inst_1 : L.Structure N]
(g : L.Equiv M N), g.comp (FirstOrder.Language.Equiv.refl L M) = g |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.