name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
Complex.UnitDisc.coe_neg._simp_1 | Mathlib.Analysis.Complex.UnitDisc.Basic | ∀ (z : Complex.UnitDisc), -↑z = ↑(-z) | false |
ProperCone.mem_dual._simp_1 | Mathlib.Analysis.Convex.Cone.Dual | ∀ {R : Type u_1} {M : Type u_2} {N : Type u_3} [inst : CommRing R] [inst_1 : PartialOrder R] [inst_2 : IsOrderedRing R]
[inst_3 : TopologicalSpace R] [inst_4 : ClosedIciTopology R] [inst_5 : AddCommGroup M] [inst_6 : Module R M]
[inst_7 : TopologicalSpace M] [inst_8 : AddCommGroup N] [inst_9 : Module R N] [inst_10 : TopologicalSpace N]
{p : M →ₗ[R] N →ₗ[R] R} [inst_11 : p.IsContPerfPair] {s : Set M} {y : N},
(y ∈ ProperCone.dual p s) = ∀ ⦃x : M⦄, x ∈ s → 0 ≤ (p x) y | false |
SeparationQuotient.instNonUnitalNormedRing._proof_2 | Mathlib.Analysis.Normed.Ring.Lemmas | ∀ {α : Type u_1} [inst : NonUnitalSeminormedRing α] (q₁ q₂ : Quotient (inseparableSetoid α)), ‖q₁ * q₂‖ ≤ ‖q₁‖ * ‖q₂‖ | false |
_private.Mathlib.Computability.Primrec.Basic.0.Primrec.nat_div._simp_1_2 | Mathlib.Computability.Primrec.Basic | ∀ {α : Type u_1} [inst : LinearOrderedCommMonoidWithZero α] {a : α}, (0 < a) = (a ≠ 0) | false |
PseudoMetricSpace.ofPreNNDist._proof_9 | Mathlib.Topology.Metrizable.Uniformity | ∀ {X : Type u_1} (d : X → X → NNReal),
(∀ (x : X), d x x = 0) →
(∀ (x y : X), d x y = d y x) → ∀ (x y : X), 0 ≤ ↑(⨅ l, (List.zipWith d (x :: l) (l ++ [y])).sum) | false |
analyticOnNhd_const | Mathlib.Analysis.Analytic.Constructions | ∀ {𝕜 : Type u_2} [inst : NontriviallyNormedField 𝕜] {E : Type u_3} {F : Type u_4} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {v : F} {s : Set E},
AnalyticOnNhd 𝕜 (fun x => v) s | true |
_private.Mathlib.NumberTheory.LegendreSymbol.JacobiSymbol.0.jacobiSym.eq_zero_iff_not_coprime._simp_1_5 | Mathlib.NumberTheory.LegendreSymbol.JacobiSymbol | ∀ {a b c : Prop}, ((a ∧ b) ∧ c) = (a ∧ b ∧ c) | false |
_private.Mathlib.Topology.MetricSpace.Isometry.0.isometry_iff_nndist_eq._simp_1_2 | Mathlib.Topology.MetricSpace.Isometry | ∀ {p q : NNReal}, (↑p = ↑q) = (p = q) | false |
Semiring.directSumGSemiring._proof_3 | Mathlib.Algebra.DirectSum.Ring | ∀ (ι : Type u_1) {R : Type u_2} [inst : AddMonoid ι] [inst_1 : Semiring R] (a b c : GradedMonoid fun x => R),
a * b * c = a * (b * c) | false |
ProfiniteGrp.ofProfinite._proof_1 | Mathlib.Topology.Algebra.Category.ProfiniteGrp.Basic | ∀ (G : Profinite), CompactSpace ↑G.toTop | false |
LieHom.prod._proof_1 | Mathlib.Algebra.Lie.Prod | ∀ {R : Type u_4} {L₁ : Type u_1} {L₂ : Type u_2} {L : Type u_3} [inst : CommRing R] [inst_1 : LieRing L₁]
[inst_2 : LieAlgebra R L₁] [inst_3 : LieRing L₂] [inst_4 : LieAlgebra R L₂] [inst_5 : LieRing L]
[inst_6 : LieAlgebra R L] (f : L →ₗ⁅R⁆ L₁) (g : L →ₗ⁅R⁆ L₂) {x y : L},
((↑f).prod ↑g).toFun ⁅x, y⁆ = ⁅((↑f).prod ↑g).toFun x, ((↑f).prod ↑g).toFun y⁆ | false |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.getKeyD_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) | false |
_private.Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Unital.0.Units.continuousOn_inv₀_spectrum._simp_1_1 | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Unital | ∀ {α : Type u_1} {s : Set α} {a : α}, (s ⊆ {a}ᶜ) = (a ∉ s) | false |
Std.Time.Nanosecond.instTransOrdOffset | Std.Time.Time.Unit.Nanosecond | Std.TransOrd Std.Time.Nanosecond.Offset | true |
_private.Mathlib.Topology.UniformSpace.Basic.0.Uniform.continuousOn_iff'_left._simp_1_1 | Mathlib.Topology.UniformSpace.Basic | ∀ {α : Type ua} {β : Type ub} [inst : UniformSpace α] [inst_1 : TopologicalSpace β] {f : β → α} {b : β} {s : Set β},
ContinuousWithinAt f s b = Filter.Tendsto (fun x => (f x, f b)) (nhdsWithin b s) (uniformity α) | false |
List.diff_subset | Batteries.Data.List.Lemmas | ∀ {α : Type u_1} [inst : BEq α] [LawfulBEq α] (l₁ l₂ : List α), l₁.diff l₂ ⊆ l₁ | true |
Order.Ioo_succ_right_of_not_isMax | Mathlib.Order.SuccPred.Basic | ∀ {α : Type u_1} [inst : LinearOrder α] [inst_1 : SuccOrder α] {a b : α},
¬IsMax b → Set.Ioo a (Order.succ b) = Set.Ioc a b | true |
CategoryTheory.Iso.trans_refl | Mathlib.CategoryTheory.Iso | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y : C} (α : X ≅ Y), α ≪≫ CategoryTheory.Iso.refl Y = α | true |
DFinsupp.Lex.isOrderedCancelAddMonoid | Mathlib.Data.DFinsupp.Lex | ∀ {ι : Type u_1} {α : ι → Type u_2} [inst : LinearOrder ι] [inst_1 : (i : ι) → AddCommMonoid (α i)]
[inst_2 : (i : ι) → PartialOrder (α i)] [∀ (i : ι), IsOrderedCancelAddMonoid (α i)],
IsOrderedCancelAddMonoid (Lex (Π₀ (i : ι), α i)) | true |
PowerSeries.mul_X_cancel | Mathlib.RingTheory.PowerSeries.Basic | ∀ {R : Type u_1} [inst : Semiring R] {φ ψ : PowerSeries R}, φ * PowerSeries.X = ψ * PowerSeries.X → φ = ψ | true |
Finset.ruzsa_triangle_inequality_add_sub_add | Mathlib.Combinatorics.Additive.PluenneckeRuzsa | ∀ {G : Type u_1} [inst : DecidableEq G] [inst_1 : AddGroup G] (A B C : Finset G),
B.card * (A + C).card ≤ (B - A).card * (B + C).card | true |
Bool.le_trans | Init.Data.Bool | ∀ {x y z : Bool}, x ≤ y → y ≤ z → x ≤ z | true |
Std.DTreeMap.Internal.Impl.Const.insertMany_cons | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {instOrd : Ord α} {β : Type v} {t : Std.DTreeMap.Internal.Impl α fun x => β} (h : t.WF)
{l : List (α × β)} {k : α} {v : β},
↑(Std.DTreeMap.Internal.Impl.Const.insertMany t ((k, v) :: l) ⋯) =
↑(Std.DTreeMap.Internal.Impl.Const.insertMany (Std.DTreeMap.Internal.Impl.insert k v t ⋯).impl l ⋯) | true |
Std.DTreeMap.Raw.getKey_modify_self | Std.Data.DTreeMap.Raw.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t : Std.DTreeMap.Raw α β cmp} [Std.TransCmp cmp]
[inst : Std.LawfulEqCmp cmp],
t.WF → ∀ [Inhabited α] {k : α} {f : β k → β k} {hc : k ∈ t.modify k f}, (t.modify k f).getKey k hc = k | true |
Subarray.size_mkSlice_ric | Init.Data.Slice.Array.Lemmas | ∀ {α : Type u_1} {xs : Subarray α} {hi : ℕ},
Std.Slice.size (Std.Ric.Sliceable.mkSlice xs *...=hi) = min (hi + 1) (Std.Slice.size xs) | true |
AddSubgroup.nsmul | Mathlib.Algebra.Group.Subgroup.Defs | {G : Type u_1} → [inst : AddGroup G] → (H : AddSubgroup G) → SMul ℕ ↥H | true |
Mathlib.Tactic.Linarith.CompSource.add.injEq | Mathlib.Tactic.Linarith.Oracle.FourierMotzkin | ∀ (a a_1 a_2 a_3 : Mathlib.Tactic.Linarith.CompSource), (a.add a_1 = a_2.add a_3) = (a = a_2 ∧ a_1 = a_3) | true |
CategoryTheory.GrothendieckTopology.Cover.Arrow.toMiddleHom | Mathlib.CategoryTheory.Sites.Grothendieck | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{J : CategoryTheory.GrothendieckTopology C} →
{X : C} → {S : J.Cover X} → {T : (I : S.Arrow) → J.Cover I.Y} → (I : (S.bind T).Arrow) → I.Y ⟶ I.middle | true |
HomologicalComplex.singleObjHomologySelfIso | Mathlib.Algebra.Homology.SingleHomology | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
[inst_1 : CategoryTheory.Limits.HasZeroMorphisms C] →
[inst_2 : CategoryTheory.Limits.HasZeroObject C] →
{ι : Type u_1} →
[inst_3 : DecidableEq ι] →
(c : ComplexShape ι) → (j : ι) → (A : C) → ((HomologicalComplex.single C c j).obj A).homology j ≅ A | true |
AlgebraicGeometry.isGermInjectiveAt_iff_of_isOpenImmersion | Mathlib.AlgebraicGeometry.SpreadingOut | ∀ {X Y : AlgebraicGeometry.Scheme} {f : X ⟶ Y} {x : ↥X} [AlgebraicGeometry.IsOpenImmersion f],
Y.IsGermInjectiveAt (f x) ↔ X.IsGermInjectiveAt x | true |
Mathlib.PrintSorries.State._sizeOf_1 | Mathlib.Util.PrintSorries | Mathlib.PrintSorries.State → ℕ | false |
AlgebraicGeometry.AffineTargetMorphismProperty.diagonal_of_openCover_source | Mathlib.AlgebraicGeometry.Morphisms.Constructors | ∀ {Q : AlgebraicGeometry.AffineTargetMorphismProperty} [Q.IsLocal] {X Y : AlgebraicGeometry.Scheme} (f : X ⟶ Y)
(𝒰 : X.OpenCover) [inst : ∀ (i : 𝒰.I₀), AlgebraicGeometry.IsAffine (𝒰.X i)] [inst_1 : AlgebraicGeometry.IsAffine Y],
(∀ (i j : 𝒰.I₀), Q (CategoryTheory.Limits.pullback.mapDesc (𝒰.f i) (𝒰.f j) f)) → Q.diagonal f | true |
AddUnits.neg_add_eq_zero._simp_1 | Mathlib.Algebra.Group.Units.Basic | ∀ {α : Type u} [inst : AddMonoid α] {u : AddUnits α} {a : α}, (↑(-u) + a = 0) = (↑u = a) | false |
Mathlib.Linter.Style.initFn._@.Mathlib.Tactic.Linter.DeprecatedSyntaxLinter.854069892._hygCtx._hyg.4 | Mathlib.Tactic.Linter.DeprecatedSyntaxLinter | IO (Lean.Option Bool) | false |
Fin.find?_eq_findRev?_iff | Batteries.Data.Fin.Lemmas | ∀ {n : ℕ} {p : Fin n → Bool}, Fin.find? p = Fin.findRev? p ↔ ∀ (i j : Fin n), p i = true → p j = true → i = j | true |
_private.Mathlib.Algebra.Group.Subgroup.Pointwise.0.Subgroup.conjAct_pointwise_smul_iff._simp_1_1 | Mathlib.Algebra.Group.Subgroup.Pointwise | ∀ {G : Type u_1} [inst : Group G] {H K : Subgroup G}, (H = K) = ∀ (x : G), x ∈ H ↔ x ∈ K | false |
Std.DTreeMap.Internal.Impl.maxKey?_eq_none_iff | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Std.DTreeMap.Internal.Impl α β} [Std.TransOrd α],
t.WF → (t.maxKey? = none ↔ t.isEmpty = true) | true |
ProbabilityTheory.defaultRatCDF_le_one | Mathlib.Probability.Kernel.Disintegration.MeasurableStieltjes | ∀ (q : ℚ), ProbabilityTheory.defaultRatCDF q ≤ 1 | true |
Lean.KeyedDeclsAttribute.OLeanEntry.mk.injEq | Lean.KeyedDeclsAttribute | ∀ (key : Lean.KeyedDeclsAttribute.Key) (declName : Lean.Name) (key_1 : Lean.KeyedDeclsAttribute.Key)
(declName_1 : Lean.Name),
({ key := key, declName := declName } = { key := key_1, declName := declName_1 }) =
(key = key_1 ∧ declName = declName_1) | true |
Std.ExtHashMap.size_diff_add_size_inter_eq_size_left | Std.Data.ExtHashMap.Lemmas | ∀ {α : Type u} {β : Type v} {x : BEq α} {x_1 : Hashable α} {m₁ m₂ : Std.ExtHashMap α β} [inst : EquivBEq α]
[inst_1 : LawfulHashable α], (m₁ \ m₂).size + (m₁ ∩ m₂).size = m₁.size | true |
Std.Rxi.Iterator.noConfusionType | Init.Data.Range.Polymorphic.RangeIterator | Sort u_1 → {α : Type u} → Std.Rxi.Iterator α → {α' : Type u} → Std.Rxi.Iterator α' → Sort u_1 | false |
_private.Lean.Meta.LetToHave.0.Lean.Meta.LetToHave.State.noConfusion | Lean.Meta.LetToHave | {P : Sort u} → {t t' : Lean.Meta.LetToHave.State✝} → t = t' → Lean.Meta.LetToHave.State.noConfusionType✝ P t t' | false |
groupCohomology.shortComplexH0 | Mathlib.RepresentationTheory.Homological.GroupCohomology.LowDegree | {k G : Type u} →
[inst : CommRing k] → [inst_1 : Group G] → Rep.{max u u_1, u, u} k G → CategoryTheory.ShortComplex (ModuleCat k) | true |
Eq.faithful_of_comp | Mathlib.CategoryTheory.Functor.FullyFaithful | ∀ {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 : CategoryTheory.Functor C D}
{G : CategoryTheory.Functor D E} {H : CategoryTheory.Functor C E} [ℋ : H.Faithful], F.comp G = H → F.Faithful | true |
_private.Mathlib.RingTheory.Nilpotent.Basic.0.isReduced_iff_pow_one_lt._simp_1_1 | Mathlib.RingTheory.Nilpotent.Basic | ∀ {R : Type u_1} [inst : MonoidWithZero R], IsReduced R = IsRadical 0 | false |
Orientation.kahler_map_complex | Mathlib.Analysis.InnerProductSpace.TwoDim | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : InnerProductSpace ℝ E] [inst_2 : Fact (Module.finrank ℝ E = 2)]
(o : Orientation ℝ E (Fin 2)) (f : E ≃ₗᵢ[ℝ] ℂ),
(Orientation.map (Fin 2) f.toLinearEquiv) o = Complex.orientation →
∀ (x y : E), (o.kahler x) y = f y * (starRingEnd ℂ) (f x) | true |
Ordinal.mul_omega0_dvd | Mathlib.SetTheory.Ordinal.Principal | ∀ {a : Ordinal.{u}}, 0 < a → a < Ordinal.omega0 → ∀ {b : Ordinal.{u}}, Ordinal.omega0 ∣ b → a * b = b | true |
Aesop.Options' | Aesop.Options.Internal | Type | true |
Algebra.Extension.Hom.id | Mathlib.RingTheory.Extension.Basic | {R : Type u} →
{S : Type v} →
[inst : CommRing R] → [inst_1 : CommRing S] → [inst_2 : Algebra R S] → (P : Algebra.Extension R S) → P.Hom P | true |
ModularForm.delta | Mathlib.NumberTheory.ModularForms.Delta | UpperHalfPlane → ℂ | true |
Mathlib.Tactic.FieldSimp.NF.«_aux_Mathlib_Tactic_FieldSimp_Lemmas___macroRules_Mathlib_Tactic_FieldSimp_NF_term_::ᵣ__1» | Mathlib.Tactic.FieldSimp.Lemmas | Lean.Macro | false |
CpltSepUniformSpace.t0Space | Mathlib.Topology.Category.UniformSpace | ∀ (X : CpltSepUniformSpace), T0Space X.toUniformSpace.carrier | true |
_private.Mathlib.Data.Nat.Fib.Basic.0.Nat.fib_strictMonoOn.match_1_1 | Mathlib.Data.Nat.Fib.Basic | ∀ (motive : (x : ℕ) → x ∈ Set.Ici 2 → (x_2 : ℕ) → x_2 ∈ Set.Ici 2 → x < x_2 → Prop) (x : ℕ) (x_1 : x ∈ Set.Ici 2)
(x_2 : ℕ) (x_3 : x_2 ∈ Set.Ici 2) (x_4 : x < x_2),
(∀ (_m : ℕ) (x : _m + 2 ∈ Set.Ici 2) (_n : ℕ) (x_5 : _n + 2 ∈ Set.Ici 2) (hmn : _m + 2 < _n + 2),
motive _m.succ.succ x _n.succ.succ x_5 hmn) →
motive x x_1 x_2 x_3 x_4 | false |
_private.Lean.Server.FileWorker.WidgetRequests.0.Lean.Widget.TaggedTextHighlightState.mk.sizeOf_spec | Lean.Server.FileWorker.WidgetRequests | ∀ (query : String) (ms : Array String.Pos.Raw) (p : String.Pos.Raw) (anyHighlight : Bool),
sizeOf { query := query, ms := ms, p := p, anyHighlight := anyHighlight } =
1 + sizeOf query + sizeOf ms + sizeOf p + sizeOf anyHighlight | true |
_private.Lean.Compiler.LCNF.Specialize.0.Lean.Compiler.LCNF.Specialize.specializeApp?.match_19 | Lean.Compiler.LCNF.Specialize | (motive : Lean.Compiler.LCNF.LetValue Lean.Compiler.LCNF.Purity.pure → Sort u_1) →
(e : Lean.Compiler.LCNF.LetValue Lean.Compiler.LCNF.Purity.pure) →
((declName : Lean.Name) →
(us : List Lean.Level) →
(args : Array (Lean.Compiler.LCNF.Arg Lean.Compiler.LCNF.Purity.pure)) →
motive (Lean.Compiler.LCNF.LetValue.const declName us args ⋯)) →
((x : Lean.Compiler.LCNF.LetValue Lean.Compiler.LCNF.Purity.pure) → motive x) → motive e | false |
_private.Mathlib.NumberTheory.LucasLehmer.0.mersenne_mod_eight._proof_1_1 | Mathlib.NumberTheory.LucasLehmer | ∀ (n : ℕ), mersenne n % 8 = 7 → (2 * mersenne n + 1) % 8 = 7 | false |
_private.Mathlib.Combinatorics.SimpleGraph.Regularity.Chunk.0.SzemerediRegularity.edgeDensity_chunk_aux | Mathlib.Combinatorics.SimpleGraph.Regularity.Chunk | ∀ {α : Type u_1} [inst : Fintype α] [inst_1 : DecidableEq α] {P : Finpartition Finset.univ} {G : SimpleGraph α}
[inst_2 : DecidableRel G.Adj] {ε : ℝ} {U V : Finset α} [Nonempty α] (hP : P.IsEquipartition),
P.parts.card * 16 ^ P.parts.card ≤ Fintype.card α →
100 ≤ 4 ^ P.parts.card * ε ^ 5 →
∀ (hU : U ∈ P.parts) (hV : V ∈ P.parts),
↑(G.edgeDensity U V) ^ 2 - ε ^ 5 / 25 ≤
((∑ ab ∈ (SzemerediRegularity.chunk hP G ε hU).parts.product (SzemerediRegularity.chunk hP G ε hV).parts,
↑(G.edgeDensity ab.1 ab.2)) /
16 ^ P.parts.card) ^
2 | true |
MonomialOrder.degLex_single_lt_iff | Mathlib.Data.Finsupp.MonomialOrder.DegLex | ∀ {σ : Type u_2} [inst : LinearOrder σ] [inst_1 : WellFoundedGT σ] {a b : σ},
((MonomialOrder.degLex.toSyn fun₀ | a => 1) < MonomialOrder.degLex.toSyn fun₀ | b => 1) ↔ b < a | true |
Lean.Meta.Grind.Arith.Linear.RingEqCnstr.mk.sizeOf_spec | Lean.Meta.Tactic.Grind.Arith.Linear.Types | ∀ (p : Lean.Grind.CommRing.Poly) (h : Lean.Meta.Grind.Arith.Linear.RingEqCnstrProof),
sizeOf { p := p, h := h } = 1 + sizeOf p + sizeOf h | true |
MeasureTheory.Lp.boundedContinuousFunction._proof_1 | Mathlib.MeasureTheory.Function.LpSpace.ContinuousFunctions | ∀ (E : Type u_1) [inst : NormedAddCommGroup E], IsTopologicalAddGroup E | false |
_private.Mathlib.Algebra.Star.RingQuot.0.RingQuot.starRing._proof_1 | Mathlib.Algebra.Star.RingQuot | ∀ {R : Type u_1} [inst : Semiring R] [inst_1 : StarRing R] (r : R → R → Prop)
(hr : ∀ (a b : R), r a b → r (star a) (star b)) (x : RingQuot r), RingQuot.star'✝ r hr (RingQuot.star'✝¹ r hr x) = x | false |
Lean.Widget.instToJsonRpcEncodablePacket._@.Lean.Server.FileWorker.WidgetRequests.433270988._hygCtx._hyg.30 | Lean.Server.FileWorker.WidgetRequests | Lean.ToJson Lean.Widget.RpcEncodablePacket✝ | false |
WithBot.unbotD_eq_iff | Mathlib.Order.WithBot | ∀ {α : Type u_1} {d y : α} {x : WithBot α}, WithBot.unbotD d x = y ↔ x = ↑y ∨ x = ⊥ ∧ y = d | true |
TopCat.conePtOfConeForget | Mathlib.Topology.Category.TopCat.Limits.Basic | {J : Type v} →
[inst : CategoryTheory.Category.{w, v} J] →
{F : CategoryTheory.Functor J TopCat} → CategoryTheory.Limits.Cone (F.comp (CategoryTheory.forget TopCat)) → Type u | true |
LinearMap.BilinForm.dualSubmodule._proof_3 | Mathlib.LinearAlgebra.BilinearForm.DualLattice | ∀ {R : Type u_2} {S : Type u_1} {M : Type u_3} [inst : CommRing R] [inst_1 : Field S] [inst_2 : AddCommGroup M]
[inst_3 : Algebra R S] [inst_4 : Module R M] [inst_5 : Module S M] [IsScalarTower R S M] (B : LinearMap.BilinForm S M)
(N : Submodule R M) (r : R), ∀ a ∈ {x | ∀ y ∈ N, (B x) y ∈ 1}, ∀ y ∈ N, (B (r • a)) y ∈ 1 | false |
_private.Mathlib.Combinatorics.Matroid.Sum.0.Matroid.sigma._simp_8 | Mathlib.Combinatorics.Matroid.Sum | ∀ {α : Type u_1} {β : α → Type u_4} {p : (a : α) × β a → Prop},
(∀ (x : (a : α) × β a), p x) = ∀ (a : α) (b : β a), p ⟨a, b⟩ | false |
RootPairing.EmbeddedG2.twoShortAddLongRoot_eq | 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],
RootPairing.EmbeddedG2.twoShortAddLongRoot P =
2 • RootPairing.EmbeddedG2.shortRoot P + RootPairing.EmbeddedG2.longRoot P | true |
_private.Mathlib.Topology.UniformSpace.Basic.0.Filter.HasBasis.uniformSpace_eq_bot._simp_1_1 | Mathlib.Topology.UniformSpace.Basic | ∀ {α : Type ua} {u : UniformSpace α}, (u = ⊥) = (SetRel.id ∈ uniformity α) | false |
CategoryTheory.ShortComplex.RightHomologyData.ofHasCokernelOfHasKernel._proof_1 | Mathlib.Algebra.Homology.ShortComplex.RightHomology | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
(S : CategoryTheory.ShortComplex C) [inst_2 : CategoryTheory.Limits.HasCokernel S.f],
CategoryTheory.CategoryStruct.comp S.f (CategoryTheory.Limits.cokernel.π S.f) = 0 | false |
Lean.Parser.Term.doAssert.formatter | Lean.Parser.Do | Lean.PrettyPrinter.Formatter | true |
CategoryTheory.PreGaloisCategory.natTrans_ext_of_isGalois | Mathlib.CategoryTheory.Galois.Decomposition | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{u₂, u₁} C] [inst_1 : CategoryTheory.GaloisCategory C]
(F : CategoryTheory.Functor C FintypeCat) [CategoryTheory.PreGaloisCategory.FiberFunctor F]
{G : CategoryTheory.Functor C FintypeCat} {t s : F ⟶ G},
(∀ (X : C) [CategoryTheory.PreGaloisCategory.IsGalois X], t.app X = s.app X) → t = s | true |
CategoryTheory.GrothendieckTopology.arrow_trans | Mathlib.CategoryTheory.Sites.Grothendieck | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y : C} (J : CategoryTheory.GrothendieckTopology C)
(f : Y ⟶ X) (S R : CategoryTheory.Sieve X),
J.Covers S f → (∀ {Z : C} (g : Z ⟶ X), S.arrows g → J.Covers R g) → J.Covers R f | true |
Std.Iter.all_eq_match_step | Init.Data.Iterators.Lemmas.Consumers.Loop | ∀ {α β : Type w} [inst : Std.Iterator α Id β] [Std.Iterators.Finite α Id] [inst_2 : Std.IteratorLoop α Id Id]
[Std.LawfulIteratorLoop α Id Id] {it : Std.Iter β} {p : β → Bool},
Std.Iter.all p it =
match ↑it.step with
| Std.IterStep.yield it' x => if p x = true then Std.Iter.all p it' else false
| Std.IterStep.skip it' => Std.Iter.all p it'
| Std.IterStep.done => true | true |
BitVec.toNat_intMin_of_pos | Init.Data.BitVec.Lemmas | ∀ {w : ℕ}, 0 < w → (BitVec.intMin w).toNat = 2 ^ (w - 1) | true |
PMF.apply_ne_top | Mathlib.Probability.ProbabilityMassFunction.Basic | ∀ {α : Type u_1} (p : PMF α) (a : α), p a ≠ ⊤ | true |
QuotientGroup.quotientMapSubgroupOfOfLe._proof_1 | Mathlib.GroupTheory.QuotientGroup.Basic | ∀ {G : Type u_1} [inst : Group G] {A' A B' : Subgroup G},
A' ≤ B' → Subgroup.comap A.subtype A' ≤ Subgroup.comap A.subtype B' | false |
Algebra.TensorProduct.opAlgEquiv._proof_15 | Mathlib.LinearAlgebra.TensorProduct.Opposite | ∀ (R : Type u_1) (S : Type u_2) (A : Type u_3) [inst : CommSemiring R] [inst_1 : CommSemiring S] [inst_2 : Semiring A]
[inst_3 : Algebra R S] [inst_4 : Algebra R A] [inst_5 : Algebra S A] [IsScalarTower R S A], SMulCommClass R S Aᵐᵒᵖ | false |
Std.TreeSet.Raw.min!_le_of_mem | Std.Data.TreeSet.Raw.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t : Std.TreeSet.Raw α cmp} [Std.TransCmp cmp] [inst : Inhabited α],
t.WF → ∀ {k : α}, k ∈ t → (cmp t.min! k).isLE = true | true |
SeminormedCommGroup.recOn | Mathlib.Analysis.Normed.Group.Defs | {E : Type u_8} →
{motive : SeminormedCommGroup E → Sort u} →
(t : SeminormedCommGroup E) →
([toNorm : Norm E] →
[toCommGroup : CommGroup E] →
[toPseudoMetricSpace : PseudoMetricSpace E] →
(dist_eq : ∀ (x y : E), dist x y = ‖x⁻¹ * y‖) →
motive
{ toNorm := toNorm, toCommGroup := toCommGroup, toPseudoMetricSpace := toPseudoMetricSpace,
dist_eq := dist_eq }) →
motive t | false |
_private.Mathlib.MeasureTheory.Integral.IntervalIntegral.AbsolutelyContinuousFun.0.AbsolutelyContinuousOnInterval.dist_le_of_pairwiseDisjoint_hasSum._simp_1_8 | Mathlib.MeasureTheory.Integral.IntervalIntegral.AbsolutelyContinuousFun | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} {f : α → β} {g : β → γ} {a : Filter α} {c : Filter γ},
Filter.Tendsto f a (Filter.comap g c) = Filter.Tendsto (g ∘ f) a c | false |
MeasurablePow.mk | Mathlib.MeasureTheory.Group.Arithmetic | ∀ {β : Type u_2} {γ : Type u_3} [inst : MeasurableSpace β] [inst_1 : MeasurableSpace γ] [inst_2 : Pow β γ],
(Measurable fun p => p.1 ^ p.2) → MeasurablePow β γ | true |
AddCircle.equivIccQuot_comp_mk_eq_toIcoMod | Mathlib.Topology.Instances.AddCircle.Defs | ∀ {𝕜 : Type u_1} [inst : AddCommGroup 𝕜] [inst_1 : LinearOrder 𝕜] [inst_2 : IsOrderedAddMonoid 𝕜] (p a : 𝕜)
[hp : Fact (0 < p)] [inst_3 : Archimedean 𝕜],
⇑(AddCircle.equivIccQuot p a) ∘ Quotient.mk'' = fun x => Quot.mk (AddCircle.EndpointIdent p a) ⟨toIcoMod ⋯ a x, ⋯⟩ | true |
Circle.exp_two_pi_mul_int | Mathlib.Analysis.SpecialFunctions.Complex.Circle | ∀ (n : ℤ), Circle.exp (2 * Real.pi * ↑n) = 1 | true |
List.mem_merge | Init.Data.List.Sort.Lemmas | ∀ {α : Type u_1} {le : α → α → Bool} {a : α} {xs ys : List α}, a ∈ xs.merge ys le ↔ a ∈ xs ∨ a ∈ ys | true |
Algebra.SubmersivePresentation.basisKaehlerOfIsCompl.congr_simp | Mathlib.RingTheory.Smooth.StandardSmoothCotangent | ∀ {R : Type u_1} {S : Type u_2} {ι : Type u_3} {σ : Type u_4} [inst : CommRing R] [inst_1 : CommRing S]
[inst_2 : Algebra R S] [inst_3 : Finite σ] (P P_1 : Algebra.SubmersivePresentation R S ι σ) (e_P : P = P_1)
{κ : Type u_5} {f f_1 : κ → ι} (e_f : f = f_1) (hf : Function.Injective f)
(hcompl : IsCompl (Set.range f) (Set.range P.map)), P.basisKaehlerOfIsCompl hf hcompl = P_1.basisKaehlerOfIsCompl ⋯ ⋯ | true |
_private.Init.Grind.Ordered.Int.0.Lean.Grind.instLawfulOrderLTInt._proof_1 | Init.Grind.Ordered.Int | ∀ (a b : ℤ), ¬(a < b ↔ a ≤ b ∧ ¬b ≤ a) → False | false |
_private.Mathlib.RingTheory.Extension.Cotangent.BaseChange.0.Algebra.Extension.tensorCotangentSpace._proof_13 | Mathlib.RingTheory.Extension.Cotangent.BaseChange | ∀ {R : Type u_1} {S : Type u_3} [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S]
(P : Algebra.Extension R S), SMulCommClass R R P.Ring | false |
enorm_norm | Mathlib.Analysis.Normed.Group.Real | ∀ {E : Type u_5} [inst : SeminormedAddCommGroup E] (x : E), ‖‖x‖‖ₑ = ‖x‖ₑ | true |
apply_ite_left | Mathlib.Logic.Basic | ∀ {α : Sort u_3} {β : Sort u_4} {γ : Sort u_5} (f : α → β → γ) (P : Prop) [inst : Decidable P] (x y : α) (z : β),
f (if P then x else y) z = if P then f x z else f y z | true |
Set.inv_mem_centralizer._simp_2 | Mathlib.Algebra.Group.Center | ∀ {M : Type u_1} {S : Set M} [inst : Group M] {a : M}, a ∈ S.centralizer → (a⁻¹ ∈ S.centralizer) = True | false |
ENNReal.zpow_sub | Mathlib.Data.ENNReal.Inv | ∀ {x : ENNReal}, x ≠ 0 → x ≠ ⊤ → ∀ (m n : ℤ), x ^ (m - n) = x ^ m * (x ^ n)⁻¹ | true |
ProfiniteAddGrp.mk.inj | Mathlib.Topology.Algebra.Category.ProfiniteGrp.Basic | ∀ {toProfinite : Profinite} {addGroup : AddGroup ↑toProfinite.toTop}
{topologicalAddGroup : IsTopologicalAddGroup ↑toProfinite.toTop} {toProfinite_1 : Profinite}
{addGroup_1 : AddGroup ↑toProfinite_1.toTop} {topologicalAddGroup_1 : IsTopologicalAddGroup ↑toProfinite_1.toTop},
{ toProfinite := toProfinite, addGroup := addGroup, topologicalAddGroup := topologicalAddGroup } =
{ toProfinite := toProfinite_1, addGroup := addGroup_1, topologicalAddGroup := topologicalAddGroup_1 } →
toProfinite = toProfinite_1 ∧ addGroup ≍ addGroup_1 | true |
Nat.lcm_mul_right_right_eq_mul_of_lcm_eq_mul | Init.Data.Nat.Lcm | ∀ {n m k : ℕ}, n.lcm m = n * m → n.lcm (m * k) = n.lcm k * m | true |
_private.Init.Data.Range.Polymorphic.Lemmas.0.Std.Rxc.Iterator.toList_eq_match.match_1.eq_2 | Init.Data.Range.Polymorphic.Lemmas | ∀ {α : Type u_1} (motive : Option α → Sort u_2) (a : α) (h_1 : Unit → motive none) (h_2 : (a : α) → motive (some a)),
(match some a with
| none => h_1 ()
| some a => h_2 a) =
h_2 a | true |
LinearPMap.add_domain | Mathlib.LinearAlgebra.LinearPMap | ∀ {R : Type u_1} [inst : Ring R] {E : Type u_2} [inst_1 : AddCommGroup E] [inst_2 : Module R E] {F : Type u_3}
[inst_3 : AddCommGroup F] [inst_4 : Module R F] (f g : E →ₗ.[R] F), (f + g).domain = f.domain ⊓ g.domain | true |
_private.Init.Data.Range.Polymorphic.NatLemmas.0.Nat.toList_rcc_eq_cons_iff._proof_1_1 | Init.Data.Range.Polymorphic.NatLemmas | ∀ {m n a : ℕ}, m = a → ¬(m < n + 1 ↔ m ≤ n) → False | false |
MeasureTheory.Integrable.enorm_toL1 | Mathlib.MeasureTheory.Function.L1Space.AEEqFun | ∀ {α : Type u_1} {β : Type u_2} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} [inst : NormedAddCommGroup β]
{f : α → β} (hf : MeasureTheory.Integrable f μ), ‖MeasureTheory.Integrable.toL1 f hf‖ₑ = ∫⁻ (a : α), ‖f a‖ₑ ∂μ | true |
Polynomial.wfDvdMonoid | Mathlib.RingTheory.Polynomial.UniqueFactorization | ∀ {R : Type u_1} [inst : CommSemiring R] [NoZeroDivisors R] [WfDvdMonoid R], WfDvdMonoid (Polynomial R) | true |
Field.inv_zero | Mathlib.Algebra.Field.Defs | ∀ {K : Type u} [self : Field K], 0⁻¹ = 0 | true |
LinearPMap.instVAdd | Mathlib.LinearAlgebra.LinearPMap | {R : Type u_1} →
[inst : Ring R] →
{E : Type u_2} →
[inst_1 : AddCommGroup E] →
[inst_2 : Module R E] →
{F : Type u_3} → [inst_3 : AddCommGroup F] → [inst_4 : Module R F] → VAdd (E →ₗ[R] F) (E →ₗ.[R] F) | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.