name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M |
|---|---|---|
OrderDual.gradeOrder._proof_2 | Mathlib.Order.Grade | ∀ {𝕆 : Type u_2} {α : Type u_1} [inst : Preorder 𝕆] [inst_1 : Preorder α] [inst_2 : GradeOrder 𝕆 α] (x x_1 : αᵒᵈ),
x ⋖ x_1 → OrderDual.toDual (grade 𝕆 (OrderDual.ofDual x)) ⋖ OrderDual.toDual (grade 𝕆 (OrderDual.ofDual x_1)) |
WeakSpace.instContinuousSMul | Mathlib.Topology.Algebra.Module.WeakDual | ∀ {𝕜 : Type u_2} {E : Type u_4} [inst : CommSemiring 𝕜] [inst_1 : TopologicalSpace 𝕜] [inst_2 : ContinuousAdd 𝕜]
[inst_3 : ContinuousConstSMul 𝕜 𝕜] [inst_4 : AddCommMonoid E] [inst_5 : Module 𝕜 E] [inst_6 : TopologicalSpace E]
[ContinuousSMul 𝕜 𝕜], ContinuousSMul 𝕜 (WeakSpace 𝕜 E) |
Std.Rci.HasRcoIntersection.casesOn | Init.Data.Range.Polymorphic.PRange | {α : Type w} →
{motive : Std.Rci.HasRcoIntersection α → Sort u} →
(t : Std.Rci.HasRcoIntersection α) →
((intersection : Std.Rci α → Std.Rco α → Std.Rco α) → motive { intersection := intersection }) → motive t |
IsDenseInducing.closure_image_mem_nhds | Mathlib.Topology.DenseEmbedding | ∀ {α : Type u_1} {β : Type u_2} [inst : TopologicalSpace α] [inst_1 : TopologicalSpace β] {i : α → β} {s : Set α}
{a : α}, IsDenseInducing i → s ∈ nhds a → closure (i '' s) ∈ nhds (i a) |
Con.mapOfSurjective | Mathlib.GroupTheory.Congruence.Hom | {M : Type u_1} →
{N : Type u_2} →
{F : Type u_4} →
[inst : Mul M] →
[inst_1 : Mul N] →
[inst_2 : FunLike F M N] →
[inst_3 : MulHomClass F M N] → {c : Con M} → (f : F) → Con.ker f ≤ c → Function.Surjective ⇑f → Con N |
Nat.le.intro | Init.Data.Nat.Basic | ∀ {n m k : ℕ}, n + k = m → n ≤ m |
Subgroup.IsSubnormal.eq_bot_or_top_of_isSimpleGroup | Mathlib.GroupTheory.IsSubnormal | ∀ {G : Type u_1} [inst : Group G] {H : Subgroup G}, IsSimpleGroup G → H.IsSubnormal → H = ⊥ ∨ H = ⊤ |
_private.Mathlib.Data.Num.ZNum.0.ZNum.bit0_of_bit0.match_1_1 | Mathlib.Data.Num.ZNum | ∀ (motive : ZNum → Prop) (x : ZNum),
(∀ (a : Unit), motive ZNum.zero) →
(∀ (a : PosNum), motive (ZNum.pos a)) → (∀ (a : PosNum), motive (ZNum.neg a)) → motive x |
Filter.comap._proof_3 | Mathlib.Order.Filter.Defs | ∀ {α : Type u_1} {β : Type u_2} (m : α → β) (f : Filter β) {x y : Set α},
x ∈ {s | ∃ t ∈ f, m ⁻¹' t ⊆ s} → y ∈ {s | ∃ t ∈ f, m ⁻¹' t ⊆ s} → x ∩ y ∈ {s | ∃ t ∈ f, m ⁻¹' t ⊆ s} |
CategoryTheory.SimplicialObject.Augmented.ExtraDegeneracy.map._proof_8 | Mathlib.AlgebraicTopology.ExtraDegeneracy | ∀ {C : Type u_4} [inst : CategoryTheory.Category.{u_3, u_4} C] {D : Type u_2}
[inst_1 : CategoryTheory.Category.{u_1, u_2} D] {X : CategoryTheory.SimplicialObject.Augmented C}
(ed : X.ExtraDegeneracy) (F : CategoryTheory.Functor C D) (n : ℕ) (i : Fin (n + 2)),
CategoryTheory.CategoryStruct.comp (F.map (ed.s (n + 1)))
((((CategoryTheory.SimplicialObject.Augmented.whiskering C D).obj F).obj X).left.δ i.succ) =
CategoryTheory.CategoryStruct.comp
((((CategoryTheory.SimplicialObject.Augmented.whiskering C D).obj F).obj X).left.δ i) (F.map (ed.s n)) |
_private.Mathlib.Algebra.SkewMonoidAlgebra.Basic.0.SkewMonoidAlgebra.isScalarTower_self._simp_2 | Mathlib.Algebra.SkewMonoidAlgebra.Basic | ∀ {k : Type u_1} {G : Type u_2} [inst : AddMonoid k] {S : Type u_3} [inst_1 : SMulZeroClass S k] (s : S) (a : G)
(b : k), SkewMonoidAlgebra.single a (s • b) = s • SkewMonoidAlgebra.single a b |
Multiset.coe_eq_coe | Mathlib.Data.Multiset.Defs | ∀ {α : Type u_1} {l₁ l₂ : List α}, ↑l₁ = ↑l₂ ↔ l₁.Perm l₂ |
_private.Lean.DocString.Add.0.Lean.makeDocStringVerso._sparseCasesOn_1 | Lean.DocString.Add | {α : Type u} →
{β : Type v} →
{motive : α ⊕ β → Sort u_1} →
(t : α ⊕ β) → ((val : α) → motive (Sum.inl val)) → (Nat.hasNotBit 1 t.ctorIdx → motive t) → motive t |
_private.Mathlib.Data.List.Triplewise.0.List.triplewise_iff_getElem._proof_1_88 | Mathlib.Data.List.Triplewise | ∀ {α : Type u_1} (tail : List α) (i j k : ℕ),
j < k → k < tail.length + 1 → -1 * ↑j + 1 ≤ 0 → tail.length + 1 ≤ i → i + 1 ≤ tail.length → j - 1 < tail.length |
Valuation.Uniformizer._sizeOf_1 | Mathlib.RingTheory.Valuation.Discrete.Basic | {Γ : Type u_1} →
{inst : LinearOrderedCommGroupWithZero Γ} →
{A : Type u_2} →
{inst_1 : Ring A} → {v : Valuation A Γ} → {hv : v.IsRankOneDiscrete} → [SizeOf Γ] → [SizeOf A] → v.Uniformizer → ℕ |
Equiv.sigmaSigmaSubtype._proof_1 | Mathlib.Logic.Equiv.Basic | ∀ {α : Type u_3} {β : α → Type u_1} {γ : (a : α) → β a → Type u_2} (p : (a : α) × β a → Prop),
{ s // p ⟨s.fst, s.snd.fst⟩ } = { s // p ⟨s.fst, s.snd.fst⟩ } |
Bool.compl_eq_bnot | Mathlib.Order.BooleanAlgebra.Defs | compl = not |
True | Init.Prelude | Prop |
String.Slice.utf8ByteSize_sliceTo | Init.Data.String.Basic | ∀ {s : String.Slice} {pos : s.Pos}, (s.sliceTo pos).utf8ByteSize = pos.offset.byteIdx |
LinearMap.compl₂._proof_2 | Mathlib.LinearAlgebra.BilinearMap | ∀ {R : Type u_9} {R₂ : Type u_7} {R₃ : Type u_4} {R₄ : Type u_3} {R₅ : Type u_6} {M : Type u_8} {N : Type u_5}
{P : Type u_1} {Q : Type u_2} [inst : Semiring R] [inst_1 : Semiring R₂] [inst_2 : Semiring R₃] [inst_3 : Semiring R₄]
[inst_4 : Semiring R₅] {σ₂₃ : R₂ →+* R₃} {σ₄₂ : R₄ →+* R₂} {σ₄₃ : R₄ →+* R₃} [inst_5 : AddCommMonoid M]
[inst_6 : AddCommMonoid N] [inst_7 : AddCommMonoid P] [inst_8 : AddCommMonoid Q] [inst_9 : Module R M]
[inst_10 : Module R₂ N] [inst_11 : Module R₃ P] [inst_12 : Module R₄ Q] [inst_13 : Module R₅ P]
[inst_14 : RingHomCompTriple σ₄₂ σ₂₃ σ₄₃] [inst_15 : SMulCommClass R₃ R₅ P] {σ₁₅ : R →+* R₅}
(h : M →ₛₗ[σ₁₅] N →ₛₗ[σ₂₃] P) (g : Q →ₛₗ[σ₄₂] N) (x x_1 : M),
(LinearMap.lcompₛₗ R₅ P σ₂₃ g) (h (x + x_1)) =
(LinearMap.lcompₛₗ R₅ P σ₂₃ g) (h x) + (LinearMap.lcompₛₗ R₅ P σ₂₃ g) (h x_1) |
Lean.CollectFVars.visit | Lean.Util.CollectFVars | Lean.Expr → Lean.CollectFVars.Visitor |
Multiset.singleton_ne_zero | Mathlib.Data.Multiset.ZeroCons | ∀ {α : Type u_1} (a : α), {a} ≠ 0 |
IsUniformAddGroup.casesOn | Mathlib.Topology.Algebra.IsUniformGroup.Defs | {α : Type u_3} →
[inst : UniformSpace α] →
[inst_1 : AddGroup α] →
{motive : IsUniformAddGroup α → Sort u} →
(t : IsUniformAddGroup α) →
((uniformContinuous_sub : UniformContinuous fun p => p.1 - p.2) → motive ⋯) → motive t |
GroupExtension.Equiv.ofMonoidHom.eq_1 | Mathlib.GroupTheory.GroupExtension.Basic | ∀ {N : Type u_1} {G : Type u_2} [inst : Group N] [inst_1 : Group G] {E : Type u_3} [inst_2 : Group E]
{S : GroupExtension N E G} {E' : Type u_4} [inst_3 : Group E'] {S' : GroupExtension N E' G} (f : E →* E')
(comp_inl : f.comp S.inl = S'.inl) (rightHom_comp : S'.rightHom.comp f = S.rightHom),
GroupExtension.Equiv.ofMonoidHom f comp_inl rightHom_comp =
{ toFun := (↑f).toFun,
invFun := fun e' =>
have e := Function.surjInv ⋯ (S'.rightHom e');
e * S.inl (Function.invFun (⇑S'.inl) ((f e)⁻¹ * e')),
left_inv := ⋯, right_inv := ⋯, map_mul' := ⋯, inl_comm := ⋯, rightHom_comm := ⋯ } |
Turing.PartrecToTM2.codeSupp'.match_1 | Mathlib.Computability.TuringMachine.ToPartrec | (motive : Turing.ToPartrec.Code → Turing.PartrecToTM2.Cont' → Sort u_1) →
(x : Turing.ToPartrec.Code) →
(x_1 : Turing.PartrecToTM2.Cont') →
((c : Turing.ToPartrec.Code) →
(h : c = Turing.ToPartrec.Code.zero') →
(k : Turing.PartrecToTM2.Cont') → motive (namedPattern c Turing.ToPartrec.Code.zero' h) k) →
((c : Turing.ToPartrec.Code) →
(h : c = Turing.ToPartrec.Code.succ) →
(k : Turing.PartrecToTM2.Cont') → motive (namedPattern c Turing.ToPartrec.Code.succ h) k) →
((c : Turing.ToPartrec.Code) →
(h : c = Turing.ToPartrec.Code.tail) →
(k : Turing.PartrecToTM2.Cont') → motive (namedPattern c Turing.ToPartrec.Code.tail h) k) →
((c f fs : Turing.ToPartrec.Code) →
(h : c = f.cons fs) → (k : Turing.PartrecToTM2.Cont') → motive (namedPattern c (f.cons fs) h) k) →
((c f g : Turing.ToPartrec.Code) →
(h : c = f.comp g) → (k : Turing.PartrecToTM2.Cont') → motive (namedPattern c (f.comp g) h) k) →
((c f g : Turing.ToPartrec.Code) →
(h : c = f.case g) → (k : Turing.PartrecToTM2.Cont') → motive (namedPattern c (f.case g) h) k) →
((c f : Turing.ToPartrec.Code) →
(h : c = f.fix) → (k : Turing.PartrecToTM2.Cont') → motive (namedPattern c f.fix h) k) →
motive x x_1 |
Lean.Lsp.ReferenceContext | Lean.Data.Lsp.LanguageFeatures | Type |
_private.Init.Data.Int.Gcd.0.Int.gcd_le_right._proof_1_1 | Init.Data.Int.Gcd | ∀ {b : ℤ}, 0 < b → ¬b = ↑b.natAbs → False |
Std.HashSet.isEmpty_eq_size_eq_zero | Std.Data.HashSet.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {m : Std.HashSet α}, m.isEmpty = (m.size == 0) |
_private.Mathlib.MeasureTheory.Integral.Bochner.VitaliCaratheodory.0.MeasureTheory.exists_lt_lowerSemicontinuous_integral_lt._simp_1_7 | Mathlib.MeasureTheory.Integral.Bochner.VitaliCaratheodory | ∀ (x : ENNReal), (↑x = ⊥) = False |
Std.IterM.DefaultConsumers.forIn_eq | Init.Data.Iterators.Lemmas.Consumers.Monadic.Loop | ∀ {γ : Type x} {α β : Type w} {m : Type w → Type w'} {n : Type x → Type x'} [inst : Monad n]
[inst_1 : Std.Iterator α m β] {lift : (γ : Type w) → (δ : Type x) → (γ → n δ) → m γ → n δ}
{plausible_forInStep : β → γ → ForInStep γ → Prop} {it : Std.IterM m β} {init : γ}
{f : (b : β) → it.IsPlausibleIndirectOutput b → (c : γ) → n (Subtype (plausible_forInStep b c))},
Std.IteratorLoop.forIn lift γ plausible_forInStep it init f =
Std.IterM.DefaultConsumers.forIn' lift γ plausible_forInStep it init it.IsPlausibleIndirectOutput ⋯ f |
Nat.gcd_self | Init.Data.Nat.Gcd | ∀ (n : ℕ), n.gcd n = n |
Subgroup.IsComplement.toRightFun.eq_1 | Mathlib.GroupTheory.Complement | ∀ {G : Type u_1} [inst : Group G] {H : Subgroup G} {T : Set G} (hT : Subgroup.IsComplement (↑H) T),
hT.toRightFun = ⇑hT.rightQuotientEquiv ∘ Quotient.mk'' |
_private.Mathlib.Geometry.Manifold.HasGroupoid.0.restr_mem_maximalAtlas_aux1 | Mathlib.Geometry.Manifold.HasGroupoid | ∀ {H : Type u} {M : Type u_2} [inst : TopologicalSpace H] [inst_1 : TopologicalSpace M] [inst_2 : ChartedSpace H M]
(G : StructureGroupoid H) [ClosedUnderRestriction G] {e e' : OpenPartialHomeomorph M H},
e ∈ StructureGroupoid.maximalAtlas M G → e' ∈ atlas H M → ∀ {s : Set M}, IsOpen s → (e.restr s).symm.trans e' ∈ G |
Lean.Meta.SynthInstance.State.generatorStack._default | Lean.Meta.SynthInstance | Array Lean.Meta.SynthInstance.GeneratorNode |
BitVec.toFin_ofFnLEAux | Batteries.Data.BitVec.Lemmas | ∀ {n : ℕ} (m : ℕ) (f : Fin n → Bool), (BitVec.ofFnLEAux m f).toFin = Fin.ofNat (2 ^ m) (Nat.ofBits f) |
_private.Mathlib.Topology.Constructions.0.inducing_sigma.match_1_2 | Mathlib.Topology.Constructions | ∀ {ι : Type u_1} {σ : ι → Type u_2} (motive : Sigma σ → Prop) (x : Sigma σ),
(∀ (i : ι) (x : σ i), motive ⟨i, x⟩) → motive x |
Finset.compls.eq_1 | Mathlib.Data.Finset.Sups | ∀ {α : Type u_2} [inst : BooleanAlgebra α], Finset.compls = Finset.map { toFun := compl, inj' := ⋯ } |
one_le_pow₀ | Mathlib.Algebra.Order.GroupWithZero.Unbundled.Basic | ∀ {M₀ : Type u_2} [inst : MonoidWithZero M₀] [inst_1 : Preorder M₀] {a : M₀} [ZeroLEOneClass M₀] [PosMulMono M₀],
1 ≤ a → ∀ {n : ℕ}, 1 ≤ a ^ n |
CategoryTheory.LocallyDiscrete.eqToHom_toLoc | Mathlib.CategoryTheory.Bicategory.LocallyDiscrete | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {a b : C} (h : a = b),
(CategoryTheory.eqToHom h).toLoc = CategoryTheory.eqToHom ⋯ |
_private.Mathlib.Algebra.Homology.ExactSequence.0.CategoryTheory.ComposableArrows.exact₂_iff._proof_1_10 | Mathlib.Algebra.Homology.ExactSequence | ∀ (i : ℕ), i + 2 ≤ 2 → i = 0 |
isClosed_coinduced | Mathlib.Topology.Order | ∀ {α : Type u_1} {β : Type u_2} {t : TopologicalSpace α} {s : Set β} {f : α → β}, IsClosed s ↔ IsClosed (f ⁻¹' s) |
Finite.exists_max | Mathlib.Data.Fintype.Lattice | ∀ {α : Type u_2} {β : Type u_3} [Finite α] [Nonempty α] [inst : LinearOrder β] (f : α → β), ∃ x₀, ∀ (x : α), f x ≤ f x₀ |
CategoryTheory.NatTrans.IsMonoidal.casesOn | Mathlib.CategoryTheory.Monoidal.NaturalTransformation | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
[inst_1 : CategoryTheory.MonoidalCategory C] →
{D : Type u₂} →
[inst_2 : CategoryTheory.Category.{v₂, u₂} D] →
[inst_3 : CategoryTheory.MonoidalCategory D] →
{F₁ F₂ : CategoryTheory.Functor C D} →
{τ : F₁ ⟶ F₂} →
[inst_4 : F₁.LaxMonoidal] →
[inst_5 : F₂.LaxMonoidal] →
{motive : CategoryTheory.NatTrans.IsMonoidal τ → Sort u} →
(t : CategoryTheory.NatTrans.IsMonoidal τ) →
((unit :
CategoryTheory.CategoryStruct.comp (CategoryTheory.Functor.LaxMonoidal.ε F₁)
(τ.app (CategoryTheory.MonoidalCategoryStruct.tensorUnit C)) =
CategoryTheory.Functor.LaxMonoidal.ε F₂) →
(tensor :
∀ (X Y : C),
CategoryTheory.CategoryStruct.comp (CategoryTheory.Functor.LaxMonoidal.μ F₁ X Y)
(τ.app (CategoryTheory.MonoidalCategoryStruct.tensorObj X Y)) =
CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCategoryStruct.tensorHom (τ.app X) (τ.app Y))
(CategoryTheory.Functor.LaxMonoidal.μ F₂ X Y)) →
motive ⋯) →
motive t |
Lean.Grind.CommRing.Expr.denoteSAsRing.eq_2 | Init.Grind.Ring.CommSemiringAdapter | ∀ {α : Type u_1} [inst : Lean.Grind.Semiring α] (ctx : Lean.Grind.CommRing.Context α) (k : ℕ),
Lean.Grind.CommRing.Expr.denoteSAsRing ctx (Lean.Grind.CommRing.Expr.natCast k) = OfNat.ofNat k |
Std.DTreeMap.Raw.isSome_getKey?_iff_mem._simp_1 | Std.Data.DTreeMap.Raw.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t : Std.DTreeMap.Raw α β cmp} [Std.TransCmp cmp],
t.WF → ∀ {a : α}, ((t.getKey? a).isSome = true) = (a ∈ t) |
Lean.Elab.Term.SavedContext.recOn | Lean.Elab.Term.TermElabM | {motive : Lean.Elab.Term.SavedContext → Sort u} →
(t : Lean.Elab.Term.SavedContext) →
((declName? : Option Lean.Name) →
(options : Lean.Options) →
(openDecls : List Lean.OpenDecl) →
(macroStack : Lean.Elab.MacroStack) →
(errToSorry : Bool) →
(levelNames : List Lean.Name) →
(fixedTermElabs : Array Lean.Elab.Term.FixedTermElabRef) →
motive
{ declName? := declName?, options := options, openDecls := openDecls, macroStack := macroStack,
errToSorry := errToSorry, levelNames := levelNames, fixedTermElabs := fixedTermElabs }) →
motive t |
MonotoneOn.slope_nonneg | Mathlib.LinearAlgebra.AffineSpace.Slope | ∀ {k : Type u_1} {E : Type u_2} [inst : Field k] [inst_1 : AddCommGroup E] [inst_2 : Module k E]
[inst_3 : LinearOrder k] [IsStrictOrderedRing k] [inst_5 : PartialOrder E] [IsOrderedAddMonoid E] [PosSMulMono k E]
{f : k → E} {x y : k} {s : Set k}, MonotoneOn f s → x ∈ s → y ∈ s → 0 ≤ slope f x y |
IsSolvableByRad | Mathlib.FieldTheory.AbelRuffini | (F : Type u_1) → {E : Type u_2} → [inst : Field F] → [inst_1 : Field E] → [Algebra F E] → E → Prop |
ge_of_tendsto | Mathlib.Topology.Order.OrderClosed | ∀ {α : Type u} {β : Type v} [inst : TopologicalSpace α] [inst_1 : Preorder α] [ClosedIciTopology α] {f : β → α}
{a b : α} {x : Filter β} [x.NeBot], Filter.Tendsto f x (nhds a) → (∀ᶠ (c : β) in x, b ≤ f c) → b ≤ a |
UniformCauchySeqOnFilter.eq_1 | Mathlib.Topology.UniformSpace.UniformConvergence | ∀ {α : Type u_1} {β : Type u_2} {ι : Type u_4} [inst : UniformSpace β] (F : ι → α → β) (p : Filter ι) (p' : Filter α),
UniformCauchySeqOnFilter F p p' =
∀ u ∈ uniformity β, ∀ᶠ (m : (ι × ι) × α) in (p ×ˢ p) ×ˢ p', (F m.1.1 m.2, F m.1.2 m.2) ∈ u |
CategoryTheory.ExactFunctor.whiskeringRight_obj_map | Mathlib.CategoryTheory.Limits.ExactFunctor | ∀ (C : Type u₁) [inst : CategoryTheory.Category.{v₁, u₁} C] (D : Type u₂) [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
(E : Type u₃) [inst_2 : CategoryTheory.Category.{v₃, u₃} E] (F : D ⥤ₑ E) {X Y : C ⥤ₑ D} (f : X ⟶ Y),
((CategoryTheory.ExactFunctor.whiskeringRight C D E).obj F).map f =
CategoryTheory.ObjectProperty.homMk (CategoryTheory.Functor.whiskerRight f.hom F.obj) |
HasFTaylorSeriesUpTo.hasFDerivAt | Mathlib.Analysis.Calculus.ContDiff.FTaylorSeries | ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {E : Type uE} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {F : Type uF} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {f : E → F}
{n : WithTop ℕ∞} {p : E → FormalMultilinearSeries 𝕜 E F},
HasFTaylorSeriesUpTo n f p → n ≠ 0 → ∀ (x : E), HasFDerivAt f ((continuousMultilinearCurryFin1 𝕜 E F) (p x 1)) x |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.mem_of_getKey?_eq_some._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) |
FirstOrder.Language.StrongHomClass.realize_formula._simp_1 | Mathlib.ModelTheory.Semantics | ∀ {L : FirstOrder.Language} {M : Type w} {N : Type u_1} [inst : L.Structure M] [inst_1 : L.Structure N] {α : Type u'}
{F : Type u_4} [inst_2 : EquivLike F M N] [L.StrongHomClass F M N] (g : F) (φ : L.Formula α) {v : α → M},
φ.Realize (⇑g ∘ v) = φ.Realize v |
Aesop.RuleTac.ForwardM.instInhabitedState | Aesop.RuleTac.Forward | Inhabited Aesop.RuleTac.ForwardM.State |
Lean.Parser.Command.mixfix._regBuiltin.Lean.Parser.Command.mixfix.formatter_41 | Lean.Parser.Syntax | IO Unit |
CliffordAlgebra.map_comp_ι | Mathlib.LinearAlgebra.CliffordAlgebra.Basic | ∀ {R : Type u_1} [inst : CommRing R] {M₁ : Type u_4} {M₂ : Type u_5} [inst_1 : AddCommGroup M₁]
[inst_2 : AddCommGroup M₂] [inst_3 : Module R M₁] [inst_4 : Module R M₂] {Q₁ : QuadraticForm R M₁}
{Q₂ : QuadraticForm R M₂} (f : Q₁ →qᵢ Q₂),
(CliffordAlgebra.map f).toLinearMap ∘ₗ CliffordAlgebra.ι Q₁ = CliffordAlgebra.ι Q₂ ∘ₗ f.toLinearMap |
TopCat.of.sizeOf_spec | Mathlib.Topology.Category.TopCat.Basic | ∀ (carrier : Type u) [str : TopologicalSpace carrier], sizeOf (TopCat.of carrier) = 1 + sizeOf carrier + sizeOf str |
_private.Mathlib.Geometry.Euclidean.Incenter.0.Affine.Simplex.touchpointWeights_singleton_pos._simp_1_1 | Mathlib.Geometry.Euclidean.Incenter | ∀ {α : Type u_1} [inst : Zero α] [inst_1 : Preorder α] [inst_2 : DecidableLT α] {a : α}, (SignType.sign a = 1) = (0 < a) |
instCommutativeInt8HAnd | Init.Data.SInt.Bitwise | Std.Commutative fun x1 x2 => x1 &&& x2 |
Mathlib.Tactic.Ring.ExProd.brecOn.eq | Mathlib.Tactic.Ring.Common | ∀
{motive_1 :
{u : Lean.Level} →
{α : Q(Type u)} → (a : Q(CommSemiring «$α»)) → (e : Q(«$α»)) → Mathlib.Tactic.Ring.ExBase a e → Sort u}
{motive_2 :
{u : Lean.Level} →
{α : Q(Type u)} → (a : Q(CommSemiring «$α»)) → (e : Q(«$α»)) → Mathlib.Tactic.Ring.ExProd a e → Sort u}
{motive_3 :
{u : Lean.Level} →
{α : Q(Type u)} → (a : Q(CommSemiring «$α»)) → (e : Q(«$α»)) → Mathlib.Tactic.Ring.ExSum a e → Sort u}
{u : Lean.Level} {α : Q(Type u)} {a : Q(CommSemiring «$α»)} {e : Q(«$α»)} (t : Mathlib.Tactic.Ring.ExProd a e)
(F_1 :
{u : Lean.Level} →
{α : Q(Type u)} →
(a : Q(CommSemiring «$α»)) → (e : Q(«$α»)) → (t : Mathlib.Tactic.Ring.ExBase a e) → t.below → motive_1 a e t)
(F_2 :
{u : Lean.Level} →
{α : Q(Type u)} →
(a : Q(CommSemiring «$α»)) → (e : Q(«$α»)) → (t : Mathlib.Tactic.Ring.ExProd a e) → t.below → motive_2 a e t)
(F_3 :
{u : Lean.Level} →
{α : Q(Type u)} →
(a : Q(CommSemiring «$α»)) → (e : Q(«$α»)) → (t : Mathlib.Tactic.Ring.ExSum a e) → t.below → motive_3 a e t),
t.brecOn F_1 F_2 F_3 = F_2 a e t (Mathlib.Tactic.Ring.ExProd.brecOn.go t F_1 F_2 F_3).2 |
_private.Lean.Meta.Constructions.NoConfusion.0.Lean.mkNoConfusionType._sparseCasesOn_1 | Lean.Meta.Constructions.NoConfusion | {α : Type u} →
{motive : List α → Sort u_1} →
(t : List α) →
((head : α) → (tail : List α) → motive (head :: tail)) → (Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t |
Int.dvd_mul_gcd_iff_dvd_mul | Init.Data.Int.Gcd | ∀ {k n m : ℤ}, k ∣ n * ↑(k.gcd m) ↔ k ∣ n * m |
Turing.TM1.Stmt.brecOn | Mathlib.Computability.TuringMachine.PostTuringMachine | {Γ : Type u_1} →
{Λ : Type u_2} →
{σ : Type u_3} →
{motive : Turing.TM1.Stmt Γ Λ σ → Sort u} →
(t : Turing.TM1.Stmt Γ Λ σ) → ((t : Turing.TM1.Stmt Γ Λ σ) → Turing.TM1.Stmt.below t → motive t) → motive t |
Finset.exists_ne_map_eq_of_card_image_lt | Mathlib.Data.Finset.Card | ∀ {α : Type u_1} {β : Type u_2} {s : Finset α} [inst : DecidableEq β] {f : α → β},
(Finset.image f s).card < s.card → ∃ x ∈ s, ∃ y ∈ s, x ≠ y ∧ f x = f y |
_private.Std.Do.PostCond.0.Std.Do.ExceptConds.entails.match_1.eq_3 | Std.Do.PostCond | ∀ (motive : (ps : Std.Do.PostShape) → Std.Do.ExceptConds ps → Std.Do.ExceptConds ps → Sort u_2) (ε : Type u_1)
(ps : Std.Do.PostShape) (x y : Std.Do.ExceptConds (Std.Do.PostShape.except ε ps))
(h_1 : (x y : Std.Do.ExceptConds Std.Do.PostShape.pure) → motive Std.Do.PostShape.pure x y)
(h_2 :
(σ : Type u_1) →
(ps : Std.Do.PostShape) →
(x y : Std.Do.ExceptConds (Std.Do.PostShape.arg σ ps)) → motive (Std.Do.PostShape.arg σ ps) x y)
(h_3 :
(ε : Type u_1) →
(ps : Std.Do.PostShape) →
(x y : Std.Do.ExceptConds (Std.Do.PostShape.except ε ps)) → motive (Std.Do.PostShape.except ε ps) x y),
(match Std.Do.PostShape.except ε ps, x, y with
| Std.Do.PostShape.pure, x, y => h_1 x y
| Std.Do.PostShape.arg σ ps, x, y => h_2 σ ps x y
| Std.Do.PostShape.except ε ps, x, y => h_3 ε ps x y) =
h_3 ε ps x y |
_private.Mathlib.Topology.MetricSpace.Pseudo.Defs.0.Metric.dense_iff_iUnion_ball._simp_1_1 | Mathlib.Topology.MetricSpace.Pseudo.Defs | ∀ {α : Type u} {s : Set α}, (s = Set.univ) = ∀ (x : α), x ∈ s |
_private.Mathlib.Topology.Order.IsLUB.0.ConditionallyCompleteLinearOrder.isCompact_Icc.match_1_6 | Mathlib.Topology.Order.IsLUB | ∀ {α : Type u_1} [inst : ConditionallyCompleteLinearOrder α] (f : Ultrafilter α) (c : α)
(motive : (∃ x, c < x ∧ Set.Iio x ∉ f) → Prop) (x : ∃ x, c < x ∧ Set.Iio x ∉ f),
(∀ (x : α) (hx : c < x) (hxf : Set.Iio x ∉ f), motive ⋯) → motive x |
CategoryTheory.Enriched.FunctorCategory.isLimitConeFunctorEnrichedHom._proof_1 | Mathlib.CategoryTheory.Enriched.FunctorCategory | ∀ (V : Type u_2) [inst : CategoryTheory.Category.{u_1, u_2} V] [inst_1 : CategoryTheory.MonoidalCategory V]
{C : Type u_6} [inst_2 : CategoryTheory.Category.{u_5, u_6} C] {J : Type u_4}
[inst_3 : CategoryTheory.Category.{u_3, u_4} J] [inst_4 : CategoryTheory.EnrichedOrdinaryCategory V C]
(F₁ F₂ : CategoryTheory.Functor J C) [inst_5 : CategoryTheory.Enriched.FunctorCategory.HasFunctorEnrichedHom V F₁ F₂]
[inst_6 : CategoryTheory.Enriched.FunctorCategory.HasEnrichedHom V F₁ F₂]
(s : CategoryTheory.Limits.Cone (CategoryTheory.Enriched.FunctorCategory.functorEnrichedHom V F₁ F₂))
(m : s.pt ⟶ (CategoryTheory.Enriched.FunctorCategory.coneFunctorEnrichedHom V F₁ F₂).pt),
(∀ (j : J),
CategoryTheory.CategoryStruct.comp m
((CategoryTheory.Enriched.FunctorCategory.coneFunctorEnrichedHom V F₁ F₂).π.app j) =
s.π.app j) →
m = CategoryTheory.Enriched.FunctorCategory.isLimitConeFunctorEnrichedHom.lift s |
MulAction.IsPreprimitive.isQuasiPreprimitive | Mathlib.GroupTheory.GroupAction.Primitive | ∀ {M : Type u_3} [inst : Group M] {α : Type u_4} [inst_1 : MulAction M α] [MulAction.IsPreprimitive M α],
MulAction.IsQuasiPreprimitive M α |
Lean.Meta.ExprConfigCacheKey.expr | Lean.Meta.Basic | Lean.Meta.ExprConfigCacheKey → Lean.Expr |
_private.Mathlib.Analysis.Complex.Convex.0.Complex.rectangle_eq_convexHull._simp_1_2 | Mathlib.Analysis.Complex.Convex | ∀ {𝕜 : Type u_1} [inst : Field 𝕜] [inst_1 : LinearOrder 𝕜] [IsStrictOrderedRing 𝕜] (x y : 𝕜),
Set.uIcc x y = segment 𝕜 x y |
Batteries.RBNode.forM.eq_def | Batteries.Data.RBMap.Lemmas | ∀ {m : Type u_1 → Type u_2} {α : Type u_3} [inst : Monad m] (f : α → m PUnit.{u_1 + 1}) (x : Batteries.RBNode α),
Batteries.RBNode.forM f x =
match x with
| Batteries.RBNode.nil => pure PUnit.unit
| Batteries.RBNode.node c l v r => do
Batteries.RBNode.forM f l
f v
Batteries.RBNode.forM f r |
_private.Mathlib.RingTheory.QuasiFinite.Weakly.0.Algebra.WeaklyQuasiFiniteAt.of_quasiFiniteAt_residueField._simp_1_1 | Mathlib.RingTheory.QuasiFinite.Weakly | ∀ (R : Type u) (S : Type v) (A : Type w) [inst : CommSemiring R] [inst_1 : CommSemiring S] [inst_2 : Semiring A]
[inst_3 : Algebra R S] [inst_4 : Algebra S A] [inst_5 : Algebra R A] [IsScalarTower R S A],
(algebraMap S A).comp (algebraMap R S) = algebraMap R A |
IsAtom.uniqueFinpartition._proof_1 | Mathlib.Order.Partition.Finpartition | ∀ {α : Type u_1} [inst : Lattice α] [inst_1 : OrderBot α] {a : α} {P : Finpartition a} (ha : IsAtom a)
(P : Finpartition a), P = Finpartition.indiscrete ⋯ |
SSet.horn₂₁.isPushout | Mathlib.AlgebraicTopology.SimplicialSet.HornColimits | CategoryTheory.IsPushout (SSet.stdSimplex.δ 0) (SSet.stdSimplex.δ 1) SSet.horn₂₁.ι₀₁ SSet.horn₂₁.ι₁₂ |
MulChar.val_neg_one_eq_one_of_odd_order | Mathlib.NumberTheory.MulChar.Basic | ∀ {R : Type u_1} {R' : Type u_2} [inst : CommRing R] [inst_1 : CommMonoidWithZero R'] {χ : MulChar R R'} {n : ℕ},
Odd n → χ ^ n = 1 → χ (-1) = 1 |
Lean.OLeanLevel.casesOn | Lean.Environment | {motive : Lean.OLeanLevel → Sort u} →
(t : Lean.OLeanLevel) →
motive Lean.OLeanLevel.exported → motive Lean.OLeanLevel.server → motive Lean.OLeanLevel.private → motive t |
CalcPanel.rpc._rpc_wrapped | Mathlib.Tactic.Widget.Calc | Lean.Server.RpcProcedure |
FirstOrder.Language.Substructure.closure._proof_1 | Mathlib.ModelTheory.Substructures | ∀ (L : FirstOrder.Language) {M : Type u_1} [inst : L.Structure M] (x : Set M) (x_1 : L.Substructure M),
sInf {S | x ⊆ ↑S} ≤ x_1 ↔ x ≤ ↑x_1 |
CategoryTheory.Presieve.CoverByImageStructure.mk._flat_ctor | Mathlib.CategoryTheory.Sites.DenseSubsite.Basic | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
{D : Type u_2} →
[inst_1 : CategoryTheory.Category.{v_2, u_2} D] →
{G : CategoryTheory.Functor C D} →
{V U : D} →
{f : V ⟶ U} →
(obj : C) →
(lift : V ⟶ G.obj obj) →
(map : G.obj obj ⟶ U) →
autoParam (CategoryTheory.CategoryStruct.comp lift map = f)
CategoryTheory.Presieve.CoverByImageStructure.fac._autoParam →
CategoryTheory.Presieve.CoverByImageStructure G f |
FirstOrder.Field.FieldAxiom.addAssoc.elim | Mathlib.ModelTheory.Algebra.Field.Basic | {motive : FirstOrder.Field.FieldAxiom → Sort u} →
(t : FirstOrder.Field.FieldAxiom) → t.ctorIdx = 0 → motive FirstOrder.Field.FieldAxiom.addAssoc → motive t |
isNoetherian_mk | Mathlib.RingTheory.Noetherian.Defs | ∀ {R : Type u_1} {M : Type u_2} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M],
WellFoundedGT (Submodule R M) → IsNoetherian R M |
GenLoop.Homotopic | Mathlib.Topology.Homotopy.HomotopyGroup | {N : Type u_1} → {X : Type u_2} → [inst : TopologicalSpace X] → {x : X} → ↑(GenLoop N X x) → ↑(GenLoop N X x) → Prop |
TopologicalSpace.IsSeparable.of_separableSpace | Mathlib.Topology.Bases | ∀ {α : Type u} [t : TopologicalSpace α] [h : TopologicalSpace.SeparableSpace α] (s : Set α),
TopologicalSpace.IsSeparable s |
Lean.Lsp.ResolvableCompletionItemData._sizeOf_inst | Lean.Data.Lsp.LanguageFeatures | SizeOf Lean.Lsp.ResolvableCompletionItemData |
QuadraticModuleCat.cliffordAlgebra_map | Mathlib.LinearAlgebra.CliffordAlgebra.CategoryTheory | ∀ {R : Type u} [inst : CommRing R] {_M _N : QuadraticModuleCat R} (f : _M ⟶ _N),
QuadraticModuleCat.cliffordAlgebra.map f = AlgCat.ofHom (CliffordAlgebra.map (QuadraticModuleCat.Hom.toIsometry f)) |
List.length_permutationsAux | Mathlib.Data.List.Permutation | ∀ {α : Type u_1} (ts is : List α),
(ts.permutationsAux is).length + is.length.factorial = (ts.length + is.length).factorial |
Lean.Server.LspResponse.mk.noConfusion | Lean.Server.Requests | {α : Type} →
{P : Sort u} →
{response : α} →
{isComplete : Bool} →
{response' : α} →
{isComplete' : Bool} →
{ response := response, isComplete := isComplete } = { response := response', isComplete := isComplete' } →
(response ≍ response' → isComplete = isComplete' → P) → P |
Asymptotics.IsBigOWith.comp_tendsto | Mathlib.Analysis.Asymptotics.Defs | ∀ {α : Type u_1} {β : Type u_2} {E : Type u_3} {F : Type u_4} [inst : Norm E] [inst_1 : Norm F] {c : ℝ} {f : α → E}
{g : α → F} {l : Filter α},
Asymptotics.IsBigOWith c l f g →
∀ {k : β → α} {l' : Filter β}, Filter.Tendsto k l' l → Asymptotics.IsBigOWith c l' (f ∘ k) (g ∘ k) |
Std.DTreeMap.Equiv.maxEntry_eq | Std.Data.DTreeMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t₁ t₂ : Std.DTreeMap α β cmp} [Std.TransCmp cmp]
{he : t₁.isEmpty = false} (h : t₁.Equiv t₂), t₁.maxEntry he = t₂.maxEntry ⋯ |
_private.Lean.Parser.Tactic.Doc.0.Lean.Parser.Tactic.Doc.initFn.match_3._@.Lean.Parser.Tactic.Doc.710499956._hygCtx._hyg.2 | Lean.Parser.Tactic.Doc | (motive : Option Lean.Name → Sort u_1) →
(x : Option Lean.Name) → ((tgt' : Lean.Name) → motive (some tgt')) → ((x : Option Lean.Name) → motive x) → motive x |
Polynomial.instNormalizationMonoid._proof_5 | Mathlib.Algebra.Polynomial.FieldDivision | ∀ {R : Type u_1} [inst : CommRing R] [NoZeroDivisors R] [inst_2 : NormalizationMonoid R] (u : (Polynomial R)ˣ),
↑{ val := Polynomial.C ↑(normUnit (↑u).leadingCoeff), inv := Polynomial.C ↑(normUnit (↑u).leadingCoeff)⁻¹,
val_inv := ⋯, inv_val := ⋯ } =
↑u⁻¹ |
mdifferentiableAt_atlas | Mathlib.Geometry.Manifold.MFDeriv.Atlas | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {H : Type u_3} [inst_3 : TopologicalSpace H] {I : ModelWithCorners 𝕜 E H} {M : Type u_4}
[inst_4 : TopologicalSpace M] [inst_5 : ChartedSpace H M] [IsManifold I 1 M] {e : OpenPartialHomeomorph M H},
e ∈ atlas H M → ∀ {x : M}, x ∈ e.source → MDiffAt ↑e x |
AlgebraicGeometry.Scheme.Modules.instHasLimits | Mathlib.AlgebraicGeometry.Modules.Sheaf | ∀ {X : AlgebraicGeometry.Scheme}, CategoryTheory.Limits.HasLimits X.Modules |
MeasureTheory.OuterMeasure.comap | Mathlib.MeasureTheory.OuterMeasure.Operations | {α : Type u_1} → {β : Type u_3} → (α → β) → MeasureTheory.OuterMeasure β →ₗ[ENNReal] MeasureTheory.OuterMeasure α |
StarAlgEquiv.isometry | Mathlib.Analysis.CStarAlgebra.Spectrum | ∀ {F : Type u_1} {A : Type u_2} {B : Type u_3} [inst : NonUnitalCStarAlgebra A] [inst_1 : NonUnitalCStarAlgebra B]
[inst_2 : EquivLike F A B] [NonUnitalAlgEquivClass F ℂ A B] [StarHomClass F A B] (φ : F), Isometry ⇑φ |
Std.ExtDTreeMap.minEntry! | Std.Data.ExtDTreeMap.Basic | {α : Type u} →
{β : α → Type v} →
{cmp : α → α → Ordering} →
[Std.TransCmp cmp] → [Inhabited ((a : α) × β a)] → Std.ExtDTreeMap α β cmp → (a : α) × β a |
Ideal.exists_mem_pow_notMem_pow_succ | Mathlib.RingTheory.DedekindDomain.Ideal.Lemmas | ∀ {A : Type u_2} [inst : CommRing A] [IsDedekindDomain A] (I : Ideal A),
I ≠ ⊥ → I ≠ ⊤ → ∀ (e : ℕ), ∃ x ∈ I ^ e, x ∉ I ^ (e + 1) |
Set.Ico_subset_Ico_left | Mathlib.Order.Interval.Set.Basic | ∀ {α : Type u_1} [inst : Preorder α] {a₁ a₂ b : α}, a₁ ≤ a₂ → Set.Ico a₂ b ⊆ Set.Ico a₁ b |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.