name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
Lean.Elab.Term.TacticMVarKind.autoParam.elim | Lean.Elab.Term.TermElabM | {motive : Lean.Elab.Term.TacticMVarKind → Sort u} →
(t : Lean.Elab.Term.TacticMVarKind) →
t.ctorIdx = 1 → ((argName : Lean.Name) → motive (Lean.Elab.Term.TacticMVarKind.autoParam argName)) → motive t | null | false |
Fin.rev_anti | Mathlib.Order.Fin.Basic | ∀ {n : ℕ}, Antitone Fin.rev | null | true |
_private.Mathlib.Data.EReal.Operations.0.EReal.le_sub_iff_add_le._simp_1_3 | Mathlib.Data.EReal.Operations | ∀ {α : Type u} [inst : PartialOrder α] [inst_1 : OrderBot α] {a : α}, (a ≤ ⊥) = (a = ⊥) | null | false |
Lean.Compiler.LCNF.Code.oset.noConfusion | Lean.Compiler.LCNF.Basic | {pu : Lean.Compiler.LCNF.Purity} →
{P : Sort u} →
{fvarId : Lean.FVarId} →
{i : ℕ} →
{y : Lean.Compiler.LCNF.Arg pu} →
{k : Lean.Compiler.LCNF.Code pu} →
{h : autoParam (pu = Lean.Compiler.LCNF.Purity.impure) Lean.Compiler.LCNF.Alt._auto_7} →
{fvarId' : Lean.FVarI... | null | false |
Lean.Meta.Grind.Arith.traceModel | Lean.Meta.Tactic.Grind.Arith.ModelUtil | Lean.Name → Array (Lean.Expr × ℚ) → Lean.MetaM Unit | If the given trace class is enabled, trace the model using the class. | true |
SSet.instIsStableUnderTransfiniteCompositionAnodyneExtensions._proof_1 | Mathlib.AlgebraicTopology.SimplicialSet.AnodyneExtensions.Basic | SSet.anodyneExtensions.IsStableUnderTransfiniteComposition | null | false |
Finset.max_abv_sum_one_le | Mathlib.NumberTheory.Height.Basic | ∀ {R : Type u_1} {S : Type u_2} [inst : Semiring R] [inst_1 : CommSemiring S] [inst_2 : LinearOrder S] [IsOrderedRing S]
[CharZero S] (v : AbsoluteValue R S) {ι : Type u_3} {s : Finset ι},
s.Nonempty → ∀ (x : ι → R), max (v (∑ i ∈ s, x i)) 1 ≤ ↑s.card * ∏ i ∈ s, max (v (x i)) 1 | The "local" version of the height bound for arbitrary sums for general (possibly archimedean)
absolute values. | true |
_private.Mathlib.CategoryTheory.Monoidal.Multifunctor.0.CategoryTheory.MonoidalCategory.curriedTensorPreFunctor._simp_1 | Mathlib.CategoryTheory.Monoidal.Multifunctor | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.MonoidalCategory C] (X : C)
{Y₁ Y₂ : C} (f : Y₁ ⟶ Y₂),
CategoryTheory.MonoidalCategoryStruct.whiskerLeft X f =
CategoryTheory.MonoidalCategoryStruct.tensorHom (CategoryTheory.CategoryStruct.id X) f | null | false |
MonotoneOn.convex_le | Mathlib.Analysis.Convex.Basic | ∀ {𝕜 : Type u_1} {E : Type u_2} {β : Type u_4} [inst : Semiring 𝕜] [inst_1 : PartialOrder 𝕜] [inst_2 : AddCommMonoid E]
[inst_3 : LinearOrder E] [IsOrderedAddMonoid E] [inst_5 : PartialOrder β] [inst_6 : Module 𝕜 E] [PosSMulMono 𝕜 E]
{s : Set E} {f : E → β}, MonotoneOn f s → Convex 𝕜 s → ∀ (r : β), Convex 𝕜 ... | null | true |
Submodule.equivOpposite._proof_5 | Mathlib.Algebra.Algebra.Operations | ∀ {R : Type u_2} [inst : CommSemiring R] {A : Type u_1} [inst_1 : Semiring A] [inst_2 : Algebra R A]
(x : (Submodule R A)ᵐᵒᵖ),
MulOpposite.op
(Submodule.comap (↑(MulOpposite.opLinearEquiv R))
(Submodule.comap (↑(MulOpposite.opLinearEquiv R).symm) (MulOpposite.unop x))) =
x | null | false |
CategoryTheory.CommSq.rightAdjointLiftStructEquiv | Mathlib.CategoryTheory.LiftingProperties.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] →
{G : CategoryTheory.Functor C D} →
{F : CategoryTheory.Functor D C} →
{A B : C} →
{X Y : D} →
{i : A ⟶ B} →
... | The liftings of a commutative are in bijection with the liftings of its (right)
adjoint square. | true |
CategoryTheory.Limits.limitObjIsoLimitCompEvaluation_inv_π_app | Mathlib.CategoryTheory.Limits.FunctorCategory.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {J : Type u₁} [inst_1 : CategoryTheory.Category.{v₁, u₁} J]
{K : Type u₂} [inst_2 : CategoryTheory.Category.{v₂, u₂} K] [inst_3 : CategoryTheory.Limits.HasLimitsOfShape J C]
(F : CategoryTheory.Functor J (CategoryTheory.Functor K C)) (j : J) (k : K),
Catego... | null | true |
MeasureTheory.setLIntegral_measure_zero | Mathlib.MeasureTheory.Integral.Lebesgue.Basic | ∀ {α : Type u_1} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} (s : Set α) (f : α → ENNReal),
μ s = 0 → ∫⁻ (x : α) in s, f x ∂μ = 0 | null | true |
Std.ExtTreeMap.getKeyGE? | Std.Data.ExtTreeMap.Basic | {α : Type u} → {β : Type v} → {cmp : α → α → Ordering} → [Std.TransCmp cmp] → Std.ExtTreeMap α β cmp → α → Option α | Tries to retrieve the smallest key that is greater than or equal to the
given key, returning `none` if no such key exists.
| true |
Lean.Compiler.LCNF.Simp.Config.casesOn | Lean.Compiler.LCNF.Simp.Config | {motive : Lean.Compiler.LCNF.Simp.Config → Sort u} →
(t : Lean.Compiler.LCNF.Simp.Config) →
((etaPoly inlinePartial implementedBy inlineDefs : Bool) →
motive
{ etaPoly := etaPoly, inlinePartial := inlinePartial, implementedBy := implementedBy,
inlineDefs := inlineDefs }) →
moti... | null | false |
ContinuousMap.HomotopyEquiv.prodCongr | Mathlib.Topology.Homotopy.Equiv | {X : Type u} →
{Y : Type v} →
{Z : Type w} →
{Z' : Type x} →
[inst : TopologicalSpace X] →
[inst_1 : TopologicalSpace Y] →
[inst_2 : TopologicalSpace Z] →
[inst_3 : TopologicalSpace Z'] →
ContinuousMap.HomotopyEquiv X Y →
Continuo... | If `X` is homotopy equivalent to `Y` and `Z` is homotopy equivalent to `Z'`, then `X × Z` is
homotopy equivalent to `Z × Z'`. | true |
_private.Lean.Meta.Tactic.Simp.BuiltinSimprocs.SInt.0.Int32.reduceToInt._regBuiltin.Int32.reduceToInt.declare_1._@.Lean.Meta.Tactic.Simp.BuiltinSimprocs.SInt.3685453738._hygCtx._hyg.422 | Lean.Meta.Tactic.Simp.BuiltinSimprocs.SInt | IO Unit | null | false |
Std.WP.Spec.adaptExcept_EStateM | Std.WP.Triple.SpecLemmas | ∀ {ε ε' σ α : Type} (f : ε → ε') (x : EStateM ε σ α) (post : α → σ → Prop) (epost : ε' → σ → Prop),
⦃ Std.WP.wp x post fun e => epost (f e) ⦄ EStateM.adaptExcept f x ⦃ post; epost ⦄ | null | true |
TopologicalSpace.UpgradedIsCompletelyMetrizableSpace.edist._inherited_default | Mathlib.Topology.Metrizable.CompletelyMetrizable | {X : Type u_3} →
(dist : X → X → ℝ) →
(∀ (x : X), dist x x = 0) →
(∀ (x y : X), dist x y = dist y x) → (∀ (x y z : X), dist x z ≤ dist x y + dist y z) → X → X → ENNReal | null | false |
_private.Mathlib.GroupTheory.Perm.Fin.0.Fin.cycleIcc_of_le_of_le._proof_1_17 | Mathlib.GroupTheory.Perm.Fin | ∀ {n : ℕ} {j k : Fin n}, k ≤ j → ¬k = j → ↑k + 1 < n | null | false |
SimpleGraph.Walk.IsPath.bypass_eq_self | Mathlib.Combinatorics.SimpleGraph.Paths | ∀ {V : Type u} {G : SimpleGraph V} {u v : V} [inst : DecidableEq V] {p : G.Walk u v}, p.IsPath → p.bypass = p | null | true |
Set.sups_assoc | Mathlib.Data.Set.Sups | ∀ {α : Type u_2} [inst : SemilatticeSup α] (s t u : Set α), s ⊻ t ⊻ u = s ⊻ (t ⊻ u) | null | true |
natCast_eq_one | Mathlib.Algebra.Order.Kleene | ∀ {α : Type u_1} [inst : IdemSemiring α] {n : ℕ}, n ≠ 0 → ↑n = 1 | null | true |
CategoryTheory.Comma.unopFunctorCompFst | Mathlib.CategoryTheory.Comma.Basic | {A : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} A] →
{B : Type u₂} →
[inst_1 : CategoryTheory.Category.{v₂, u₂} B] →
{T : Type u₃} →
[inst_2 : CategoryTheory.Category.{v₃, u₃} T] →
(L : CategoryTheory.Functor A T) →
(R : CategoryTheory.Functor B T) →
... | Composing `unopFunctor L R` with `(fst L R).op` is isomorphic to `snd L.op R.op`. | true |
Equiv.Set.powerset._proof_4 | Mathlib.Logic.Equiv.Set | ∀ {α : Type u_1} (S : Set α) (x : ↑(𝒫 S)), (fun x => ⟨Subtype.val '' x, ⋯⟩) ((fun x => Subtype.val ⁻¹' ↑x) x) = x | null | false |
Filter.image_mem_map_iff | Mathlib.Order.Filter.Map | ∀ {α : Type u_1} {β : Type u_2} {f : Filter α} {m : α → β} {s : Set α},
Function.Injective m → (m '' s ∈ Filter.map m f ↔ s ∈ f) | null | true |
Std.Time.Hour.Offset.ofDays | Std.Time.Date.Basic | Std.Time.Day.Offset → Std.Time.Hour.Offset | Convert `Day.Offset` into `Hour.Offset`.
| true |
Polynomial.coeff_mul_add_eq_of_natDegree_le | Mathlib.Algebra.Polynomial.Degree.Operations | ∀ {R : Type u} [inst : Semiring R] {df dg : ℕ} {f g : Polynomial R},
f.natDegree ≤ df → g.natDegree ≤ dg → (f * g).coeff (df + dg) = f.coeff df * g.coeff dg | null | true |
_private.Std.Do.Triple.SpecLemmas.0.Std.Do.Spec.get_EStateM._simp_1_1 | Std.Do.Triple.SpecLemmas | ∀ {m : Type u → Type v} {ps : Std.Do.PostShape} [inst : Std.Do.WP m ps] {α : Type u} {x : m α} {P : Std.Do.Assertion ps}
{Q : Std.Do.PostCond α ps}, ⦃P⦄ x ⦃Q⦄ = (P ⊢ₛ (Std.Do.wp x).apply Q) | null | false |
_private.Lean.Meta.Tactic.Simp.BuiltinSimprocs.BitVec.0.BitVec.reduceReplicate._regBuiltin.BitVec.reduceReplicate.declare_1._@.Lean.Meta.Tactic.Simp.BuiltinSimprocs.BitVec.1900396974._hygCtx._hyg.23 | Lean.Meta.Tactic.Simp.BuiltinSimprocs.BitVec | IO Unit | null | false |
Units.Simps.val_inv.eq_1 | Mathlib.Algebra.Group.Units.Defs | ∀ {α : Type u} [inst : Monoid α] (u : αˣ), Units.Simps.val_inv u = ↑u⁻¹ | null | true |
Int8.toInt16_xor | Init.Data.SInt.Bitwise | ∀ (a b : Int8), (a ^^^ b).toInt16 = a.toInt16 ^^^ b.toInt16 | null | true |
_private.Init.Data.Array.Erase.0.Array.eraseIdx_set._proof_3 | Init.Data.Array.Erase | ∀ {α : Type u_1} {xs : Array α} {i : ℕ} {a : α} {hi : i < xs.size} {j : ℕ}, j < i → ¬i - 1 < xs.size - 1 → False | null | false |
Nat.add_div | Init.Data.Nat.Div.Lemmas | ∀ {a b c : ℕ}, 0 < c → (a + b) / c = a / c + b / c + if c ≤ a % c + b % c then 1 else 0 | null | true |
CategoryTheory.Limits.binaryFanZeroRightIsLimit._proof_1 | Mathlib.CategoryTheory.Limits.Constructions.ZeroObjects | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Limits.HasZeroObject C] (X : C)
(s : CategoryTheory.Limits.BinaryFan X 0),
CategoryTheory.CategoryStruct.comp s.fst (CategoryTheory.CategoryStruct.id X) = s.fst | null | false |
Prod.instAddCommGroupWithOne._proof_6 | Mathlib.Algebra.Ring.Prod | ∀ {R : Type u_1} {S : Type u_2} [inst : AddCommGroupWithOne R] [inst_1 : AddCommGroupWithOne S] (a b : R × S),
a + b = b + a | null | false |
AddMonoidAlgebra.toRingHom_mapRingEquiv | Mathlib.Algebra.MonoidAlgebra.MapDomain | ∀ {R : Type u_3} {S : Type u_4} {M : Type u_6} [inst : Semiring R] [inst_1 : Semiring S] [inst_2 : AddMonoid M]
(e : R ≃+* S), (AddMonoidAlgebra.mapRingEquiv M e).toRingHom = AddMonoidAlgebra.mapRingHom M ↑e | null | true |
Iff.mpr | Init.Core | ∀ {a b : Prop}, (a ↔ b) → b → a | Modus ponens for if and only if, reversed. If `a ↔ b` and `b`, then `a`. | true |
Relation.transGen_le_reflTransGen | Mathlib.Logic.Relation | ∀ {α : Type u_1} {r : α → α → Prop}, Relation.TransGen r ≤ Relation.ReflTransGen r | null | true |
Matrix.kroneckerMap_zero_left | Mathlib.LinearAlgebra.Matrix.Kronecker | ∀ {α : Type u_3} {β : Type u_5} {γ : Type u_7} {l : Type u_9} {m : Type u_10} {n : Type u_11} {p : Type u_12}
[inst : Zero α] [inst_1 : Zero γ] (f : α → β → γ),
(∀ (b : β), f 0 b = 0) → ∀ (B : Matrix n p β), Matrix.kroneckerMap f 0 B = 0 | null | true |
_private.Lean.Level.0.Lean.Level.isExplicitSubsumedAux | Lean.Level | Array Lean.Level → ℕ → ℕ → Bool | Auxiliary function for `normalize`.
`maxExplicit` is the maximum explicit universe level at `lvls`.
Return true if it finds a level with offset ≥ maxExplicit.
`i` starts at the first non explicit level.
It assumes `lvls` has been sorted using `normLt`.
| true |
AlgebraicGeometry.LocallyRingedSpace.IsOpenImmersion.ofRestrict | Mathlib.Geometry.RingedSpace.OpenImmersion | ∀ {X : TopCat} (Y : AlgebraicGeometry.LocallyRingedSpace) {f : X ⟶ ↑Y.toPresheafedSpace}
(hf : Topology.IsOpenEmbedding ⇑(CategoryTheory.ConcreteCategory.hom f)),
AlgebraicGeometry.LocallyRingedSpace.IsOpenImmersion (Y.ofRestrict hf) | null | true |
_private.Batteries.Recycling.RBTree.Alter.0.RBTree.RBNode.Path.Ordered.match_1.splitter | Batteries.Recycling.RBTree.Alter | {α : Type u_1} →
(motive : RBTree.RBNode.Path α → Sort u_2) →
(x : RBTree.RBNode.Path α) →
(Unit → motive RBTree.RBNode.Path.root) →
((c : RBTree.RBColor) →
(parent : RBTree.RBNode.Path α) →
(x : α) → (b : RBTree.RBNode α) → motive (RBTree.RBNode.Path.left c parent x b)) →
... | null | true |
DividedPowers.coincide_on_smul | Mathlib.RingTheory.DividedPowers.Basic | ∀ {A : Type u_1} [inst : CommSemiring A] {I : Ideal A} {a : A} (hI : DividedPowers I) {J : Ideal A}
(hJ : DividedPowers J) {n : ℕ}, a ∈ I • J → hI.dpow n a = hJ.dpow n a | If J is another ideal of A with divided powers,
then the divided powers of I and J coincide on I • J
[Berthelot-1974], 1.6.1 (ii) | true |
ContRepresentation.coind₁.congr_simp | Mathlib.RepresentationTheory.Continuous.Basic | ∀ {R : Type u_1} {V : Type u_3} [inst : Ring R] [inst_1 : AddCommGroup V] [inst_2 : TopologicalSpace V]
[inst_3 : IsTopologicalAddGroup V] [inst_4 : Module R V] {G : Type u_7} [inst_5 : Group G]
[inst_6 : TopologicalSpace G] [inst_7 : TopologicalSpace R] [inst_8 : ContinuousSMul R V]
[inst_9 : IsTopologicalGroup ... | null | true |
List.filterMapM.loop._sunfold | Init.Data.List.Control | {m : Type u → Type v} → [Monad m] → {α : Type w} → {β : Type u} → (α → m (Option β)) → List α → List β → m (List β) | null | false |
List.MergeSort.Internal.splitRevInTwo_fst._proof_1 | Init.Data.List.Sort.Impl | ∀ {α : Type u_1} {n : ℕ} (l : { l // l.length = n }),
(↑(List.MergeSort.Internal.splitInTwo l).1).reverse.length = (n + 1) / 2 | null | false |
Lean.Meta.Sym.Offset.num.elim | Lean.Meta.Sym.Offset | {motive : Lean.Meta.Sym.Offset → Sort u} →
(t : Lean.Meta.Sym.Offset) → t.ctorIdx = 0 → ((k : ℕ) → motive (Lean.Meta.Sym.Offset.num k)) → motive t | null | false |
CategoryTheory.Subgroupoid.instTop._proof_1 | Mathlib.CategoryTheory.Groupoid.Subgroupoid | ∀ {C : Type u_2} [inst : CategoryTheory.Groupoid C] {c d : C} {p : c ⟶ d},
p ∈ Set.univ → CategoryTheory.Groupoid.inv p ∈ Set.univ | null | false |
CochainComplex.HomComplex.Cocycle.fromSingleMk_smul._proof_1 | Mathlib.Algebra.Homology.HomotopyCategory.HomComplexSingle | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Preadditive C] {X : C}
{K : CochainComplex C ℤ} {R : Type u_3} [inst_2 : Ring R] [inst_3 : CategoryTheory.Linear R C] (r : R) {q : ℤ}
(f : X ⟶ K.X q) (q' : ℤ),
CategoryTheory.CategoryStruct.comp f (K.d q q') = 0 → CategoryTheo... | null | false |
differentiableWithinAt_comp_sub | Mathlib.Analysis.Calculus.FDeriv.Add | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {F : Type u_3} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {f : E → F}
{x : E} {s : Set E} (a : E),
DifferentiableWithinAt 𝕜 (fun x => f (x - a)) s x ↔ DifferentiableWi... | null | true |
CochainComplex.ConnectData.d_negSucc | Mathlib.Algebra.Homology.Embedding.Connect | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{K : ChainComplex C ℕ} {L : CochainComplex C ℕ} (h : CochainComplex.ConnectData K L) (n m : ℕ),
h.d (Int.negSucc n) (Int.negSucc m) = K.d n m | null | true |
Std.Http.Header.TransferEncoding.noConfusion | Std.Http.Data.Headers.Basic | {P : Sort u} →
{t t' : Std.Http.Header.TransferEncoding} → t = t' → Std.Http.Header.TransferEncoding.noConfusionType P t t' | null | false |
Lean.Meta.Grind.SplitDiagInfo.c | Lean.Meta.Tactic.Grind.Types | Lean.Meta.Grind.SplitDiagInfo → Lean.Expr | null | true |
Matrix.frobenius_norm_replicateRow | Mathlib.Analysis.Matrix.Normed | ∀ {m : Type u_3} {α : Type u_5} {ι : Type u_7} [inst : Fintype m] [inst_1 : Unique ι]
[inst_2 : SeminormedAddCommGroup α] (v : m → α), ‖Matrix.replicateRow ι v‖ = ‖WithLp.toLp 2 v‖ | null | true |
AlgebraicGeometry.Scheme.Pullback.range_diagonal_subset_diagonalCoverDiagonalRange | Mathlib.AlgebraicGeometry.Morphisms.Separated | ∀ {X Y : AlgebraicGeometry.Scheme} (f : X ⟶ Y) (𝒰 : Y.OpenCover)
(𝒱 : (i : 𝒰.I₀) → (CategoryTheory.Limits.pullback f (𝒰.f i)).OpenCover),
Set.range ⇑(CategoryTheory.Limits.pullback.diagonal f) ⊆
↑(AlgebraicGeometry.Scheme.Pullback.diagonalCoverDiagonalRange f 𝒰 𝒱) | null | true |
NonUnitalAlgebra.map_top | Mathlib.Algebra.Algebra.NonUnitalSubalgebra | ∀ {R : Type u} {A : Type v} {B : Type w} [inst : CommSemiring R] [inst_1 : NonUnitalNonAssocSemiring A]
[inst_2 : Module R A] [inst_3 : NonUnitalNonAssocSemiring B] [inst_4 : Module R B] [inst_5 : IsScalarTower R A A]
[inst_6 : SMulCommClass R A A] (f : A →ₙₐ[R] B), NonUnitalSubalgebra.map f ⊤ = f.range | null | true |
_private.Lean.Server.Requests.0.Lean.Server.chainLspRequestHandler.match_1 | Lean.Server.Requests | (motive : Option Lean.Json → Sort u_1) →
(x : Option Lean.Json) → (Unit → motive none) → ((response : Lean.Json) → motive (some response)) → motive x | null | false |
Lean.Elab.Tactic.MkSimpContextResult | Lean.Elab.Tactic.Simp | Type | null | true |
Lean.Linter.LinterOptions._sizeOf_1 | Lean.Linter.Init | Lean.Linter.LinterOptions → ℕ | null | false |
AddGroupSeminorm.rec | Mathlib.Analysis.Normed.Group.Seminorm | {G : Type u_6} →
[inst : AddGroup G] →
{motive : AddGroupSeminorm G → Sort u} →
((toFun : G → ℝ) →
(map_zero' : toFun 0 = 0) →
(add_le' : ∀ (r s : G), toFun (r + s) ≤ toFun r + toFun s) →
(neg' : ∀ (r : G), toFun (-r) = toFun r) →
motive { toFun := toFun, ... | null | false |
_private.Mathlib.Combinatorics.SimpleGraph.Triangle.Basic.0.SimpleGraph.edgeDisjointTriangles_iff_mem_sym2_subsingleton._simp_1_1 | Mathlib.Combinatorics.SimpleGraph.Triangle.Basic | ∀ {α : Type u_1} {s : Finset α} {m : Sym2 α}, (m ∈ s.sym2) = ∀ a ∈ m, a ∈ s | null | false |
Matroid.IsBasis.cardinalMk_le_cRk | Mathlib.Combinatorics.Matroid.Rank.Cardinal | ∀ {α : Type u} {M : Matroid α} {I X : Set α}, M.IsBasis I X → Cardinal.mk ↑I ≤ M.cRk X | null | true |
Std.Rco.forIn'_eq_forIn'_toArray | Init.Data.Range.Polymorphic.Lemmas | ∀ {α : Type u} {r : Std.Rco α} [inst : LE α] [inst_1 : LT α] [inst_2 : DecidableLT α]
[inst_3 : Std.PRange.UpwardEnumerable α] [inst_4 : Std.PRange.LawfulUpwardEnumerableLE α]
[inst_5 : Std.PRange.LawfulUpwardEnumerableLT α] [inst_6 : Std.Rxo.IsAlwaysFinite α]
[inst_7 : Std.PRange.LawfulUpwardEnumerable α] {γ : T... | null | true |
Turing.PartrecToTM2.Λ'.instDecidableEq._proof_38 | Mathlib.Computability.TuringMachine.ToPartrec | ∀ (f : Option Turing.PartrecToTM2.Γ' → Turing.PartrecToTM2.Λ') (p : Turing.PartrecToTM2.Γ' → Bool)
(k₁ k₂ : Turing.PartrecToTM2.K') (q : Turing.PartrecToTM2.Λ'),
¬Turing.PartrecToTM2.Λ'.read f = Turing.PartrecToTM2.Λ'.move p k₁ k₂ q | null | false |
natCard_units_lt | Mathlib.RingTheory.Fintype | ∀ (M₀ : Type u_1) [inst : MonoidWithZero M₀] [Nontrivial M₀] [Finite M₀], Nat.card M₀ˣ < Nat.card M₀ | null | true |
_private.Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.ShiftLeft.0.Std.Tactic.BVDecide.BVExpr.bitblast.denote_blastShiftLeft._proof_1_6 | Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.ShiftLeft | ∀ {w0 : ℕ} (idx n : ℕ), ¬0 ≤ n - 1 → False | null | false |
Fin.val_fin_le | Mathlib.Data.Fin.Basic | ∀ {n : ℕ} {a b : Fin n}, ↑a ≤ ↑b ↔ a ≤ b | `a ≤ b` as natural numbers if and only if `a ≤ b` in `Fin n`. | true |
Submodule.coe_matrix | Mathlib.Data.Matrix.Basic | ∀ {m : Type u_2} {n : Type u_3} {R : Type u_11} {M : Type u_12} [inst : Semiring R] [inst_1 : AddCommMonoid M]
[inst_2 : Module R M] (S : Submodule R M), ↑S.matrix = (↑S).matrix | null | true |
le_of_inf_eq | Mathlib.Order.Defs.Lattice | ∀ {α : Type u} [inst : SemilatticeInf α] {a b : α}, a ⊓ b = a → a ≤ b | **Alias** of the forward direction of `inf_eq_left`. | true |
_private.Mathlib.NumberTheory.Transcendental.Liouville.Measure.0.volume_iUnion_setOfPred_liouvilleWith._simp_1_3 | Mathlib.NumberTheory.Transcendental.Liouville.Measure | ∀ {b a : Prop}, (a ∧ b) = ∃ (_ : a), b | null | false |
Algebra.TensorProduct.basisAux._proof_4 | Mathlib.RingTheory.TensorProduct.Free | ∀ {R : Type u_1} (A : Type u_2) [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A],
SMulCommClass R R A | null | false |
Lean.findParentProjStruct? | Lean.Structure | Lean.Environment → Lean.Name → Lean.Name → Option Lean.Name | Given a structure `structName` and a parent projection name `projName` (e.g. `toParentStructName`),
returns the corresponding parent structure name.
The parent projection name is a single-component name.
Note: this relies on the fact that projection names are checked to be consistent across all parents.
| true |
_private.Mathlib.Basic.ENNReal.Basic.0.ENNReal.iInter_Ici_coe_nat._simp_1_2 | Mathlib.Basic.ENNReal.Basic | ∀ {β : Type u_2} {ι : Sort u_4} (s : ι → Set β), ⋂ i, (s i)ᶜ = (⋃ i, s i)ᶜ | null | false |
CategoryTheory.Limits.WidePullbackShape.struct._proof_2 | Mathlib.CategoryTheory.Limits.Shapes.WidePullbacks | ∀ {J : Type u_1} {Z : CategoryTheory.Limits.WidePullbackShape J}, Z = none → none = Z | null | false |
Module.Flat.tensorSubmoduleAlgebraEquiv._proof_1 | Mathlib.RingTheory.PicardGroup | ∀ {R : Type u_1} {A : Type u_2} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A],
SMulCommClass R A A | null | false |
Lean.Doc.instMonadStateOfInternalStateDocM | Lean.Elab.DocString | MonadStateOf Lean.Doc.InternalState Lean.Doc.DocM | null | true |
MeasureTheory.tendsto_setIntegral_of_L1 | Mathlib.MeasureTheory.Integral.Bochner.Basic | ∀ {α : Type u_1} {G : Type u_5} [inst : NormedAddCommGroup G] [inst_1 : NormedSpace ℝ G] {m : MeasurableSpace α}
{μ : MeasureTheory.Measure α} {ι : Type u_6} (f : α → G),
MeasureTheory.AEStronglyMeasurable f μ →
∀ {F : ι → α → G} {l : Filter ι},
(∀ᶠ (i : ι) in l, MeasureTheory.Integrable (F i) μ) →
... | If `F i → f` in `L1`, then `∫ x in s, F i x ∂μ → ∫ x in s, f x ∂μ`. | true |
StarMul.noConfusion | Mathlib.Algebra.Star.Basic | {P : Sort u_1} →
{R : Type u} →
{inst : Mul R} →
{t : StarMul R} →
{R' : Type u} →
{inst' : Mul R'} → {t' : StarMul R'} → R = R' → inst ≍ inst' → t ≍ t' → StarMul.noConfusionType P t t' | null | false |
FractionalIdeal.absNorm_div_norm_eq_absNorm_div_norm | Mathlib.RingTheory.FractionalIdeal.Norm | ∀ {R : Type u_1} [inst : CommRing R] [inst_1 : IsDedekindDomain R] [inst_2 : Module.Free ℤ R] [Module.Finite ℤ R]
{K : Type u_2} [inst_4 : CommRing K] [inst_5 : Algebra R K] [IsFractionRing R K]
{I : FractionalIdeal (nonZeroDivisors R) K} (a : ↥(nonZeroDivisors R)) (I₀ : Ideal R),
a • ↑I = Submodule.map (Algebra.... | null | true |
PMF.ofFinset.congr_simp | Mathlib.Probability.ProbabilityMassFunction.Constructions | ∀ {α : Type u_1} (f f_1 : α → ENNReal) (e_f : f = f_1) (s s_1 : Finset α) (e_s : s = s_1) (h : ∑ a ∈ s, f a = 1)
(h' : ∀ a ∉ s, f a = 0), PMF.ofFinset f s h h' = PMF.ofFinset f_1 s_1 ⋯ ⋯ | null | true |
continuous_algebraMap_iff_smul | Mathlib.Topology.Algebra.Algebra | ∀ (R : Type u_1) (A : Type u) [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A]
[inst_3 : TopologicalSpace R] [inst_4 : TopologicalSpace A] [ContinuousMul A],
Continuous ⇑(algebraMap R A) ↔ Continuous fun p => p.1 • p.2 | null | true |
Lean.LocalDeclKind | Lean.LocalContext | Type | Whether a local declaration should be found by type class search, tactics, etc.
and shown in the goal display.
| true |
Subgroup.isRegularAtInfty_of_neg_one_mem | Mathlib.NumberTheory.ModularForms.Cusps | ∀ {R : Type u_1} [inst : Ring R] {𝒢 : Subgroup (GL (Fin 2) R)}, -1 ∈ 𝒢 → 𝒢.IsRegularAtInfty | null | true |
CategoryTheory.Functor.IsHomological | Mathlib.CategoryTheory.Triangulated.HomologicalFunctor | {C : Type u_1} →
{A : Type u_3} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
[inst_1 : CategoryTheory.HasShift C ℤ] →
[inst_2 : CategoryTheory.Category.{v_3, u_3} A] →
CategoryTheory.Functor C A →
[inst_3 : CategoryTheory.Limits.HasZeroObject C] →
[inst_4 : C... | A functor from a pretriangulated category to an abelian category is a homological functor
if it sends distinguished triangles to exact sequences. | true |
GromovHausdorff.auxGluing._proof_4 | Mathlib.Topology.MetricSpace.GromovHausdorff | ∀ (X : ℕ → Type) [inst : (n : ℕ) → MetricSpace (X n)] [inst_1 : ∀ (n : ℕ), CompactSpace (X n)]
[inst_2 : ∀ (n : ℕ), Nonempty (X n)] (n : ℕ), Isometry (GromovHausdorff.optimalGHInjl (X n) (X (n + 1))) | null | false |
ENNReal.essSup_piecewise | Mathlib.MeasureTheory.Function.EssSup | ∀ {α : Type u_1} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} {f : α → ENNReal} {s : Set α}
[inst : DecidablePred fun x => x ∈ s] {g : α → ENNReal},
MeasureTheory.NullMeasurableSet s μ →
essSup (s.piecewise f g) μ = max (essSup f (μ.restrict s)) (essSup g (μ.restrict sᶜ)) | null | true |
toBoolAlg_zero | Mathlib.Algebra.Ring.BooleanRing | ∀ {α : Type u_1} [inst : BooleanRing α], toBoolAlg 0 = ⊥ | null | true |
Equiv.mulActionWithZero._proof_1 | Mathlib.Algebra.GroupWithZero.Action.TransferInstance | ∀ (M₀ : Type u_2) {A : Type u_1} {B : Type u_3} (e : A ≃ B) [inst : MonoidWithZero M₀] [inst_1 : Zero B]
[inst_2 : MulActionWithZero M₀ B] (x y : M₀) (b : A), (x * y) • b = x • y • b | null | false |
IsLocalizedModule.mapExtendScalars | Mathlib.RingTheory.Localization.Module | {R : Type u_1} →
[inst : CommSemiring R] →
(S : Submonoid R) →
{M : Type u_2} →
{M' : Type u_3} →
[inst_1 : AddCommMonoid M] →
[inst_2 : AddCommMonoid M'] →
[inst_3 : Module R M] →
[inst_4 : Module R M'] →
(f : M →ₗ[R] M') →
... | A linear map `M →ₗ[R] N` gives a map between localized modules `Mₛ →ₗ[Rₛ] Nₛ`. | true |
Topology.IsClosed_of | Mathlib.Topology.Defs.Basic | Lean.ParserDescr | Notation for `IsClosed` with respect to a non-standard topology. | true |
_private.Mathlib.Data.Finset.Insert.0.Finset.insert_comm._proof_1_1 | Mathlib.Data.Finset.Insert | ∀ {α : Type u_1} [inst : DecidableEq α] (a b : α) (s : Finset α), insert a (insert b s) = insert b (insert a s) | null | false |
Std.Tactic.BVDecide.BVExpr.WithCache.cache | Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Expr | {α : Type u} →
{aig : Std.Sat.AIG Std.Tactic.BVDecide.BVBit} →
Std.Tactic.BVDecide.BVExpr.WithCache α aig → Std.Tactic.BVDecide.BVExpr.Cache aig | null | true |
MonoidHom.FixedPointFree.commGroupOfInvolutive | Mathlib.GroupTheory.FixedPointFree | {F : Type u_1} →
{G : Type u_2} →
[inst : Group G] →
[inst_1 : FunLike F G G] →
[MonoidHomClass F G G] →
{φ : F} → [Finite G] → MonoidHom.FixedPointFree ⇑φ → Function.Involutive ⇑φ → CommGroup G | If a finite group admits a fixed-point-free involution, then it is commutative. | true |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.Const.isEmpty_filter_eq_false_iff._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) | null | false |
mem_selfAdjointMatricesSubmodule' | Mathlib.LinearAlgebra.Matrix.BilinearForm | ∀ {R₂ : Type u_3} [inst : CommRing R₂] {n : Type u_5} [inst_1 : Fintype n] (J A : Matrix n n R₂)
[inst_2 : DecidableEq n], A ∈ selfAdjointMatricesSubmodule J ↔ J.IsSelfAdjoint A | null | true |
DirectLimit.instMulZeroOneClass._proof_1 | Mathlib.Algebra.Colimit.DirectLimit | ∀ {ι : Type u_1} [inst : Preorder ι] {G : ι → Type u_3} {T : ⦃i j : ι⦄ → i ≤ j → Type u_2}
[inst_1 : (i j : ι) → (h : i ≤ j) → FunLike (T h) (G i) (G j)] [inst_2 : (i : ι) → MulZeroOneClass (G i)]
[∀ (i j : ι) (h : i ≤ j), MonoidWithZeroHomClass (T h) (G i) (G j)] (i j : ι) (h : i ≤ j),
MonoidHomClass (T h) (G i)... | null | false |
RatFunc.ofFractionRing_eq | Mathlib.FieldTheory.RatFunc.Basic | ∀ {K : Type u} [inst : CommRing K] [inst_1 : IsDomain K],
RatFunc.ofFractionRing =
⇑(IsLocalization.algEquiv (nonZeroDivisors (Polynomial K)) (FractionRing (Polynomial K)) (RatFunc K)) | null | true |
TopCat.coconeOfCoconeForget._proof_2 | Mathlib.Topology.Category.TopCat.Limits.Basic | ∀ {J : Type u_3} [inst : CategoryTheory.Category.{u_2, u_3} J] {F : CategoryTheory.Functor J TopCat}
(c : CategoryTheory.Limits.Cocone (F.comp (CategoryTheory.forget TopCat))) (j j' : J) (φ : j ⟶ j'),
CategoryTheory.CategoryStruct.comp (F.map φ)
(TopCat.ofHom { toFun := ⇑(CategoryTheory.ConcreteCategory.hom (... | null | false |
Lean.LocalDecl.collectFVars | Lean.Meta.CollectFVars | Lean.LocalDecl → StateRefT' IO.RealWorld Lean.CollectFVars.State Lean.MetaM Unit | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.