name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
Lean.Parser.Term.num.parenthesizer | Lean.Parser.Term | Lean.PrettyPrinter.Parenthesizer | null | true |
AddSubgroup.addCommutator_eq_bot_iff_le_centralizer | Mathlib.GroupTheory.Commutator.Basic | ∀ {G : Type u_1} [inst : AddGroup G] {H₁ H₂ : AddSubgroup G}, ⁅H₁, H₂⁆ = ⊥ ↔ H₁ ≤ AddSubgroup.centralizer ↑H₂ | null | true |
Subsemigroup.centerToMulOpposite._proof_2 | Mathlib.GroupTheory.Submonoid.Center | ∀ {M : Type u_1} [inst : Mul M],
Function.RightInverse (fun r => ⟨MulOpposite.unop ↑r, ⋯⟩) fun r => ⟨MulOpposite.op ↑r, ⋯⟩ | null | false |
_private.Lean.Elab.DeclModifiers.0.Lean.Elab.Visibility.isPublic._sparseCasesOn_1 | Lean.Elab.DeclModifiers | {motive : Lean.Elab.Visibility → Sort u} →
(t : Lean.Elab.Visibility) → motive Lean.Elab.Visibility.public → (Nat.hasNotBit 4 t.ctorIdx → motive t) → motive t | null | false |
CategoryTheory.LocalizerMorphism.homMap_comp | Mathlib.CategoryTheory.Localization.HomEquiv | ∀ {C₁ : Type u_2} {C₂ : Type u_3} {D₁ : Type u_5} {D₂ : Type u_6} [inst : CategoryTheory.Category.{v_2, u_2} C₁]
[inst_1 : CategoryTheory.Category.{v_3, u_3} C₂] [inst_2 : CategoryTheory.Category.{v_5, u_5} D₁]
[inst_3 : CategoryTheory.Category.{v_6, u_6} D₂] {W₁ : CategoryTheory.MorphismProperty C₁}
{W₂ : Catego... | null | true |
CochainComplex.HomComplex.Cochain.ofHom_v | Mathlib.Algebra.Homology.HomotopyCategory.HomComplex | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Preadditive C]
{F G : CochainComplex C ℤ} (φ : F ⟶ G) (p : ℤ), (CochainComplex.HomComplex.Cochain.ofHom φ).v p p ⋯ = φ.f p | null | true |
_private.Mathlib.Data.Nat.Log.0.Nat.log.go_spec._simp_1_4 | Mathlib.Data.Nat.Log | ∀ {n : ℕ}, (1 ≤ n) = (n ≠ 0) | null | false |
RootPairing.EmbeddedG2.mem_span_of_mem_allRoots | Mathlib.LinearAlgebra.RootSystem.Finite.G2 | ∀ {ι : 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)
[inst_5 : P.EmbeddedG2] [Finite ι] [CharZero R] [IsDomain R] {x : M},
x ∈ RootPairing.EmbeddedG2.allRoots P →
... | null | true |
CategoryTheory.ProjectiveResolution.ofComplex._proof_3 | Mathlib.CategoryTheory.Abelian.Projective.Resolution | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Abelian C] {X₀ X₁ : C}
(f : X₁ ⟶ X₀), CategoryTheory.Limits.HasKernel f | null | false |
Algebra.Etale.comp | Mathlib.RingTheory.Etale.Basic | ∀ (R : Type u) (A : Type v) (B : Type u_1) [inst : CommRing R] [inst_1 : CommRing A] [inst_2 : Algebra R A]
[inst_3 : CommRing B] [inst_4 : Algebra R B] [inst_5 : Algebra A B] [IsScalarTower R A B] [Algebra.Etale R A]
[Algebra.Etale A B], Algebra.Etale R B | Étale is stable under composition. | true |
EuclideanGeometry.eq_of_dist_eq_of_dist_eq_of_finrank_eq_two | Mathlib.Geometry.Euclidean.Basic | ∀ {V : Type u_1} {P : Type u_2} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V] [inst_2 : MetricSpace P]
[NormedAddTorsor V P] [FiniteDimensional ℝ V],
Module.finrank ℝ V = 2 →
∀ {c₁ c₂ p₁ p₂ p : P} {r₁ r₂ : ℝ},
c₁ ≠ c₂ →
p₁ ≠ p₂ →
dist p₁ c₁ = r₁ →
dist p₂ c₁ ... | Distances `r₁` `r₂` of `p` from two different points `c₁` `c₂` determine at
most two points `p₁` `p₂` in two-dimensional space (two circles intersect in at
most two points). | true |
Lean.Doc.Parser.InList.mk._flat_ctor | Lean.DocString.Parser | ℕ → Lean.Doc.Parser.OrderedListType ⊕ Lean.Doc.Parser.UnorderedListType → Lean.Doc.Parser.InList | null | false |
AddCircle.liftIoc_zero_continuous | Mathlib.Topology.Instances.AddCircle.Defs | ∀ {𝕜 : Type u_1} {B : Type u_2} [inst : AddCommGroup 𝕜] [inst_1 : LinearOrder 𝕜] [inst_2 : IsOrderedAddMonoid 𝕜] {p : 𝕜}
[hp : Fact (0 < p)] [inst_3 : Archimedean 𝕜] [inst_4 : TopologicalSpace 𝕜] [OrderTopology 𝕜]
[inst_6 : TopologicalSpace B] {f : 𝕜 → B},
f 0 = f p → ContinuousOn f (Set.Icc 0 p) → Conti... | null | true |
List.mem_attach | Init.Data.List.Attach | ∀ {α : Type u_1} (l : List α) (x : { x // x ∈ l }), x ∈ l.attach | null | true |
QuadraticAlgebra.ratCast_def | Mathlib.Algebra.QuadraticAlgebra.Basic | ∀ {K : Type u_1} [inst : Field K] {a b : K} (q : ℚ), RatCast.ratCast q = QuadraticAlgebra.C ↑q | null | true |
ODE.FunSpace.mk.congr_simp | Mathlib.Analysis.ODE.PicardLindelof | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] {tmin tmax : ℝ} {t₀ : ↑(Set.Icc tmin tmax)} {x₀ : E} {r L : NNReal}
(toFun toFun_1 : ↑(Set.Icc tmin tmax) → E) (e_toFun : toFun = toFun_1) (lipschitzWith : LipschitzWith L toFun)
(mem_closedBall₀ : toFun t₀ ∈ Metric.closedBall x₀ ↑r),
{ toFun := toFun, lipschitzWith ... | null | true |
RingHom.codomain_trivial_iff_range_trivial | Mathlib.Algebra.Ring.Hom.Defs | ∀ {α : Type u_2} {β : Type u_3} {x : NonAssocSemiring α} {x_1 : NonAssocSemiring β} (f : α →+* β),
0 = 1 ↔ ∀ (x_2 : α), f x_2 = 0 | `f : α →+* β` has a trivial codomain iff it has a trivial range. | true |
_private.Lean.Meta.Tactic.Simp.BuiltinSimprocs.BitVec.0.BitVec.reduceHShiftRight._regBuiltin.BitVec.reduceHShiftRight.declare_1._@.Lean.Meta.Tactic.Simp.BuiltinSimprocs.BitVec.3981976031._hygCtx._hyg.29 | Lean.Meta.Tactic.Simp.BuiltinSimprocs.BitVec | IO Unit | null | false |
_private.Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Mul.0.Std.Tactic.BVDecide.BVExpr.bitblast.blastMul._proof_1 | Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Mul | ∀ {w : ℕ}, ¬w = 0 → ¬0 < w → False | null | false |
CategoryTheory.Limits.CatCospanTransformMorphism.left_coherence_assoc | Mathlib.CategoryTheory.Limits.Shapes.Pullback.Categorical.CatCospanTransform | ∀ {A : Type u₁} {B : Type u₂} {C : Type u₃} {A' : Type u₄} {B' : Type u₅} {C' : Type u₆}
[inst : CategoryTheory.Category.{v₁, u₁} A] [inst_1 : CategoryTheory.Category.{v₂, u₂} B]
[inst_2 : CategoryTheory.Category.{v₃, u₃} C] {F : CategoryTheory.Functor A B} {G : CategoryTheory.Functor C B}
[inst_3 : CategoryTheor... | the coherence condition for the left square | true |
_private.Lean.Meta.Tactic.Grind.Action.0.Lean.Meta.Grind.Action.orElse.eq_1 | Lean.Meta.Tactic.Grind.Action | ∀ (x y : Lean.Meta.Grind.Action) (goal : Lean.Meta.Grind.Goal) (kna kp : Lean.Meta.Grind.ActionCont),
x.orElse y goal kna kp = x goal (fun goal => y goal kna kp) kp | null | true |
FinTopCat.of | Mathlib.Topology.Category.FinTopCat | (X : Type u) → [Fintype X] → [TopologicalSpace X] → FinTopCat | Construct a bundled `FinTopCat` from the underlying type and the appropriate typeclasses. | true |
Real.le_arcsin_iff_sin_le | Mathlib.Analysis.SpecialFunctions.Trigonometric.Inverse | ∀ {x y : ℝ}, x ∈ Set.Icc (-(Real.pi / 2)) (Real.pi / 2) → y ∈ Set.Icc (-1) 1 → (x ≤ Real.arcsin y ↔ Real.sin x ≤ y) | null | true |
CategoryTheory.Square.Hom | Mathlib.CategoryTheory.Square | {C : Type u} → [inst : CategoryTheory.Category.{v, u} C] → CategoryTheory.Square C → CategoryTheory.Square C → Type v | A morphism between two commutative squares consists of 4 morphisms
which extend these two squares into a commuting cube. | true |
_private.Mathlib.GroupTheory.ResiduallyFinite.0.Group.residuallyFinite_iff_forall_finiteIndexNormalSubgroup._simp_1_1 | Mathlib.GroupTheory.ResiduallyFinite | ∀ {G : Type u_1} [inst : Group G], Group.ResiduallyFinite G = (⨅ H, H.toSubgroup = ⊥) | null | false |
CentroidHom.centerToCentroidCenter._proof_6 | Mathlib.Algebra.Ring.CentroidHom | ∀ {α : Type u_1} [inst : NonUnitalNonAssocSemiring α] (z : ↥(NonUnitalSubsemiring.center α)) (b c : α),
↑z * (b * c) = ↑z * b * c | null | false |
Nat.Partition.mk | Mathlib.Combinatorics.Enumerative.Partition.Basic | {n : ℕ} → (parts : Multiset ℕ) → (∀ {i : ℕ}, i ∈ parts → 0 < i) → parts.sum = n → n.Partition | null | true |
Lean.Meta.Grind.AC.ACM.Context.mk.inj | Lean.Meta.Tactic.Grind.AC.Util | ∀ {opId opId_1 : ℕ}, { opId := opId } = { opId := opId_1 } → opId = opId_1 | null | true |
AlgebraicGeometry.Spec.fiberToSpecResidueFieldIso._proof_3 | Mathlib.AlgebraicGeometry.Fiber | ∀ (R : Type u_1) [inst : CommRing R] (p : PrimeSpectrum R), p.asIdeal.IsPrime | null | false |
spectrum.inv₀_mem | Mathlib.Algebra.Algebra.Spectrum.Basic | ∀ {R : Type u} {A : Type v} [inst : Semifield R] [inst_1 : Ring A] [inst_2 : Algebra R A] {r : R} {a : Aˣ},
r ∈ spectrum R ↑a⁻¹ → r⁻¹ ∈ spectrum R ↑a | **Alias** of the reverse direction of `spectrum.inv₀_mem_iff`. | true |
DirectLimit.instDivisionRing._proof_5 | Mathlib.Algebra.Colimit.DirectLimit | ∀ {ι : Type u_1} [inst : Preorder ι] {G : ι → Type u_2} {T : ⦃i j : ι⦄ → i ≤ j → Type u_3}
{f : (x x_1 : ι) → (h : x ≤ x_1) → T h} [inst_1 : (i j : ι) → (h : i ≤ j) → FunLike (T h) (G i) (G j)]
[inst_2 : DirectedSystem G fun x1 x2 x3 => ⇑(f x1 x2 x3)] [inst_3 : IsDirectedOrder ι] [inst_4 : Nonempty ι]
[inst_5 : (... | null | false |
SemidirectProduct.inl._proof_1 | Mathlib.GroupTheory.SemidirectProduct | ∀ {N : Type u_1} {G : Type u_2} [inst : Group N] [inst_1 : Group G] {φ : G →* MulAut N} (x y : N),
⟨x * y, 1⟩ = ⟨x, 1⟩ * ⟨y, 1⟩ | null | false |
Std.Iterators.Types.ULiftIterator.ctorIdx | Init.Data.Iterators.Combinators.Monadic.ULift | {α : Type u} →
{m : Type u → Type u'} →
{n : Type (max u v) → Type v'} →
{β : Type u} →
{lift : ⦃γ : Type u⦄ → m γ → Std.Iterators.ULiftT n γ} → Std.Iterators.Types.ULiftIterator α m n β lift → ℕ | null | false |
intervalIntegral.integral_mono_on | Mathlib.MeasureTheory.Integral.IntervalIntegral.Basic | ∀ {f g : ℝ → ℝ} {a b : ℝ} {μ : MeasureTheory.Measure ℝ},
a ≤ b →
IntervalIntegrable f μ a b →
IntervalIntegrable g μ a b →
(∀ x ∈ Set.Icc a b, f x ≤ g x) → ∫ (u : ℝ) in a..b, f u ∂μ ≤ ∫ (u : ℝ) in a..b, g u ∂μ | null | true |
Filter.comap_cofinite_le | Mathlib.Order.Filter.Cofinite | ∀ {α : Type u_2} {β : Type u_3} (f : α → β), Filter.comap f Filter.cofinite ≤ Filter.cofinite | null | true |
List.isEqv.match_1 | Init.Data.List.Basic | {α : Type u_1} →
(motive : List α → List α → (α → α → Bool) → Sort u_2) →
(x x_1 : List α) →
(x_2 : α → α → Bool) →
((x : α → α → Bool) → motive [] [] x) →
((a : α) → (as : List α) → (b : α) → (bs : List α) → (eqv : α → α → Bool) → motive (a :: as) (b :: bs) eqv) →
((x x_3 : Li... | null | false |
Geometry.SimplicialComplex.faces_bot | Mathlib.Analysis.Convex.SimplicialComplex.Basic | ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : Ring 𝕜] [inst_1 : PartialOrder 𝕜] [inst_2 : AddCommGroup E]
[inst_3 : Module 𝕜 E], ⊥.faces = ∅ | null | true |
Subring.instInfSet | Mathlib.Algebra.Ring.Subring.Basic | {R : Type u} → [inst : NonAssocRing R] → InfSet (Subring R) | null | true |
CategoryTheory.Functor.OneHypercoverDenseData.SieveStruct.i₀ | Mathlib.CategoryTheory.Sites.DenseSubsite.OneHypercoverDense | {C₀ : Type u₀} →
{C : Type u} →
[inst : CategoryTheory.Category.{v₀, u₀} C₀] →
[inst_1 : CategoryTheory.Category.{v, u} C] →
{F : CategoryTheory.Functor C₀ C} →
{J₀ : CategoryTheory.GrothendieckTopology C₀} →
{J : CategoryTheory.GrothendieckTopology C} →
{X : C} →... | the index of the intermediate object | true |
Lean.Lsp.instFromJsonLocation.fromJson | Lean.Data.Lsp.Basic | Lean.Json → Except String Lean.Lsp.Location | null | true |
Aesop.ForwardRuleMatch.foldHypsM | Aesop.Forward.Match | {M : Type u_1 → Type u_2} → {σ : Type u_1} → [Monad M] → (σ → Lean.FVarId → M σ) → σ → Aesop.ForwardRuleMatch → M σ | Fold over the hypotheses contained in a match. | true |
Lean.Meta.LazyDiscrTree.ImportData.casesOn | Lean.Meta.LazyDiscrTree | {motive : Lean.Meta.LazyDiscrTree.ImportData → Sort u} →
(t : Lean.Meta.LazyDiscrTree.ImportData) →
((errors : IO.Ref (Array Lean.Meta.LazyDiscrTree.ImportFailure)) → motive { errors := errors }) → motive t | null | false |
_private.Mathlib.Data.Option.NAry.0.Option.map_map₂_distrib_right._proof_1_1 | Mathlib.Data.Option.NAry | ∀ {α : Type u_3} {β : Type u_4} {γ : Type u_2} {δ : Type u_1} {f : α → β → γ} {a : Option α} {b : Option β}
{β' : Type u_5} {g : γ → δ} {f' : α → β' → δ} {g' : β → β'},
(∀ (a : α) (b : β), g (f a b) = f' a (g' b)) → Option.map g (Option.map₂ f a b) = Option.map₂ f' a (Option.map g' b) | null | false |
TemperedDistribution.fourierMultiplierCLM_toTemperedDistributionCLM_eq | Mathlib.Analysis.Distribution.FourierMultiplier | ∀ {E : Type u_3} {F : Type u_4} [inst : NormedAddCommGroup E] [inst_1 : NormedAddCommGroup F]
[inst_2 : InnerProductSpace ℝ E] [inst_3 : NormedSpace ℂ F] [inst_4 : FiniteDimensional ℝ E]
[inst_5 : MeasurableSpace E] [inst_6 : BorelSpace E] [CompleteSpace F] {g : E → ℂ},
Function.HasTemperateGrowth g →
∀ (f : ... | null | true |
addCommutator_centralizer_addCommutator_le_center | Mathlib.GroupTheory.Commutator.Basic | ∀ (G : Type u_1) [inst : AddGroup G],
⁅AddSubgroup.centralizer ↑(addCommutator G), AddSubgroup.centralizer ↑(addCommutator G)⁆ ≤ AddSubgroup.center G | null | true |
AlgEquiv.ofBijective_symm_apply_apply | Mathlib.Algebra.Algebra.Equiv | ∀ {R : Type uR} {A₁ : Type uA₁} {A₂ : Type uA₂} [inst : CommSemiring R] [inst_1 : Semiring A₁] [inst_2 : Semiring A₂]
[inst_3 : Algebra R A₁] [inst_4 : Algebra R A₂] (f : A₁ →ₐ[R] A₂) (hf : Function.Bijective ⇑f) (x : A₁),
(AlgEquiv.ofBijective f hf).symm (f x) = x | null | true |
Vector.emptyWithCapacity._proof_1 | Init.Data.Vector.Basic | ∀ {α : Type u_1} (capacity : ℕ), (Array.emptyWithCapacity capacity).size = 0 | null | false |
IsOneApply.rec | Mathlib.Algebra.Group.IsApply | {F : Type u_1} →
{α : Type u_2} →
{β : Type u_3} →
[inst : FunLike F α β] →
[inst_1 : One β] →
[inst_2 : One F] →
{motive : IsOneApply F α β → Sort u} →
((one_apply : ∀ (x : α), 1 x = 1) → motive ⋯) → (t : IsOneApply F α β) → motive t | null | false |
Set.Nonempty.pow | Mathlib.Algebra.Group.Pointwise.Set.Basic | ∀ {α : Type u_2} [inst : Monoid α] {s : Set α}, s.Nonempty → ∀ {n : ℕ}, (s ^ n).Nonempty | null | true |
Finsupp.mapRange.addMonoidHom_apply | Mathlib.Algebra.Group.Finsupp | ∀ {ι : Type u_1} {M : Type u_3} {N : Type u_4} [inst : AddCommMonoid M] [inst_1 : AddCommMonoid N] (f : M →+ N)
(g : ι →₀ M), (Finsupp.mapRange.addMonoidHom f) g = Finsupp.mapRange ⇑f ⋯ g | null | true |
Action.instIsClosedUnderSubobjectsFintypeCatIsContinuousFunObjFinite | Mathlib.CategoryTheory.Galois.ContAction | ∀ {G : Type u_4} [inst : Group G] [inst_1 : TopologicalSpace G] [IsTopologicalGroup G],
(Action.isContinuous FintypeCat G).IsClosedUnderSubobjects | null | true |
Int.map_add_toList_rcc' | Init.Data.Range.Polymorphic.IntLemmas | ∀ {m n k : ℤ}, List.map (fun x => k + x) (m...=n).toList = (k + m...=k + n).toList | null | true |
NonUnitalNonAssocCommSemiring.toNonUnitalNonAssocSemiring | Mathlib.Algebra.Ring.Defs | {α : Type u} → [self : NonUnitalNonAssocCommSemiring α] → NonUnitalNonAssocSemiring α | null | true |
Lean.Elab.DefKind.example.sizeOf_spec | Lean.Elab.DefView | sizeOf Lean.Elab.DefKind.example = 1 | null | true |
_private.Mathlib.Computability.TuringMachine.ToPartrec.0.Turing.PartrecToTM2.trList.match_1.eq_2 | Mathlib.Computability.TuringMachine.ToPartrec | ∀ (motive : List ℕ → Sort u_1) (n : ℕ) (ns : List ℕ) (h_1 : Unit → motive [])
(h_2 : (n : ℕ) → (ns : List ℕ) → motive (n :: ns)),
(match n :: ns with
| [] => h_1 ()
| n :: ns => h_2 n ns) =
h_2 n ns | null | true |
_private.Lean.Meta.Tactic.Simp.BuiltinSimprocs.BitVec.0.BitVec.reduceToNat._regBuiltin.BitVec.reduceToNat.declare_1._@.Lean.Meta.Tactic.Simp.BuiltinSimprocs.BitVec.124875926._hygCtx._hyg.22 | Lean.Meta.Tactic.Simp.BuiltinSimprocs.BitVec | IO Unit | null | false |
Lean.Grind.OrderedRing.pos_intCast_of_pos | Init.Grind.Ordered.Ring | ∀ {R : Type u} [inst : Lean.Grind.Ring R] [inst_1 : LE R] [inst_2 : LT R] [Std.LawfulOrderLT R]
[inst_4 : Std.IsPreorder R] [Lean.Grind.OrderedRing R] (a : ℤ), 0 < a → 0 < ↑a | null | true |
ZeroAtInftyContinuousMap.instNonUnitalNonAssocSemiring._proof_1 | Mathlib.Topology.ContinuousMap.ZeroAtInfty | ∀ {α : Type u_1} {β : Type u_2} [inst : TopologicalSpace α] [inst_1 : TopologicalSpace β]
[inst_2 : NonUnitalNonAssocSemiring β] [inst_3 : IsTopologicalSemiring β] (a b c : ZeroAtInftyContinuousMap α β),
a * (b + c) = a * b + a * c | null | false |
PUnit.lcm_eq | Mathlib.Algebra.GCDMonoid.PUnit | ∀ {x y : PUnit.{u_1 + 1}}, lcm x y = PUnit.unit | null | true |
Metric.thickening_subset_cthickening_of_le | Mathlib.Topology.MetricSpace.Thickening | ∀ {α : Type u} [inst : PseudoEMetricSpace α] {δ₁ δ₂ : ℝ},
δ₁ ≤ δ₂ → ∀ (E : Set α), Metric.thickening δ₁ E ⊆ Metric.cthickening δ₂ E | null | true |
Equiv.Perm.IsCycle.sameCycle | Mathlib.GroupTheory.Perm.Cycle.Basic | ∀ {α : Type u_2} {f : Equiv.Perm α} {x y : α}, f.IsCycle → f x ≠ x → f y ≠ y → f.SameCycle x y | null | true |
IsAdicComplete.StrictMono.liftRingHom._proof_4 | Mathlib.RingTheory.AdicCompletion.RingHom | ∀ {a : ℕ → ℕ}, StrictMono a → ∀ {m : ℕ}, a m ≤ a (m + 1) | null | false |
symmDiff_sup_left | Mathlib.Order.SymmDiff | ∀ {α : Type u_2} [inst : GeneralizedCoheytingAlgebra α] (a b : α), symmDiff a b ⊔ a = a ⊔ b | null | true |
MeasureTheory.SimpleFunc.instRing | Mathlib.MeasureTheory.Function.SimpleFunc | {α : Type u_1} → {β : Type u_2} → [inst : MeasurableSpace α] → [Ring β] → Ring (MeasureTheory.SimpleFunc α β) | null | true |
Rep.FiniteCyclicGroup.moduleCatChainComplex._proof_1 | Mathlib.RepresentationTheory.Homological.FiniteCyclic | ∀ {k G : Type u_2} [inst : CommRing k] [inst_1 : CommGroup G] [inst_2 : Fintype G] (A : Rep.{u_1, u_2, u_2} k G)
(g : G),
CategoryTheory.CategoryStruct.comp (ModuleCat.ofHom (Rep.Hom.hom A.norm.asHom).toLinearMap)
(ModuleCat.ofHom (Rep.Hom.hom (A.applyAsHom g - CategoryTheory.CategoryStruct.id A)).toLinearMap... | null | false |
_private.Mathlib.NumberTheory.JacobiSum.Basic.0.jacobiSum_trivial_trivial._simp_1_1 | Mathlib.NumberTheory.JacobiSum.Basic | ∀ {α : Type u_1} [inst : DecidableEq α] {s t : Finset α} {a : α}, (a ∈ s \ t) = (a ∈ s ∧ a ∉ t) | null | false |
_private.Mathlib.MeasureTheory.Measure.CharacteristicFunction.TaylorExpansion.0.MeasureTheory.iteratedFDeriv_charFun._simp_1_7 | Mathlib.MeasureTheory.Measure.CharacteristicFunction.TaylorExpansion | ∀ {α : Type u_2} [inst : Zero α] [inst_1 : OfNat α 2] [NeZero 2], (2 = 0) = False | null | false |
SymAlg.unsym_ne_zero_iff | Mathlib.Algebra.Symmetrized | ∀ {α : Type u_1} [inst : Zero α] (a : αˢʸᵐ), SymAlg.unsym a ≠ 0 ↔ a ≠ 0 | null | true |
UnitAddTorus.coe_symm_measurableEquivPiIoc_apply | Mathlib.Analysis.Fourier.AddCircleMulti | ∀ {ι : Type u_2} (b : ι → ℝ) (y : { x // ∀ (i : ι), x i ∈ Set.Ioc (b i) (b i + 1) }),
(UnitAddTorus.measurableEquivPiIoc b).symm y = fun i => ↑(↑y i) | null | true |
IsCoveringMap.monodromy | Mathlib.Topology.Homotopy.Lifting | {E : Type u_1} →
{X : Type u_2} →
[inst : TopologicalSpace E] →
[inst_1 : TopologicalSpace X] →
{p : E → X} → IsCoveringMap p → {x y : X} → Path.Homotopic.Quotient x y → ↑(p ⁻¹' {x}) → ↑(p ⁻¹' {y}) | The monodromy of a covering map `p : E → X`, which sends a lift of the starting point of a
path in `X` to the endpoint of the lifted path in `E`. It only depends on the homotopy class
of the path. | true |
Std.IterM.empty | Std.Data.Iterators.Producers.Monadic.Empty | (m : Type w → Type w') → (β : Type w) → Std.IterM m β | Returns an iterator that terminates immediately.
**Termination properties:**
* `Finite` instance: always
* `Productive` instance: always
| true |
_private.Lean.Meta.Tactic.Simp.Main.0.Lean.Meta.Simp.mainCore.match_1 | Lean.Meta.Tactic.Simp.Main | (motive : Lean.Meta.Simp.Result × Lean.Meta.Simp.State → Sort u_1) →
(x : Lean.Meta.Simp.Result × Lean.Meta.Simp.State) →
((r : Lean.Meta.Simp.Result) → (s : Lean.Meta.Simp.State) → motive (r, s)) → motive x | null | false |
LieModule.maxTrivLinearMapEquivLieModuleHom._proof_7 | Mathlib.Algebra.Lie.Abelian | ∀ {R : Type u_1} [inst : CommRing R], RingHomInvPair (RingHom.id R) (RingHom.id R) | null | false |
BitVec.getMsbD_srem | Init.Data.BitVec.Bitblast | ∀ {w i : ℕ} {x y : BitVec w},
(x.srem y).getMsbD i =
match x.msb, y.msb with
| false, false => (x % y).getMsbD i
| false, true => (x % -y).getMsbD i
| true, false => (-(-x % y)).getMsbD i
| true, true => (-(-x % -y)).getMsbD i | null | true |
LinearMap.proj_surjective | Mathlib.LinearAlgebra.Pi | ∀ {R : Type u} {ι : Type x} [inst : Semiring R] {φ : ι → Type i} [inst_1 : (i : ι) → AddCommMonoid (φ i)]
[inst_2 : (i : ι) → Module R (φ i)] (i : ι), Function.Surjective ⇑(LinearMap.proj i) | null | true |
_private.Mathlib.Analysis.Meromorphic.NormalForm.0.MeromorphicOn.toMeromorphicNFOn_eq_self_on_nhdsNE._simp_1_2 | Mathlib.Analysis.Meromorphic.NormalForm | ∀ {α : Type u} (s : Set α) (x : α), (x ∈ sᶜ) = (x ∉ s) | null | false |
FirstOrder.Language.ElementaryEmbedding.comp_apply | Mathlib.ModelTheory.ElementaryMaps | ∀ {L : FirstOrder.Language} {M : Type u_1} {N : Type u_2} {P : Type u_3} [inst : L.Structure M] [inst_1 : L.Structure N]
[inst_2 : L.Structure P] (g : L.ElementaryEmbedding N P) (f : L.ElementaryEmbedding M N) (x : M),
(g.comp f) x = g (f x) | null | true |
sizeOf_default | Init.SizeOf | ∀ {α : Sort u_1} (n : α), sizeOf n = 0 | null | true |
_private.Mathlib.NumberTheory.ModularForms.CongruenceSubgroups.0.CongruenceSubgroup.exists_Gamma_le_conj._simp_1_6 | Mathlib.NumberTheory.ModularForms.CongruenceSubgroups | ∀ {n : Type u_2} [inst : DecidableEq n] [inst_1 : Fintype n] {R : Type v} [inst_2 : CommRing R] (M : Matrix n n ℤ),
(M.map fun x => ↑x).det = ↑M.det | null | false |
_private.Mathlib.Order.Filter.Tendsto.0.Filter.Tendsto.if._simp_1_1 | Mathlib.Order.Filter.Tendsto | ∀ {α : Type u_1} {β : Type u_2} {f : α → β} {l₁ : Filter α} {l₂ : Filter β},
Filter.Tendsto f l₁ l₂ = ∀ s ∈ l₂, f ⁻¹' s ∈ l₁ | null | false |
Lean.Widget.MsgEmbed.brecOn_3.eq | Lean.Widget.InteractiveDiagnostic | ∀ {motive_1 : Lean.Widget.MsgEmbed → Sort u} {motive_2 : Lean.Widget.TaggedText Lean.Widget.MsgEmbed → Sort u}
{motive_3 :
Lean.Widget.StrictOrLazy (Array (Lean.Widget.TaggedText Lean.Widget.MsgEmbed))
(Lean.Server.WithRpcRef Lean.Widget.LazyTraceChildren) →
Sort u}
{motive_4 : Array (Lean.Widget.... | null | true |
CategoryTheory.TwoSquare.hComp' | Mathlib.CategoryTheory.GuitartExact.HorizontalComposition | {C₁ : Type u_1} →
{C₂ : Type u_2} →
{C₃ : Type u_3} →
{D₁ : Type u_4} →
{D₂ : Type u_5} →
{D₃ : Type u_6} →
[inst : CategoryTheory.Category.{v_1, u_1} C₁] →
[inst_1 : CategoryTheory.Category.{v_2, u_2} C₂] →
[inst_2 : CategoryTheory.Category.{v_3, ... | The horizontal composition of 2-squares. (Variant where we allow the replacement of
the horizontal compositions by isomorphic functors.) | true |
ProbabilityTheory.Kernel.instIsFiniteKernelWithDensityRnDeriv | Mathlib.Probability.Kernel.RadonNikodym | ∀ {α : Type u_1} {γ : Type u_2} {mα : MeasurableSpace α} {mγ : MeasurableSpace γ} {κ η : ProbabilityTheory.Kernel α γ}
[hαγ : MeasurableSpace.CountableOrCountablyGenerated α γ] [hκ : ProbabilityTheory.IsFiniteKernel κ]
[inst : ProbabilityTheory.IsFiniteKernel η], ProbabilityTheory.IsFiniteKernel (η.withDensity (κ.r... | null | true |
contDiffAt_fun_id | Mathlib.Analysis.Calculus.ContDiff.Basic | ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : NontriviallyNormedField 𝕜] [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {n : WithTop ℕ∞} {x : E}, ContDiffAt 𝕜 n (fun x => x) x | Eta-expanded form of `contDiffAt_id` | true |
TopCat.GlueData.recOn | Mathlib.Topology.Gluing | {motive : TopCat.GlueData → Sort u} →
(t : TopCat.GlueData) →
((toGlueData : CategoryTheory.GlueData TopCat) →
(f_open :
∀ (i j : toGlueData.J),
Topology.IsOpenEmbedding ⇑(CategoryTheory.ConcreteCategory.hom (toGlueData.f i j))) →
motive { toGlueData := toGlueData, f_op... | null | false |
NonUnitalSubringClass.toNonUnitalNonAssocRing._proof_2 | Mathlib.RingTheory.NonUnitalSubring.Defs | ∀ {R : Type u_1} {S : Type u_2} [inst : NonUnitalNonAssocRing R] [inst_1 : SetLike S R]
[hSR : NonUnitalSubringClass S R] (s : S) (a b c : ↥s), (a + b) * c = a * c + b * c | null | false |
_private.Mathlib.Combinatorics.Additive.FreimanHom.0.isMulFreimanIso_two._simp_1_1 | Mathlib.Combinatorics.Additive.FreimanHom | ∀ {α : Type u_1} {s : Multiset α}, (s.card = 2) = ∃ x y, s = {x, y} | null | false |
ModuleCat.instModuleCarrierMkOfSMul'._proof_3 | Mathlib.Algebra.Category.ModuleCat.Basic | ∀ {R : Type u_2} [inst : Ring R] {A : AddCommGrpCat} (φ : R →+* CategoryTheory.End A) (a : R), a • 0 = 0 | null | false |
GrpTypeEquivalenceGrp.functor | Mathlib.CategoryTheory.Monoidal.Internal.Types.Grp | CategoryTheory.Functor (CategoryTheory.Grp (Type u)) GrpCat | Converting a group object in `Type u` into a group. | true |
Aesop.RuleTac.ofTacticSyntax | Aesop.RuleTac.Basic | (Aesop.RuleTacInput → Lean.MetaM Lean.Syntax.Tactic) → Aesop.RuleTac | null | true |
ZMod.val.eq_2 | Mathlib.Data.ZMod.Basic | ∀ (n : ℕ), ZMod.val = Fin.val | null | true |
Matrix.SpecialLinearGroup.transvection_coeff_zero | Mathlib.LinearAlgebra.Matrix.SpecialLinearGroup | ∀ {ι : Type u_1} {F : Type u_2} [inst : DecidableEq ι] [inst_1 : Fintype ι] [inst_2 : CommRing F] {i j : ι}
(hij : i ≠ j), Matrix.SpecialLinearGroup.transvection hij 0 = 1 | null | true |
MeasureTheory.Integrable.aefinStronglyMeasurable | Mathlib.MeasureTheory.Function.StronglyMeasurable.Lp | ∀ {α : Type u_1} {G : Type u_2} {m0 : MeasurableSpace α} {μ : MeasureTheory.Measure α} [inst : NormedAddCommGroup G]
{f : α → G}, MeasureTheory.Integrable f μ → MeasureTheory.AEFinStronglyMeasurable f μ | null | true |
Subalgebra.map_topologicalClosure_le | Mathlib.Topology.Algebra.Algebra | ∀ {R : Type u_1} [inst : CommSemiring R] {A : Type u_2} [inst_1 : Semiring A] [inst_2 : TopologicalSpace A]
{B : Type u_3} [inst_3 : Semiring B] [inst_4 : TopologicalSpace B] [inst_5 : Algebra R A] [inst_6 : Algebra R B]
[inst_7 : IsSemitopologicalSemiring A] [inst_8 : IsSemitopologicalSemiring B] (f : A →A[R] B) (... | Under a continuous algebra map, the image of the `TopologicalClosure` of a subalgebra is
contained in the `TopologicalClosure` of its image. | true |
Int.gcd_dvd_gcd_mul_right_right | Init.Data.Int.Gcd | ∀ (a b c : ℤ), a.gcd b ∣ a.gcd (b * c) | null | true |
Plausible.Shrinkable.mk._flat_ctor | Plausible.Shrinkable | {α : Type u} → (α → List α) → Plausible.Shrinkable α | null | false |
MeasureTheory.JordanDecomposition.instSMul | Mathlib.MeasureTheory.VectorMeasure.Decomposition.Jordan | {α : Type u_1} → [inst : MeasurableSpace α] → SMul NNReal (MeasureTheory.JordanDecomposition α) | null | true |
Finset.sum_Ioc_by_parts | Mathlib.Algebra.BigOperators.Module | ∀ {R : Type u_1} {M : Type u_2} [inst : Ring R] [inst_1 : AddCommGroup M] [inst_2 : Module R M] (f : ℕ → R) (g : ℕ → M)
{m n : ℕ},
m < n →
∑ i ∈ Finset.Ioc m n, f i • g i =
f n • ∑ i ∈ Finset.range (n + 1), g i - f (m + 1) • ∑ i ∈ Finset.range (m + 1), g i -
∑ i ∈ Finset.Ioc m (n - 1), (f (i + 1) ... | null | true |
CompleteLinearOrder.toCompletelyDistribLattice | Mathlib.Order.CompleteBooleanAlgebra | {α : Type u} → [CompleteLinearOrder α] → CompletelyDistribLattice α | null | true |
_private.Init.Data.Array.Lemmas.0.Array.all_eq_true_iff_forall_mem._simp_1_3 | Init.Data.Array.Lemmas | ∀ {α : Type u} {a : α} {as : Array α}, (a ∈ as) = (a ∈ as.toList) | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.