name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11.5k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
List.prefix_of_prefix_length_le | Init.Data.List.Sublist | ∀ {α : Type u_1} {l₁ l₂ l₃ : List α}, l₁ <+: l₃ → l₂ <+: l₃ → l₁.length ≤ l₂.length → l₁ <+: l₂ | null | true |
HomotopicalAlgebra.ModelCategory.mk'._proof_3 | Mathlib.AlgebraicTopology.ModelCategory.Basic | ∀ (C : Type u_2) [inst : CategoryTheory.Category.{u_1, u_2} C]
[inst_1 : HomotopicalAlgebra.CategoryWithWeakEquivalences C]
[(HomotopicalAlgebra.weakEquivalences C).HasTwoOutOfThreeProperty],
(HomotopicalAlgebra.weakEquivalences C).HasTwoOutOfThreeProperty | null | false |
Lean.instToJsonModuleArtifacts.toJson | Lean.Setup | Lean.ModuleArtifacts → Lean.Json | null | true |
_private.Lean.Linter.UnusedVariables.0.Lean.Linter.initFn._@.Lean.Linter.UnusedVariables.727354328._hygCtx._hyg.2 | Lean.Linter.UnusedVariables | IO Unit | In pattern (when `linter.unusedVariables.patternVars` is false)
* `def foo := match 0 with | unused => 1`
| false |
MvPolynomial.IsHomogeneous.totalDegree | Mathlib.RingTheory.MvPolynomial.Homogeneous | ∀ {σ : Type u_1} {R : Type u_3} [inst : CommSemiring R] {φ : MvPolynomial σ R} {n : ℕ},
φ.IsHomogeneous n → φ ≠ 0 → φ.totalDegree = n | null | true |
Submodule.quotientEquivDirectSum._proof_3 | Mathlib.LinearAlgebra.FreeModule.Finite.Quotient | ∀ {ι : Type u_2} {R : Type u_3} {M : Type u_1} [inst : CommRing R] [inst_1 : AddCommGroup M] [inst_2 : Module R M]
[inst_3 : IsDomain R] [inst_4 : IsPrincipalIdealRing R] [inst_5 : Finite ι] (F : Type u_4) [inst_6 : CommRing F]
[inst_7 : Algebra F R] [inst_8 : Module F M] [inst_9 : IsScalarTower F R M] (b : Module.... | null | false |
CircleDeg1Lift.iterate_le_of_map_le_add_int | Mathlib.Dynamics.Circle.RotationNumber.TranslationNumber | ∀ (f : CircleDeg1Lift) {x : ℝ} {m : ℤ}, f x ≤ x + ↑m → ∀ (n : ℕ), (⇑f)^[n] x ≤ x + ↑n * ↑m | null | true |
ContinuousMap.equivFnOfDiscrete_symm_apply | Mathlib.Topology.ContinuousMap.Basic | ∀ {α : Type u_1} {β : Type u_2} [inst : TopologicalSpace α] [inst_1 : TopologicalSpace β] [inst_2 : DiscreteTopology α]
(f : α → β), ⇑(ContinuousMap.equivFnOfDiscrete.symm f) = f | null | true |
Lean.Meta.Sym.Simp.instOrElseSimproc | Lean.Meta.Sym.Simp.Simproc | OrElse Lean.Meta.Sym.Simp.Simproc | null | true |
bot_lt_isotypicComponent | Mathlib.RingTheory.SimpleModule.Isotypic | ∀ {R : Type u_2} {M : Type u} [inst : Ring R] [inst_1 : AddCommGroup M] [inst_2 : Module R M] (S : Submodule R M)
[IsSimpleModule R ↥S], ⊥ < isotypicComponent R M ↥S | null | true |
Padic.addValuation | Mathlib.NumberTheory.Padics.PadicNumbers | {p : ℕ} → [hp : Fact (Nat.Prime p)] → AddValuation ℚ_[p] (WithTop ℤ) | The additive `p`-adic valuation on `ℚ_[p]`, as an `addValuation`. | true |
Ideal.span_union | Mathlib.RingTheory.Ideal.Span | ∀ {α : Type u} [inst : Semiring α] (s t : Set α), Ideal.span (s ∪ t) = Ideal.span s ⊔ Ideal.span t | null | true |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.contains_inter._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 |
_private.Mathlib.Analysis.Calculus.UniformLimitsDeriv.0.hasFDerivAt_of_tendstoLocallyUniformlyOn._simp_1_2 | Mathlib.Analysis.Calculus.UniformLimitsDeriv | ∀ {α : Type u_1} {f : Filter α}, (Set.univ ∈ f) = True | null | false |
alternatingGroup.iwasawaStructure_three | Mathlib.GroupTheory.SpecificGroups.Alternating.Simple | {α : Type u_1} →
[inst : DecidableEq α] →
[inst_1 : Fintype α] → MulAction.IwasawaStructure ↥(alternatingGroup α) ↑(Set.powersetCard α 3) | The Iwasawa structure of `alternatingGroup α` acting on `Set.powersetCard α 3`. | true |
Valuation.map_sub_eq_of_lt_left | Mathlib.RingTheory.Valuation.Basic | ∀ {R : Type u_3} {Γ₀ : Type u_4} [inst : Ring R] [inst_1 : LinearOrderedCommMonoidWithZero Γ₀] (v : Valuation R Γ₀)
{x y : R}, v y < v x → v (x - y) = v x | null | true |
Int.emod_minus_one | Init.Data.Int.DivMod.Lemmas | ∀ (a : ℤ), a % -1 = 0 | null | true |
CategoryTheory.StructuredArrow.mapIso | Mathlib.CategoryTheory.Comma.StructuredArrow.Basic | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{D : Type u₂} →
[inst_1 : CategoryTheory.Category.{v₂, u₂} D] →
{S S' : D} →
{T : CategoryTheory.Functor C D} →
(S ≅ S') → (CategoryTheory.StructuredArrow S T ≌ CategoryTheory.StructuredArrow S' T) | An isomorphism `S ≅ S'` induces an equivalence `StructuredArrow S T ≌ StructuredArrow S' T`. | true |
starL.congr_simp | Mathlib.Topology.Algebra.Module.Star | ∀ (R : Type u_1) {A : Type u_2} [inst : CommSemiring R] [inst_1 : StarRing R] [inst_2 : AddCommMonoid A]
[inst_3 : StarAddMonoid A] [inst_4 : Module R A] [inst_5 : StarModule R A] [inst_6 : TopologicalSpace A]
[inst_7 : ContinuousStar A], starL R = starL R | null | true |
_private.Mathlib.Topology.Algebra.ValuativeRel.ValuativeTopology.0.IsValuativeTopology.instIsTopologicalAddGroup.match_1 | Mathlib.Topology.Algebra.ValuativeRel.ValuativeTopology | ∀ (R : Type u_1) [inst : Ring R] [inst_1 : ValuativeRel R]
(γ : (MonoidWithZeroHom.ofClass (ValuativeRel.valuation R)).ValueGroup₀ˣ)
(motive :
(x : R × R) →
x ∈ {x | (ValuativeRel.valuation R).restrict x < ↑γ} ×ˢ {x | (ValuativeRel.valuation R).restrict x < ↑γ} → Prop)
(x : R × R)
(hx : x ∈ {x | (Valu... | null | false |
_private.Std.Time.Format.Basic.0.Std.Time.parseQuarterShort | Std.Time.Format.Basic | Std.Time.DateFormatSymbols → Std.Internal.Parsec.String.Parser Std.Time.Month.Quarter | null | true |
npow_one | Mathlib.Algebra.Group.NatPowAssoc | ∀ {M : Type u_1} [inst : MulOneClass M] [inst_1 : Pow M ℕ] [NatPowAssoc M] (x : M), x ^ 1 = x | null | true |
FirstOrder.Language.LHom.sumInl_onFunction | Mathlib.ModelTheory.LanguageMap | ∀ {L : FirstOrder.Language} {L' : FirstOrder.Language} (_n : ℕ) (val : L.Functions _n),
FirstOrder.Language.LHom.sumInl.onFunction val = Sum.inl val | null | true |
_private.Init.Data.String.Decode.0.utf8DecodeChar?_eq_assemble₃._proof_2 | Init.Data.String.Decode | ∀ {b : ByteArray}, 3 ≤ b.size → ¬1 < b.size → False | null | false |
Subarray.start | Init.Data.Array.Subarray | {α : Type u_1} → Subarray α → ℕ | The starting index of the region of interest (inclusive). | true |
Std.ExtTreeSet.max_erase_le_max | Std.Data.ExtTreeSet.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t : Std.ExtTreeSet α cmp} [inst : Std.TransCmp cmp] {k : α}
{he : t.erase k ≠ ∅}, (cmp ((t.erase k).max he) (t.max ⋯)).isLE = true | null | true |
_private.Lean.Parser.Basic.0.Lean.Parser.checkNoWsBefore._regBuiltin.Lean.Parser.checkNoWsBefore.docString_1 | Lean.Parser.Basic | IO Unit | null | false |
_private.Lean.Elab.Tactic.Conv.Simp.0.Lean.Elab.Tactic.Conv.evalSimp.match_1 | Lean.Elab.Tactic.Conv.Simp | (motive : Lean.Meta.Simp.Result × Lean.Meta.Simp.Stats → Sort u_1) →
(x : Lean.Meta.Simp.Result × Lean.Meta.Simp.Stats) →
((result : Lean.Meta.Simp.Result) → (snd : Lean.Meta.Simp.Stats) → motive (result, snd)) → motive x | null | false |
_private.Mathlib.LinearAlgebra.Dimension.Finite.0.Module.exists_nontrivial_relation_sum_zero_of_finrank_succ_lt_card._simp_1_3 | Mathlib.LinearAlgebra.Dimension.Finite | ∀ {G : Type u_3} [inst : AddGroup G] {a b : G}, (a + -b = 0) = (a = b) | null | false |
NormedRing.toNonUnitalNormedRing._proof_4 | Mathlib.Analysis.Normed.Ring.Basic | ∀ {α : Type u_1} [β : NormedRing α] (n : ℕ) (a : α), Ring.zsmul (Int.negSucc n) a = -Ring.zsmul (↑n.succ) a | null | false |
Set.Ico_add_Ioc_subset | Mathlib.Algebra.Order.Group.Pointwise.Interval | ∀ {α : Type u_1} [inst : Add α] [inst_1 : PartialOrder α] [AddLeftStrictMono α] [AddRightStrictMono α] (a b c d : α),
Set.Ico a b + Set.Ioc c d ⊆ Set.Ioo (a + c) (b + d) | null | true |
AddUnits.opEquiv._proof_4 | Mathlib.Algebra.Group.Units.Opposite | ∀ {M : Type u_1} [inst : AddMonoid M] (u : AddUnits Mᵃᵒᵖ), AddOpposite.unop ↑(-u) + AddOpposite.unop ↑u = 0 | null | false |
CompletelyDistribLattice.MinimalAxioms | Mathlib.Order.CompleteBooleanAlgebra | Type u → Type u | Structure containing the minimal axioms required to check that an order is a completely
distributive. Do NOT use, except for implementing `CompletelyDistribLattice` via
`CompletelyDistribLattice.ofMinimalAxioms`.
This structure omits the `himp`, `compl`, `sdiff`, `hnot` fields, which can be recovered using
`Completely... | true |
Equiv.Perm.IsSwap.congr_simp | Mathlib.GroupTheory.Perm.Sign | ∀ {α : Type u_1} {inst : DecidableEq α} [inst_1 : DecidableEq α] (f f_1 : Equiv.Perm α), f = f_1 → f.IsSwap = f_1.IsSwap | null | true |
_private.Mathlib.MeasureTheory.VectorMeasure.Decomposition.Hahn.0.MeasureTheory.SignedMeasure.exists_subset_restrict_nonpos'._simp_1_2 | Mathlib.MeasureTheory.VectorMeasure.Decomposition.Hahn | ∀ {α : Type u} (x : α), (x ∈ ∅) = False | null | false |
Std.DHashMap.Raw.Const.getThenInsertIfNew? | Std.Data.DHashMap.Raw | {α : Type u} →
{β : Type v} →
[BEq α] → [Hashable α] → (Std.DHashMap.Raw α fun x => β) → α → β → Option β × Std.DHashMap.Raw α fun x => β | Equivalent to (but potentially faster than) calling `Const.get?` followed by `insertIfNew`.
Checks whether a key is present in a map, returning the associated value, and inserts a value for
the key if it was not found.
If the returned value is `some v`, then the returned map is unaltered. If it is `none`, then the
re... | true |
Lean.Parser.Command.declVal.parenthesizer | Lean.Parser.Command | Lean.PrettyPrinter.Parenthesizer | null | true |
Equiv.toHomeomorph._proof_3 | Mathlib.Topology.Homeomorph.Defs | ∀ {X : Type u_2} {Y : Type u_1} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] (e : X ≃ Y),
(∀ (s : Set Y), IsOpen (⇑e ⁻¹' s) ↔ IsOpen s) → Continuous e.invFun | null | false |
UpperHemicontinuousWithinAt.eq_1 | Mathlib.Topology.Semicontinuity.Defs | ∀ {α : Type u_1} {β : Type u_2} [inst : TopologicalSpace α] [inst_1 : TopologicalSpace β] (f : α → Set β) (s : Set α)
(x : α), UpperHemicontinuousWithinAt f s x = SemicontinuousWithinAt (fun x t => t ∈ nhdsSet (f x)) s x | null | true |
Submodule.smul_comap_le_comap_smul | Mathlib.RingTheory.Ideal.Operations | ∀ {R : Type u} {M : Type v} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] {M' : Type w}
[inst_3 : AddCommMonoid M'] [inst_4 : Module R M'] (f : M →ₗ[R] M') (S : Submodule R M') (I : Ideal R),
I • Submodule.comap f S ≤ Submodule.comap f (I • S) | null | true |
WeierstrassCurve.Affine.instDecidableEqPoint.decEq._proof_2 | Mathlib.AlgebraicGeometry.EllipticCurve.Affine.Point | ∀ {R : Type u_1} {inst : CommRing R} {W' : WeierstrassCurve.Affine R} (a a_1 : R) (a_2 : W'.Nonsingular a a_1),
a_2 = a_2 | null | false |
instLawfulCommIdentityInt64HOrOfNat | Init.Data.SInt.Bitwise | Std.LawfulCommIdentity (fun x1 x2 => x1 ||| x2) 0 | null | true |
StarAlgHom.prodEquiv._proof_1 | Mathlib.Algebra.Star.StarAlgHom | ∀ {R : Type u_4} {A : Type u_1} {B : Type u_2} {C : Type u_3} [inst : CommSemiring R] [inst_1 : Semiring A]
[inst_2 : Algebra R A] [inst_3 : Star A] [inst_4 : Semiring B] [inst_5 : Algebra R B] [inst_6 : Star B]
[inst_7 : Semiring C] [inst_8 : Algebra R C] [inst_9 : Star C],
Function.LeftInverse (fun f => ((StarA... | null | false |
Finsupp.isCentralScalar | Mathlib.Data.Finsupp.SMulWithZero | ∀ (α : Type u_1) (M : Type u_5) {R : Type u_11} [inst : Zero M] [inst_1 : SMulZeroClass R M]
[inst_2 : SMulZeroClass Rᵐᵒᵖ M] [IsCentralScalar R M], IsCentralScalar R (α →₀ M) | null | true |
ProofWidgets.RpcEncodablePacket.«_@».ProofWidgets.Data.Html.2686543190._hygCtx._hyg.1.ctorElimType | ProofWidgets.Data.Html | {motive : ProofWidgets.RpcEncodablePacket✝ → Sort u} → ℕ → Sort (max 1 u) | null | false |
InnerProductGeometry.norm_add_eq_add_norm_of_angle_eq_zero | Mathlib.Geometry.Euclidean.Angle.Unoriented.Basic | ∀ {V : Type u_1} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V] {x y : V},
InnerProductGeometry.angle x y = 0 → ‖x + y‖ = ‖x‖ + ‖y‖ | If the angle between two vectors is 0, the norm of their sum equals
the sum of their norms. | true |
Ordering.swap | Init.Data.Ord.Basic | Ordering → Ordering | Swaps less-than and greater-than ordering results.
Examples:
* `Ordering.lt.swap = Ordering.gt`
* `Ordering.eq.swap = Ordering.eq`
* `Ordering.gt.swap = Ordering.lt`
| true |
_private.Lean.Compiler.LCNF.Basic.0.Lean.Compiler.LCNF.updateAltImp | Lean.Compiler.LCNF.Basic | {pu : Lean.Compiler.LCNF.Purity} →
Lean.Compiler.LCNF.Alt pu →
Array (Lean.Compiler.LCNF.Param pu) → Lean.Compiler.LCNF.Code pu → Lean.Compiler.LCNF.Alt pu | null | true |
Lean.Elab.Term.Arg.stx.noConfusion | Lean.Elab.Arg | {P : Sort u} →
{val val' : Lean.Syntax} → Lean.Elab.Term.Arg.stx val = Lean.Elab.Term.Arg.stx val' → (val = val' → P) → P | null | false |
Std.DHashMap.Raw.insert | Std.Data.DHashMap.Raw | {α : Type u} → {β : α → Type v} → [BEq α] → [Hashable α] → Std.DHashMap.Raw α β → (a : α) → β a → Std.DHashMap.Raw α β | Inserts the given mapping into the map. If there is already a mapping for the given key, then both
key and value will be replaced.
Note: this replacement behavior is true for `HashMap`, `DHashMap`, `HashMap.Raw` and `DHashMap.Raw`.
The `insert` function on `HashSet` and `HashSet.Raw` behaves differently: it will retur... | true |
mersenne_le_mersenne._gcongr_1 | Mathlib.NumberTheory.LucasLehmer | ∀ {p q : ℕ}, p ≤ q → mersenne p ≤ mersenne q | null | false |
Subsemigroup.map_injective_of_injective | Mathlib.Algebra.Group.Subsemigroup.Operations | ∀ {M : Type u_1} {N : Type u_2} [inst : Mul M] [inst_1 : Mul N] {f : M →ₙ* N},
Function.Injective ⇑f → Function.Injective (Subsemigroup.map f) | null | true |
_private.Mathlib.GroupTheory.Coxeter.Inversion.0.CoxeterSystem.IsReflection.conj._simp_1_1 | Mathlib.GroupTheory.Coxeter.Inversion | ∀ {G : Type u_1} [inst : DivInvMonoid G] (x : G), x⁻¹ = x ^ (-1) | null | false |
instIsContMDiffRiemannianBundleOfNatWithTopENat_2 | Mathlib.Geometry.Manifold.VectorBundle.Riemannian | ∀ {EB : Type u_1} [inst : NormedAddCommGroup EB] [inst_1 : NormedSpace ℝ EB] {HB : Type u_2}
[inst_2 : TopologicalSpace HB] {IB : ModelWithCorners ℝ EB HB} {B : Type u_3} [inst_3 : TopologicalSpace B]
[inst_4 : ChartedSpace HB B] {F : Type u_4} [inst_5 : NormedAddCommGroup F] [inst_6 : NormedSpace ℝ F]
{E : B → T... | null | true |
Polynomial.card_roots_sub_C | Mathlib.Algebra.Polynomial.Roots | ∀ {R : Type u} [inst : CommRing R] [inst_1 : IsDomain R] {p : Polynomial R} {a : R},
0 < p.degree → ↑(p - Polynomial.C a).roots.card ≤ p.degree | null | true |
Fin.encodeOrdering | Batteries.Data.Fin.Coding | Ordering → Fin 3 | Encode `Ordering` into `Fin 3`. | true |
_private.Mathlib.Topology.Sets.VietorisTopology.0.TopologicalSpace.Compacts.instLocallyCompactSpace._proof_2 | Mathlib.Topology.Sets.VietorisTopology | ∀ {α : Type u_1} [inst : TopologicalSpace α] (L U : Set α) (x : α) (M : Set α),
x ∈ interior M ∧ M ⊆ U ∩ interior L → M ⊆ U | null | false |
_private.Std.Data.Internal.List.Associative.0.Std.Internal.List.containsKey_of_containsKey_filterMap._simp_1_1 | Std.Data.Internal.List.Associative | ∀ {α : Type u_1} (p : α → Bool) (x : Option α), (Option.all p x = true) = ∀ (y : α), x = some y → p y = true | null | false |
CategoryTheory.Limits.preservesLimitsOfSize_of_leftOp | Mathlib.CategoryTheory.Limits.Preserves.Opposites | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
(F : CategoryTheory.Functor C Dᵒᵖ) [CategoryTheory.Limits.PreservesColimitsOfSize.{w, w', v₁, v₂, u₁, u₂} F.leftOp],
CategoryTheory.Limits.PreservesLimitsOfSize.{w, w', v₁, v₂, u₁, u₂} F | If `F.leftOp : Cᵒᵖ ⥤ D` preserves colimits, then `F : C ⥤ Dᵒᵖ` preserves limits. | true |
CategoryTheory.BasedFunctor._sizeOf_inst | Mathlib.CategoryTheory.FiberedCategory.BasedCategory | {𝒮 : Type u₁} →
{inst : CategoryTheory.Category.{v₁, u₁} 𝒮} →
(𝒳 : CategoryTheory.BasedCategory 𝒮) →
(𝒴 : CategoryTheory.BasedCategory 𝒮) → [SizeOf 𝒮] → SizeOf (CategoryTheory.BasedFunctor 𝒳 𝒴) | null | false |
MeasureTheory.measurable_inclusion_predictable | Mathlib.Probability.Process.Predictable | ∀ {Ω : Type u_1} {ι : Type u_2} {m : MeasurableSpace Ω} [inst : LinearOrder ι] [inst_1 : OrderBot ι]
[inst_2 : MeasurableSpace ι] [inst_3 : TopologicalSpace ι] [OpensMeasurableSpace ι] [OrderClosedTopology ι]
{𝓕 : MeasureTheory.Filtration ι m} {i : ι}, Measurable fun x => (↑x.1, x.2) | The inclusion map from [0,i] × Ω with the subtype × 𝓕 i σ-algebra) to ι × Ω with the
predictable σ-algebra is measurable | true |
FirstOrder.Language.Term.substFunc._sunfold | Mathlib.ModelTheory.Syntax | {L : FirstOrder.Language} →
{L' : FirstOrder.Language} → {α : Type u'} → L.Term α → ({n : ℕ} → L.Functions n → L'.Term (Fin n)) → L'.Term α | null | false |
ZMod.χ₈'_eq_χ₄_mul_χ₈ | Mathlib.NumberTheory.LegendreSymbol.ZModChar | ∀ (a : ZMod 8), ZMod.χ₈' a = ZMod.χ₄ a.cast * ZMod.χ₈ a | The relation between `χ₄`, `χ₈` and `χ₈'` | true |
Std.IterM.mk.inj | Init.Data.Iterators.Basic | ∀ {α : Type w} {m : Type w → Type w'} {β : Type w} {internalState internalState_1 : α},
{ internalState := internalState } = { internalState := internalState_1 } → internalState = internalState_1 | null | true |
RBTree.RBNode.Stream.ctorElim | BatteriesRecycling.RBTree.Basic | {α : Type u_1} →
{motive : RBTree.RBNode.Stream α → Sort u} →
(ctorIdx : ℕ) →
(t : RBTree.RBNode.Stream α) → ctorIdx = t.ctorIdx → RBTree.RBNode.Stream.ctorElimType ctorIdx → motive t | null | false |
_private.Batteries.Data.Nat.Bitwise.Lemmas.0.Nat.and_or_left_injective._simp_1_2 | Batteries.Data.Nat.Bitwise.Lemmas | ∀ (x y i : ℕ), (x.testBit i || y.testBit i) = (x ||| y).testBit i | null | false |
_private.Mathlib.Logic.Equiv.Basic.0.Equiv.piCongrLeft'._proof_1 | Mathlib.Logic.Equiv.Basic | ∀ {α : Sort u_1} {β : Sort u_3} (P : α → Sort u_2) (e : α ≃ β) (f : (a : α) → P a), (fun x => ⋯ ▸ f (e.symm (e x))) = f | null | false |
CategoryTheory.Square.rec | Mathlib.CategoryTheory.Square | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{motive : CategoryTheory.Square C → Sort u_1} →
({X₁ X₂ X₃ X₄ : C} →
(f₁₂ : X₁ ⟶ X₂) →
(f₁₃ : X₁ ⟶ X₃) →
(f₂₄ : X₂ ⟶ X₄) →
(f₃₄ : X₃ ⟶ X₄) →
(fac : CategoryTheory.CategoryStruct.c... | null | false |
RingHom.FormallyUnramified.holdsForLocalization | Mathlib.RingTheory.RingHom.Unramified | RingHom.HoldsForLocalization fun {R S} [CommRing R] [CommRing S] => RingHom.FormallyUnramified | null | true |
leftCoset_mem_leftCoset | Mathlib.GroupTheory.Coset.Basic | ∀ {α : Type u_1} [inst : Group α] (s : Subgroup α) {a : α}, a ∈ s → a • ↑s = ↑s | null | true |
Int8.minValue_le_toInt | Init.Data.SInt.Lemmas | ∀ (x : Int8), Int8.minValue.toInt ≤ x.toInt | null | true |
AList.insertRec._proof_1 | Mathlib.Data.List.AList | ∀ {α : Type u_1} {β : α → Type u_2}, WellFounded (invImage (fun x => x) sizeOfWFRel).1 | null | false |
Equiv.symm_image_subset._simp_1 | Mathlib.Logic.Equiv.Set | ∀ {α : Type u_3} {β : Type u_4} (e : α ≃ β) (s : Set α) (t : Set β), (⇑e.symm '' t ⊆ s) = (t ⊆ ⇑e '' s) | null | false |
_private.Init.Data.Char.Ordinal.0.Char.lt_iff_ofOrdinal_lt._simp_1_1 | Init.Data.Char.Ordinal | ∀ {α : Type u} [inst : LT α] [inst_1 : LE α] [Std.LawfulOrderLT α] {a b : α}, (a < b) = (a ≤ b ∧ ¬b ≤ a) | null | false |
Padic.mulValuation._proof_1 | Mathlib.NumberTheory.Padics.PadicNumbers | ∀ {p : ℕ} [hp : Fact (Nat.Prime p)], (if 0 = 0 then 0 else WithZero.exp (-Padic.valuation 0)) = 0 | null | false |
Continuous.homeoOfEquivCompactToT2 | Mathlib.Topology.Homeomorph.Lemmas | {X : Type u_1} →
{Y : Type u_2} →
[inst : TopologicalSpace X] →
[inst_1 : TopologicalSpace Y] → [CompactSpace X] → [T2Space Y] → {f : X ≃ Y} → Continuous ⇑f → X ≃ₜ Y | Continuous equivalences from a compact space to a T2 space are homeomorphisms.
This is not true when T2 is weakened to T1
(see `Continuous.homeoOfEquivCompactToT2.t1_counterexample`). | true |
String.Slice.Pos.slice_lt_iff | Init.Data.String.Lemmas.Order | ∀ {s : String.Slice} {p₀ p₁ : s.Pos} {h : p₀ ≤ p₁} {p : (s.slice p₀ p₁ h).Pos} {q : s.Pos} {h₀ : p₀ ≤ q} {h₁ : q ≤ p₁},
q.slice p₀ p₁ h₀ h₁ < p ↔ q < String.Slice.Pos.ofSlice p | null | true |
Filter.EventuallyEq.hasFDerivWithinAt_iff | Mathlib.Analysis.Calculus.FDeriv.Congr | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : AddCommGroup E] [inst_2 : Module 𝕜 E]
[inst_3 : TopologicalSpace E] {F : Type u_3} [inst_4 : AddCommGroup F] [inst_5 : Module 𝕜 F]
[inst_6 : TopologicalSpace F] {f₀ f₁ : E → F} {f' : E →L[𝕜] F} {x : E} {s : Set E},
f₀ =ᶠ[nhdsWithin ... | null | true |
_private.Mathlib.Analysis.SumIntegralComparisons.0.sum_mul_Ico_le_integral_of_monotone_antitone._proof_1_6 | Mathlib.Analysis.SumIntegralComparisons | ∀ {a b : ℕ} (i : ℕ), a ≤ i ∧ i < b → a ≤ i + 1 | null | false |
_private.Mathlib.LinearAlgebra.RootSystem.GeckConstruction.Semisimple.0.RootPairing.GeckConstruction.instIsIrreducible._simp_1 | Mathlib.LinearAlgebra.RootSystem.GeckConstruction.Semisimple | ∀ {n : Type u_2} [inst : DecidableEq n] [inst_1 : Fintype n] {R : Type v} [inst_2 : CommRing R] {S : Type w}
[inst_3 : CommRing S] (f : R →+* S) (M : Matrix n n R), (f.mapMatrix M).det = f M.det | null | false |
LaurentSeries.LaurentSeries_coe | Mathlib.RingTheory.LaurentSeries | ∀ (K : Type u_2) [inst : Field K] (x : RatFunc K),
(LaurentSeries.LaurentSeriesPkg K).coe (WithVal.toVal (RatFunc.polynomialValuationX K) x) =
(algebraMap (RatFunc K) (LaurentSeries K)) x | null | true |
Holor.assocRight | Mathlib.Data.Holor | {α : Type} → {ds₁ ds₂ ds₃ : List ℕ} → Holor α (ds₁ ++ ds₂ ++ ds₃) → Holor α (ds₁ ++ (ds₂ ++ ds₃)) | Right associator for `Holor` | true |
isStarProjection_iff' | Mathlib.Algebra.Star.StarProjection | ∀ {R : Type u_1} {p : R} [inst : Mul R] [inst_1 : Star R], IsStarProjection p ↔ p * p = p ∧ star p = p | null | true |
_private.Mathlib.Logic.Equiv.Multiset.0.Denumerable.lower.match_1.eq_1 | Mathlib.Logic.Equiv.Multiset | ∀ (motive : List ℕ → ℕ → Sort u_1) (x : ℕ) (h_1 : (x : ℕ) → motive [] x)
(h_2 : (m : ℕ) → (l : List ℕ) → (n : ℕ) → motive (m :: l) n),
(match [], x with
| [], x => h_1 x
| m :: l, n => h_2 m l n) =
h_1 x | null | true |
PresheafOfModules.epi_of_surjective | Mathlib.Algebra.Category.ModuleCat.Presheaf.EpiMono | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {R : CategoryTheory.Functor Cᵒᵖ RingCat}
{M₁ M₂ : PresheafOfModules R} {f : M₁ ⟶ M₂},
(∀ ⦃X : Cᵒᵖ⦄, Function.Surjective ⇑(CategoryTheory.ConcreteCategory.hom (f.app X))) → CategoryTheory.Epi f | null | true |
CategoryTheory.Abelian.SpectralObject.coreE₂HomologicalNat | Mathlib.Algebra.Homology.SpectralObject.HasSpectralSequence | CategoryTheory.Abelian.SpectralObject.SpectralSequenceDataCore EInt
(fun r => ComplexShape.spectralSequenceNat (-r, r - 1)) 2 | The data which allows to construct an `E₂`-homological spectral sequence
indexed by `ℕ × ℕ` from a spectral object indexed by `EInt`. (Note: additional
assumptions on the spectral object are required for the construction of
the spectral sequence from this.) | true |
Quiver.SingleObj.listToPath_pathToList | Mathlib.Combinatorics.Quiver.SingleObj | ∀ {α : Type u_1} {x : Quiver.SingleObj α} (p : Quiver.Path (Quiver.SingleObj.star α) x),
Quiver.SingleObj.listToPath (Quiver.SingleObj.pathToList p) = Quiver.Path.cast ⋯ ⋯ p | null | true |
Ordinal.add_log_le_log_mul | Mathlib.SetTheory.Ordinal.Exponential | ∀ {x y : Ordinal.{u_1}} (b : Ordinal.{u_1}), x ≠ 0 → y ≠ 0 → Ordinal.log b x + Ordinal.log b y ≤ Ordinal.log b (x * y) | null | true |
SimpleGraph.incidenceSetEquivNeighborSet._proof_1 | Mathlib.Combinatorics.SimpleGraph.Basic | ∀ {V : Type u_1} (G : SimpleGraph V) (v : V) (e : ↑(G.incidenceSet v)), ↑e ∈ G.incidenceSet v | null | false |
Interval.mulOneClass._proof_1 | Mathlib.Algebra.Order.Interval.Basic | ∀ {α : Type u_1} [inst : CommMonoid α] [inst_1 : Preorder α] [inst_2 : IsOrderedMonoid α] (s : Interval α),
WithBot.map₂ (fun x1 x2 => x1 * x2) (↑1) s = s | null | false |
HahnSeries.cardSupp_congr | Mathlib.RingTheory.HahnSeries.Cardinal | ∀ {Γ : Type u_1} {R : Type u_2} {S : Type u_3} [inst : PartialOrder Γ] [inst_1 : Zero R] [inst_2 : Zero S]
{x : HahnSeries Γ R} {y : HahnSeries Γ S}, x.support = y.support → x.cardSupp = y.cardSupp | null | true |
AddCommMonoidWithOne.mk | Mathlib.Data.Nat.Cast.Defs | {R : Type u_2} → [toAddMonoidWithOne : AddMonoidWithOne R] → (∀ (a b : R), a + b = b + a) → AddCommMonoidWithOne R | null | true |
_private.Lean.Util.Diff.0.Lean.Diff.matchSuffix._proof_2 | Lean.Util.Diff | ∀ {α : Type u_1} (left right : Subarray α) (i : ℕ),
i < Std.Slice.size left ∧ i < Std.Slice.size right → ¬Std.Slice.size right - i - 1 < Std.Slice.size right → False | null | false |
Std.HashSet.Equiv.diff_right | Std.Data.HashSet.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {m₁ m₂ m₃ : Std.HashSet α} [EquivBEq α] [LawfulHashable α],
m₂.Equiv m₃ → (m₁ \ m₂).Equiv (m₁ \ m₃) | null | true |
Rep.hom_inv_rightUnitor | Mathlib.RepresentationTheory.Rep.Basic | ∀ {k : Type u} {G : Type v} [inst : CommRing k] [inst_1 : Monoid G] {X : Rep.{u, u, v} k G},
Rep.Hom.hom (CategoryTheory.MonoidalCategoryStruct.rightUnitor X).inv = ↑(Representation.TensorProduct.rid k X.ρ).symm | null | true |
groupHomology.chainsIso₀._proof_1 | Mathlib.RepresentationTheory.Homological.GroupHomology.LowDegree | ∀ {G : Type u_1}, Subsingleton (Fin 0 → G) | null | false |
VAdd.ctorIdx | Mathlib.Algebra.Notation.Defs | {G : Type u} → {P : Type v} → VAdd G P → ℕ | null | false |
_private.Mathlib.Analysis.Convex.Side.0.Affine.Simplex.sSameSide_affineSpan_faceOpposite_iff.match_1_1 | Mathlib.Analysis.Convex.Side | ∀ {R : Type u_1} [inst : Field R] [inst_1 : LinearOrder R] {n : ℕ} {w₁ w₂ : Fin (n + 1) → R} {i : Fin (n + 1)}
(motive : SignType.sign (w₁ i) = SignType.sign (w₂ i) ∧ w₁ i ≠ 0 → Prop)
(x : SignType.sign (w₁ i) = SignType.sign (w₂ i) ∧ w₁ i ≠ 0),
(∀ (hs : SignType.sign (w₁ i) = SignType.sign (w₂ i)) (h0 : w₁ i ≠ 0... | null | false |
Std.DTreeMap.Internal.Impl.maxEntry?.eq_2 | Std.Data.DTreeMap.Internal.Model | ∀ {α : Type u} {β : α → Type v} (size : ℕ) (k : α) (v : β k) (l : Std.DTreeMap.Internal.Impl α β),
(Std.DTreeMap.Internal.Impl.inner size k v l Std.DTreeMap.Internal.Impl.leaf).maxEntry? = some ⟨k, v⟩ | null | true |
_private.Batteries.Data.List.Lemmas.0.List.findIdxNth_countPBefore_of_lt_length_of_pos._proof_1_1 | Batteries.Data.List.Lemmas | ∀ {α : Type u_1} {p : α → Bool} {i : ℕ} {h : i < [].length}, List.findIdxNth p [] (List.countPBefore p [] i) = i | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.