name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
_private.Lean.Meta.Tactic.Grind.Arith.Cutsat.Proof.0.Lean.Meta.Grind.Arith.Cutsat.EqCnstr.collectDecVars.match_1 | Lean.Meta.Tactic.Grind.Arith.Cutsat.Proof | (motive : Lean.Meta.Grind.Arith.Cutsat.EqCnstrProof → Sort u_1) →
(x : Lean.Meta.Grind.Arith.Cutsat.EqCnstrProof) →
((a zero : Lean.Expr) → motive (Lean.Meta.Grind.Arith.Cutsat.EqCnstrProof.core0 a zero)) →
((a b : Lean.Expr) →
(p₁ p₂ : Int.Linear.Poly) → motive (Lean.Meta.Grind.Arith.Cutsat.EqCns... | false |
ProofWidgets.RpcEncodablePacket.«_@».ProofWidgets.Component.Basic.2277670097._hygCtx._hyg.1.noConfusion | ProofWidgets.Component.Basic | {P : Sort u} →
{t t' : ProofWidgets.RpcEncodablePacket✝} →
t = t' →
ProofWidgets.RpcEncodablePacket.«_@».ProofWidgets.Component.Basic.2277670097._hygCtx._hyg.1.noConfusionType P t t' | false |
Lean.guardMsgsPositions | Init.Notation | Lean.ParserDescr | true |
subset_tangentConeAt_prod_left | Mathlib.Analysis.Calculus.TangentCone.Prod | ∀ {𝕜 : Type u_1} {E : Type u_2} {F : Type u_3} [inst : Semiring 𝕜] [inst_1 : AddCommGroup E] [inst_2 : Module 𝕜 E]
[inst_3 : TopologicalSpace E] [ContinuousAdd E] [ContinuousConstSMul 𝕜 E] [inst_6 : AddCommGroup F]
[inst_7 : Module 𝕜 F] [inst_8 : TopologicalSpace F] [ContinuousAdd F] [ContinuousConstSMul 𝕜 F]... | true |
AlgebraicGeometry.Scheme.kerAdjunction_counit_app | Mathlib.AlgebraicGeometry.IdealSheaf.Subscheme | ∀ (Y : AlgebraicGeometry.Scheme) (f : (CategoryTheory.Over Y)ᵒᵖ),
Y.kerAdjunction.counit.app f =
(CategoryTheory.Over.homMk (AlgebraicGeometry.Scheme.Hom.toImage (Opposite.unop f).hom) ⋯).op | true |
ZFSet.card_empty | Mathlib.SetTheory.ZFC.Cardinal | ∅.card = 0 | true |
SeparatelyContinuousMul.rec | Mathlib.Topology.Algebra.Monoid.Defs | {M : Type u_1} →
[inst : TopologicalSpace M] →
[inst_1 : Mul M] →
{motive : SeparatelyContinuousMul M → Sort u} →
((continuous_const_mul : ∀ {a : M}, Continuous fun x => a * x) →
(continuous_mul_const : ∀ {a : M}, Continuous fun x => x * a) → motive ⋯) →
(t : SeparatelyContinuo... | false |
Subring.mem_toSubsemiring._simp_1 | Mathlib.Algebra.Ring.Subring.Defs | ∀ {R : Type u} [inst : NonAssocRing R] {s : Subring R} {x : R}, (x ∈ s.toSubsemiring) = (x ∈ s) | false |
Lean.Syntax.ident.inj | Init.Core | ∀ {info : Lean.SourceInfo} {rawVal : Substring.Raw} {val : Lean.Name} {preresolved : List Lean.Syntax.Preresolved}
{info_1 : Lean.SourceInfo} {rawVal_1 : Substring.Raw} {val_1 : Lean.Name}
{preresolved_1 : List Lean.Syntax.Preresolved},
Lean.Syntax.ident info rawVal val preresolved = Lean.Syntax.ident info_1 rawV... | true |
CliffordAlgebra.reverse_mem_evenOdd_iff | Mathlib.LinearAlgebra.CliffordAlgebra.Conjugation | ∀ {R : Type u_1} [inst : CommRing R] {M : Type u_2} [inst_1 : AddCommGroup M] [inst_2 : Module R M]
(Q : QuadraticForm R M) {x : CliffordAlgebra Q} {n : ZMod 2},
CliffordAlgebra.reverse x ∈ CliffordAlgebra.evenOdd Q n ↔ x ∈ CliffordAlgebra.evenOdd Q n | true |
_private.Lean.Meta.LetToHave.0.Lean.Meta.LetToHave.State.rec | Lean.Meta.LetToHave | {motive : Lean.Meta.LetToHave.State✝ → Sort u} →
((count : ℕ) →
(results : Std.HashMap Lean.ExprStructEq Lean.Meta.LetToHave.Result✝) →
motive { count := count, results := results }) →
(t : Lean.Meta.LetToHave.State✝¹) → motive t | false |
QuadraticAlgebra.algebraMap_norm_eq_mul_star | Mathlib.Algebra.QuadraticAlgebra.Basic | ∀ {R : Type u_1} {a b : R} [inst : CommRing R] (z : QuadraticAlgebra R a b),
(algebraMap R (QuadraticAlgebra R a b)) (QuadraticAlgebra.norm z) = z * star z | true |
Module.DirectLimit.addCommGroup._proof_12 | Mathlib.Algebra.Colimit.Module | ∀ {R : Type u_1} [inst : Semiring R] {ι : Type u_2} [inst_1 : Preorder ι] [inst_2 : DecidableEq ι] (G : ι → Type u_3)
[inst_3 : (i : ι) → AddCommGroup (G i)] [inst_4 : (i : ι) → Module R (G i)] (f : (i j : ι) → i ≤ j → G i →ₗ[R] G j)
(a b : Module.DirectLimit G f), a + b = b + a | false |
_private.Mathlib.Order.Filter.Bases.Finite.0.Filter.hasBasis_generate._simp_1_1 | Mathlib.Order.Filter.Bases.Finite | ∀ {α : Type u} {s : Set (Set α)} {U : Set α}, (U ∈ Filter.generate s) = ∃ t ⊆ s, t.Finite ∧ ⋂₀ t ⊆ U | false |
HahnSeries.orderTop_embDomain | Mathlib.RingTheory.HahnSeries.Basic | ∀ {Γ' : Type u_2} {R : Type u_3} [inst : Zero R] [inst_1 : PartialOrder Γ'] {Γ : Type u_5} [inst_2 : LinearOrder Γ]
{f : Γ ↪o Γ'} {x : HahnSeries Γ R}, (HahnSeries.embDomain f x).orderTop = WithTop.map (⇑f) x.orderTop | true |
orthogonalFamily_iff_pairwise | Mathlib.Analysis.InnerProductSpace.Orthogonal | ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : RCLike 𝕜] [inst_1 : NormedAddCommGroup E] [inst_2 : InnerProductSpace 𝕜 E]
{ι : Type u_4} {V : ι → Submodule 𝕜 E},
(OrthogonalFamily 𝕜 (fun i => ↥(V i)) fun i => (V i).subtypeₗᵢ) ↔ Pairwise (Function.onFun (fun x1 x2 => x1 ⟂ x2) V) | true |
ProofWidgets.MakeEditLinkProps.ctorIdx | ProofWidgets.Component.MakeEditLink | ProofWidgets.MakeEditLinkProps → ℕ | false |
Int.zsmul_eq_mul | Mathlib.Algebra.Group.Int.Defs | ∀ (n a : ℤ), n • a = n * a | true |
_private.Lean.Elab.PreDefinition.Structural.FindRecArg.0.Lean.Elab.Structural.nonIndicesFirst.match_1 | Lean.Elab.PreDefinition.Structural.FindRecArg | (motive : Array Lean.Elab.Structural.RecArgInfo × Array Lean.Elab.Structural.RecArgInfo → Sort u_1) →
(x : Array Lean.Elab.Structural.RecArgInfo × Array Lean.Elab.Structural.RecArgInfo) →
((indices nonIndices : Array Lean.Elab.Structural.RecArgInfo) → motive (indices, nonIndices)) → motive x | false |
MeromorphicOn.neg | Mathlib.Analysis.Meromorphic.Basic | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_3} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {f : 𝕜 → E} {U : Set 𝕜}, MeromorphicOn f U → MeromorphicOn (-f) U | true |
List.nil_lt_cons | Init.Data.List.Lex | ∀ {α : Type u_1} [inst : LT α] (a : α) (l : List α), [] < a :: l | true |
_private.Init.Grind.Ring.CommSolver.0.Lean.Grind.CommRing.instBEqMon.beq.match_1.eq_1 | Init.Grind.Ring.CommSolver | ∀ (motive : Lean.Grind.CommRing.Mon → Lean.Grind.CommRing.Mon → Sort u_1)
(h_1 : Unit → motive Lean.Grind.CommRing.Mon.unit Lean.Grind.CommRing.Mon.unit)
(h_2 :
(a : Lean.Grind.CommRing.Power) →
(a_1 : Lean.Grind.CommRing.Mon) →
(b : Lean.Grind.CommRing.Power) →
(b_1 : Lean.Grind.CommRin... | true |
enorm_mul_le' | Mathlib.Analysis.Normed.Group.Basic | ∀ {E : Type u_8} [inst : TopologicalSpace E] [inst_1 : ESeminormedMonoid E] (a b : E), ‖a * b‖ₑ ≤ ‖a‖ₑ + ‖b‖ₑ | true |
CategoryTheory.Bicategory.postcomposing._proof_2 | Mathlib.CategoryTheory.Bicategory.Basic | ∀ {B : Type u_2} [inst : CategoryTheory.Bicategory B] (a b c : B) {X Y : b ⟶ c} (η : X ⟶ Y) ⦃X_1 Y_1 : a ⟶ b⦄
(f : X_1 ⟶ Y_1),
CategoryTheory.CategoryStruct.comp ((CategoryTheory.Bicategory.postcomp a X).map f)
(CategoryTheory.Bicategory.whiskerLeft Y_1 η) =
CategoryTheory.CategoryStruct.comp (CategoryThe... | false |
Finset.Ioi_nonempty | Mathlib.Order.Interval.Finset.Basic | ∀ {α : Type u_2} {a : α} [inst : Preorder α] [inst_1 : LocallyFiniteOrderTop α], (Finset.Ioi a).Nonempty ↔ ¬IsMax a | true |
ContinuousStar.rec | Mathlib.Topology.Algebra.Star | {R : Type u_1} →
[inst : TopologicalSpace R] →
[inst_1 : Star R] →
{motive : ContinuousStar R → Sort u} →
((continuous_star : Continuous star) → motive ⋯) → (t : ContinuousStar R) → motive t | false |
ValuativeRel.valueSetoid._proof_1 | Mathlib.RingTheory.Valuation.ValuativeRel.Basic | ∀ (R : Type u_1) [inst : CommRing R] [inst_1 : ValuativeRel R],
Equivalence fun x x_1 =>
match x with
| (x, s) =>
match x_1 with
| (y, t) => x * ↑t ≤ᵥ y * ↑s ∧ y * ↑s ≤ᵥ x * ↑t | false |
Std.LawfulOrderLT | Init.Data.Order.Classes | (α : Type u) → [LT α] → [LE α] → Prop | true |
LinearGrowth.tendsto_atTop_of_linearGrowthInf_natCast_pos | Mathlib.Analysis.Asymptotics.LinearGrowth | ∀ {v : ℕ → ℕ}, (LinearGrowth.linearGrowthInf fun n => ↑(v n)) ≠ 0 → Filter.Tendsto v Filter.atTop Filter.atTop | true |
IsTotallySeparated.isTotallyDisconnected | Mathlib.Topology.Connected.TotallyDisconnected | ∀ {α : Type u} [inst : TopologicalSpace α] {s : Set α}, IsTotallySeparated s → IsTotallyDisconnected s | true |
Int.reduceBdiv._regBuiltin.Int.reduceBdiv.declare_1._@.Lean.Meta.Tactic.Simp.BuiltinSimprocs.Int.1571464712._hygCtx._hyg.16 | Lean.Meta.Tactic.Simp.BuiltinSimprocs.Int | IO Unit | false |
LinearMap.smulRight_zero | Mathlib.Algebra.Module.LinearMap.End | ∀ {R : Type u_1} {S : Type u_3} {M : Type u_4} {M₁ : Type u_5} [inst : Semiring R] [inst_1 : AddCommMonoid M]
[inst_2 : AddCommMonoid M₁] [inst_3 : Module R M] [inst_4 : Module R M₁] [inst_5 : Semiring S] [inst_6 : Module R S]
[inst_7 : Module S M] [inst_8 : IsScalarTower R S M] (f : M₁ →ₗ[R] S), f.smulRight 0 = 0 | true |
ApplicativeTransformation.mk.sizeOf_spec | Mathlib.Control.Traversable.Basic | ∀ {F : Type u → Type v} [inst : Applicative F] {G : Type u → Type w} [inst_1 : Applicative G]
[inst_2 : (a : Type u) → SizeOf (F a)] [inst_3 : (a : Type u) → SizeOf (G a)] (app : (α : Type u) → F α → G α)
(preserves_pure' : ∀ {α : Type u} (x : α), app α (pure x) = pure x)
(preserves_seq' : ∀ {α β : Type u} (x : F... | true |
ENNReal.eq_of_forall_nnreal_iff | Mathlib.Data.ENNReal.Inv | ∀ {x y : ENNReal}, (∀ (r : NNReal), ↑r ≤ x ↔ ↑r ≤ y) → x = y | true |
DirectLimit.instDivisionSemiring._proof_15 | 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 : (... | false |
toLexMulEquiv.eq_1 | Mathlib.Algebra.Order.Group.Equiv | ∀ (α : Type u_1) [inst : Mul α], toLexMulEquiv α = { toEquiv := toLex, map_mul' := ⋯ } | true |
ContDiffAt.snd' | Mathlib.Analysis.Calculus.ContDiff.Comp | ∀ {𝕜 : Type u_1} {E : Type u_2} {F : Type u_3} {G : Type u_4} [inst : NontriviallyNormedField 𝕜]
[inst_1 : NormedAddCommGroup E] [inst_2 : NormedSpace 𝕜 E] [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F]
[inst_5 : NormedAddCommGroup G] [inst_6 : NormedSpace 𝕜 G] {n : WithTop ℕ∞} {f : F → G} {x : E} ... | true |
_private.Std.Data.DTreeMap.Internal.Model.0.Std.DTreeMap.Internal.Impl.updateCell._proof_19 | Std.Data.DTreeMap.Internal.Model | ∀ {α : Type u_1} {β : α → Type u_2} (k' : α) (v' : β k'),
Std.DTreeMap.Internal.Impl.leaf.size - 1 ≤
(Std.DTreeMap.Internal.Impl.inner 1 k' v' Std.DTreeMap.Internal.Impl.leaf Std.DTreeMap.Internal.Impl.leaf).size | false |
IsSelfAdjoint.toReal_spectralRadius_eq_norm | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Order | ∀ {A : Type u_1} [inst : CStarAlgebra A] {a : A}, IsSelfAdjoint a → (spectralRadius ℝ a).toReal = ‖a‖ | true |
AlgebraicGeometry.Scheme.JointlySurjective.recOn | Mathlib.AlgebraicGeometry.Cover.MorphismProperty | {K : CategoryTheory.Precoverage AlgebraicGeometry.Scheme} →
{motive : AlgebraicGeometry.Scheme.JointlySurjective K → Sort u_1} →
(t : AlgebraicGeometry.Scheme.JointlySurjective K) →
((exists_eq : ∀ {X : AlgebraicGeometry.Scheme}, ∀ S ∈ K.coverings X, ∀ (x : ↥X), ∃ Y g, S g ∧ x ∈ Set.range ⇑g) →
mo... | false |
contMDiffWithinAt_iff_of_mem_source' | Mathlib.Geometry.Manifold.ContMDiff.Defs | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {H : Type u_3} [inst_3 : TopologicalSpace H] {I : ModelWithCorners 𝕜 E H} {M : Type u_4}
[inst_4 : TopologicalSpace M] [inst_5 : ChartedSpace H M] {E' : Type u_5} [inst_6 : NormedAddComm... | true |
_private.Mathlib.Topology.Algebra.InfiniteSum.ConditionalInt.0.SummationFilter.symmetricIcc_eq_symmetricIoo_int._proof_1_13 | Mathlib.Topology.Algebra.InfiniteSum.ConditionalInt | ∀ (s : Set (Finset ℤ)),
(∃ a, ∀ (b : ℕ), a ≤ b → Finset.Icc (-↑b) ↑b ∈ s) →
∀ (a b : ℕ), a + 1 ≤ b → ∀ (a_1 : ℤ), -↑b < a_1 ∧ a_1 < ↑b ↔ -↑(b - 1) ≤ a_1 ∧ a_1 ≤ ↑(b - 1) | false |
CategoryTheory.MorphismProperty.instIsStableUnderTransfiniteCompositionOfShapeFunctorFunctorCategoryOfHasIterationOfShape | Mathlib.CategoryTheory.MorphismProperty.FunctorCategory | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {W : CategoryTheory.MorphismProperty C} (K : Type u')
[inst_1 : LinearOrder K] [inst_2 : SuccOrder K] [inst_3 : OrderBot K] [inst_4 : WellFoundedLT K]
[W.IsStableUnderTransfiniteCompositionOfShape K] (J : Type u'') [inst_6 : CategoryTheory.Category.{v'', u''}... | true |
_private.Mathlib.RingTheory.MvPowerSeries.LexOrder.0.MvPowerSeries.exists_finsupp_eq_lexOrder_of_ne_zero._simp_1_2 | Mathlib.RingTheory.MvPowerSeries.LexOrder | ∀ {α : Type u_1} {x : WithTop α}, (x ≠ ⊤) = ∃ a, ↑a = x | false |
RingHom.mk'._proof_4 | Mathlib.Algebra.Ring.Hom.Defs | ∀ {α : Type u_2} {β : Type u_1} [inst : NonAssocSemiring α] [inst_1 : NonAssocRing β] (f : α →* β)
(map_add : ∀ (a b : α), f (a + b) = f a + f b) (x y : α),
(↑(AddMonoidHom.mk' (⇑f) map_add)).toFun (x + y) =
(↑(AddMonoidHom.mk' (⇑f) map_add)).toFun x + (↑(AddMonoidHom.mk' (⇑f) map_add)).toFun y | false |
_private.Mathlib.Data.List.Basic.0.List.mem_getLast?_eq_getLast._proof_1_14 | Mathlib.Data.List.Basic | ∀ {α : Type u_1} (a b : α) (l : List α), ¬(a :: b :: l).length - 1 = 0 → (a :: b :: l).length - 2 < (b :: l).length | false |
Ring.KrullDimLE.subsingleton_primeSpectrum | Mathlib.RingTheory.KrullDimension.Zero | ∀ (R : Type u_1) [inst : CommSemiring R] [Ring.KrullDimLE 0 R] [IsLocalRing R], Subsingleton (PrimeSpectrum R) | true |
id_tensor_π_preserves_coequalizer_inv_colimMap_desc | Mathlib.CategoryTheory.Monoidal.Bimod | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.MonoidalCategory C]
[inst_2 : CategoryTheory.Limits.HasCoequalizers C]
[inst_3 :
∀ (X : C),
CategoryTheory.Limits.PreservesColimitsOfSize.{0, 0, v₁, v₁, u₁, u₁}
(CategoryTheory.MonoidalCategory.tensorLeft X)]
{X... | true |
_private.Lean.Compiler.LCNF.Internalize.0.Lean.Compiler.LCNF.Internalize.internalizeCodeDecl.match_4 | Lean.Compiler.LCNF.Internalize | {pu : Lean.Compiler.LCNF.Purity} →
(motive : Lean.Compiler.LCNF.CodeDecl pu → Sort u_1) →
(decl : Lean.Compiler.LCNF.CodeDecl pu) →
((decl : Lean.Compiler.LCNF.LetDecl pu) → motive (Lean.Compiler.LCNF.CodeDecl.let decl)) →
((decl : Lean.Compiler.LCNF.FunDecl pu) →
(h : pu = Lean.Compiler... | false |
EReal.top_ne_coe._simp_1 | Mathlib.Data.EReal.Basic | ∀ (x : ℝ), (⊤ = ↑x) = False | false |
Subsemiring.coe_prod._simp_1 | Mathlib.Algebra.Ring.Subsemiring.Basic | ∀ {R : Type u} {S : Type v} [inst : NonAssocSemiring R] [inst_1 : NonAssocSemiring S] (s : Subsemiring R)
(t : Subsemiring S), ↑s ×ˢ ↑t = ↑(s.prod t) | false |
QuadraticMap.zeroHomClass | Mathlib.LinearAlgebra.QuadraticForm.Basic | ∀ {R : Type u_3} {M : Type u_4} {N : Type u_5} [inst : CommSemiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
[inst_3 : AddCommMonoid N] [inst_4 : Module R N], ZeroHomClass (QuadraticMap R M N) M N | true |
Std.DTreeMap.Internal.Impl.balanceL!_pair_congr | Std.Data.DTreeMap.Internal.Model | ∀ {α : Type u} {β : α → Type v} {k : α} {v : β k} {k' : α} {v' : β k'},
⟨k, v⟩ = ⟨k', v'⟩ →
∀ {l l' r r' : Std.DTreeMap.Internal.Impl α β},
l = l' → r = r' → Std.DTreeMap.Internal.Impl.balanceL! k v l r = Std.DTreeMap.Internal.Impl.balanceL! k' v' l' r' | true |
Module.mapEvalEquiv | Mathlib.LinearAlgebra.Dual.Defs | (R : Type u_3) →
(M : Type u_4) →
[inst : CommSemiring R] →
[inst_1 : AddCommMonoid M] →
[inst_2 : Module R M] →
[Module.IsReflexive R M] → Submodule R M ≃o Submodule R (Module.Dual R (Module.Dual R M)) | true |
SimplexCategory.δ_comp_σ_of_le | Mathlib.AlgebraicTopology.SimplexCategory.Basic | ∀ {n : ℕ} {i : Fin (n + 2)} {j : Fin (n + 1)},
i ≤ j.castSucc →
CategoryTheory.CategoryStruct.comp (SimplexCategory.δ i.castSucc) (SimplexCategory.σ j.succ) =
CategoryTheory.CategoryStruct.comp (SimplexCategory.σ j) (SimplexCategory.δ i) | true |
_private.Mathlib.Algebra.Polynomial.UnitTrinomial.0.Polynomial.isUnitTrinomial_iff'._simp_1_1 | Mathlib.Algebra.Polynomial.UnitTrinomial | ∀ {α : Type u} [inst : Monoid α] (a : αˣ) (n : ℕ), ↑a ^ n = ↑(a ^ n) | false |
Polynomial.SplittingField.instCharZero | Mathlib.FieldTheory.SplittingField.Construction | ∀ {K : Type v} [inst : Field K] (f : Polynomial K) [CharZero K], CharZero f.SplittingField | true |
_private.Mathlib.Analysis.SpecialFunctions.ArithmeticGeometricMean.0.NNReal.bddAbove_range_agmSequences_fst._simp_1_3 | Mathlib.Analysis.SpecialFunctions.ArithmeticGeometricMean | ∀ {α : Sort u_2} {β : Sort u_1} {f : α → β} {p : β → Prop}, (∀ (b : β) (a : α), f a = b → p b) = ∀ (a : α), p (f a) | false |
FreeGroup.isReduced_iff_reduce_eq | Mathlib.GroupTheory.FreeGroup.Reduce | ∀ {α : Type u_1} {L : List (α × Bool)} [inst : DecidableEq α], FreeGroup.IsReduced L ↔ FreeGroup.reduce L = L | true |
instLTBitVec | Init.Prelude | {w : ℕ} → LT (BitVec w) | true |
PMF.uniformOfFintype_apply | Mathlib.Probability.Distributions.Uniform | ∀ {α : Type u_1} [inst : Fintype α] [inst_1 : Nonempty α] (a : α), (PMF.uniformOfFintype α) a = (↑(Fintype.card α))⁻¹ | true |
ciSup_eq_ite | Mathlib.Order.ConditionallyCompletePartialOrder.Indexed | ∀ {α : Type u_1} [inst : ConditionallyCompletePartialOrderSup α] {p : Prop} [inst_1 : Decidable p] {f : p → α},
⨆ (h : p), f h = if h : p then f h else sSup ∅ | true |
_private.Mathlib.GroupTheory.Perm.Finite.0.Equiv.Perm.disjoint_support_closure_of_disjoint_support._simp_1_2 | Mathlib.GroupTheory.Perm.Finite | ∀ {α : Type u_1} {t : Set α} {ι : Sort u_12} {s : ι → Set α}, Disjoint t (⋃ i, s i) = ∀ (i : ι), Disjoint t (s i) | false |
Pi.mulSingle_le_mulSingle._gcongr_3 | Mathlib.Algebra.Order.Pi | ∀ {ι : Type u_6} {α : ι → Type u_7} [inst : DecidableEq ι] [inst_1 : (i : ι) → One (α i)]
[inst_2 : (i : ι) → Preorder (α i)] {i : ι} {a b : α i}, a ≤ b → Pi.mulSingle i a ≤ Pi.mulSingle i b | false |
CategoryTheory.MorphismProperty.IsStableUnderComonoid.recOn | Mathlib.CategoryTheory.CopyDiscardCategory.Widesubcategory | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
[inst_1 : CategoryTheory.MonoidalCategory C] →
{P : CategoryTheory.MorphismProperty C} →
{c : C} →
[inst_2 : CategoryTheory.ComonObj c] →
{motive : P.IsStableUnderComonoid c → Sort u} →
(t : P.IsStab... | false |
ISize.toInt_maxValue | Init.Data.SInt.Lemmas | ISize.maxValue.toInt = 2 ^ (System.Platform.numBits - 1) - 1 | true |
_private.Mathlib.Tactic.Find.0.Mathlib.Tactic.Find.matchHyps | Mathlib.Tactic.Find | List Lean.Expr → List Lean.Expr → List Lean.Expr → Lean.MetaM Bool | true |
LaurentSeries.val_le_one_iff_eq_coe | Mathlib.RingTheory.LaurentSeries | ∀ (K : Type u_2) [inst : Field K] (f : LaurentSeries K), Valued.v f ≤ 1 ↔ ∃ F, (HahnSeries.ofPowerSeries ℤ K) F = f | true |
Lean.Lsp.DiagnosticCode | Lean.Data.Lsp.Diagnostics | Type | true |
Ordnode.eraseMin._unsafe_rec | Mathlib.Data.Ordmap.Ordnode | {α : Type u_1} → Ordnode α → Ordnode α | false |
UpperSet.coe_nonempty | Mathlib.Order.UpperLower.CompleteLattice | ∀ {α : Type u_1} [inst : LE α] {s : UpperSet α}, (↑s).Nonempty ↔ s ≠ ⊤ | true |
_private.Mathlib.RingTheory.Lasker.0.Submodule.IsMinimalPrimaryDecomposition.comap_localized₀_eq_ite._simp_1_9 | Mathlib.RingTheory.Lasker | ∀ {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'}
[inst_5 : IsLocalizedModule S f] {m : M} {s : ↥S} {m' : M'}, (IsLocalizedModule.mk' f m s = m') = (f m = s • ... | false |
_private.Lean.Meta.Tactic.Cbv.Util.0.Lean.Meta.Tactic.Cbv.isBitVecValue | Lean.Meta.Tactic.Cbv.Util | Lean.Expr → Bool | true |
ContinuousMap.instRegularSpace | Mathlib.Topology.CompactOpen | ∀ {X : Type u_2} {Y : Type u_3} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] [RegularSpace Y],
RegularSpace C(X, Y) | true |
Std.IterM.Partial.it | Init.Data.Iterators.Consumers.Monadic.Partial | {α : Type w} → {m : Type w → Type w'} → {β : Type w} → Std.IterM.Partial m β → Std.IterM m β | true |
AlgebraicTopology.DoldKan.Γ₀.Obj.map._proof_1 | Mathlib.AlgebraicTopology.DoldKan.FunctorGamma | ∀ {Δ' Δ : SimplexCategoryᵒᵖ} (θ : Δ ⟶ Δ') (A : SimplicialObject.Splitting.IndexSet Δ),
CategoryTheory.Limits.HasImage (CategoryTheory.CategoryStruct.comp θ.unop A.e) | false |
Algebra.TensorProduct.tensorQuotientEquiv_symm_apply_tmul | Mathlib.RingTheory.TensorProduct.Quotient | ∀ {R : Type u_1} (S : Type u_2) (T : Type u_3) (A : Type u_4) [inst : CommRing R] [inst_1 : CommRing S]
[inst_2 : Algebra R S] [inst_3 : CommRing T] [inst_4 : Algebra R T] [inst_5 : CommRing A] [inst_6 : Algebra R A]
[inst_7 : Algebra S A] [inst_8 : IsScalarTower R S A] (I : Ideal T) (a : A) (t : T),
(Algebra.Ten... | true |
Std.ExtTreeMap.union_insert_right_eq_insert_union | Std.Data.ExtTreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t₁ t₂ : Std.ExtTreeMap α β cmp} [inst : Std.TransCmp cmp]
{p : (_ : α) × β}, t₁ ∪ t₂.insert p.fst p.snd = (t₁ ∪ t₂).insert p.fst p.snd | true |
String.Slice.Pattern.Model.IsValidSearchFrom.mismatched_of_eq | Init.Data.String.Lemmas.Pattern.Basic | ∀ {ρ : Type} {pat : ρ} [inst : String.Slice.Pattern.Model.ForwardPatternModel pat] {s : String.Slice}
{startPos startPos' endPos : s.Pos} {l : List (String.Slice.Pattern.SearchStep s)},
String.Slice.Pattern.Model.IsValidSearchFrom pat endPos l →
startPos' < endPos →
(∀ (pos : s.Pos), startPos' ≤ pos → pos... | true |
Std.ExtDHashMap.mem_modify | Std.Data.ExtDHashMap.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {β : α → Type v} {m : Std.ExtDHashMap α β} [inst : LawfulBEq α] {k k' : α}
{f : β k → β k}, k' ∈ m.modify k f ↔ k' ∈ m | true |
CategoryTheory.MonoidalCategory.whiskerLeftIso_trans | Mathlib.CategoryTheory.Monoidal.Category | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.MonoidalCategory C] (W : C)
{X Y Z : C} (f : X ≅ Y) (g : Y ≅ Z),
CategoryTheory.MonoidalCategory.whiskerLeftIso W (f ≪≫ g) =
CategoryTheory.MonoidalCategory.whiskerLeftIso W f ≪≫ CategoryTheory.MonoidalCategory.whiskerLeftIso W g | true |
List.isEmpty_reverse | Init.Data.List.Lemmas | ∀ {α : Type u_1} {xs : List α}, xs.reverse.isEmpty = xs.isEmpty | true |
Std.TreeSet.Raw.insertMany_list_equiv_foldl | Std.Data.TreeSet.Raw.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t₁ : Std.TreeSet.Raw α cmp} {l : List α},
(t₁.insertMany l).Equiv (List.foldl (fun acc a => acc.insert a) t₁ l) | true |
CategoryTheory.ComposableArrows.homMkSucc | Mathlib.CategoryTheory.ComposableArrows.Basic | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
{n : ℕ} →
{F G : CategoryTheory.ComposableArrows C (n + 1)} →
(α : F.obj' 0 ⋯ ⟶ G.obj' 0 ⋯) →
(β : F.δ₀ ⟶ G.δ₀) →
CategoryTheory.CategoryStruct.comp (F.map' 0 1 CategoryTheory.ComposableArrows.homMk₁._proof_4 ⋯)
... | true |
_private.Mathlib.LinearAlgebra.Projection.0.LinearMap.IsIdempotentElem.commute_iff_of_isUnit._simp_1_4 | Mathlib.LinearAlgebra.Projection | ∀ {R : Type u_1} {M : Type u_2} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] {f : M ≃ₗ[R] M}
{p : Submodule R M}, (p ≤ Submodule.map (↑f) p) = (p ∈ Module.End.invtSubmodule ↑f.symm) | false |
Ideal.quotientEquivDirectSum | Mathlib.LinearAlgebra.FreeModule.IdealQuotient | {ι : Type u_1} →
{R : Type u_2} →
{S : Type u_3} →
[inst : CommRing R] →
[inst_1 : CommRing S] →
[inst_2 : Algebra R S] →
[inst_3 : IsDomain R] →
[inst_4 : IsPrincipalIdealRing R] →
[inst_5 : IsDomain S] →
[inst_6 : Finite ι] →
... | true |
_private.Lean.Elab.Term.TermElabM.0.Lean.Elab.Term.logUnassignedUsingErrorInfos.match_1 | Lean.Elab.Term.TermElabM | (motive : MProd Lean.MVarIdSet (MProd (Array Lean.Elab.Term.MVarErrorInfo) Bool) → Sort u_1) →
(r : MProd Lean.MVarIdSet (MProd (Array Lean.Elab.Term.MVarErrorInfo) Bool)) →
((alreadyVisited : Lean.MVarIdSet) →
(errors : Array Lean.Elab.Term.MVarErrorInfo) →
(hasNewErrors : Bool) → motive ⟨alrea... | false |
CategoryTheory.Functor.DenseAt.ofIso | Mathlib.CategoryTheory.Functor.KanExtension.DenseAt | {C : Type u₁} →
{D : Type u₂} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
[inst_1 : CategoryTheory.Category.{v₂, u₂} D] →
{F : CategoryTheory.Functor C D} → {Y : D} → F.DenseAt Y → {Y' : D} → (Y ≅ Y') → F.DenseAt Y' | true |
Option.merge.eq_4 | Init.Omega.Constraint | ∀ {α : Type u_1} (fn : α → α → α) (x_2 y : α), Option.merge fn (some x_2) (some y) = some (fn x_2 y) | true |
Lean.Server.RequestCancellation._sizeOf_1 | Lean.Server.RequestCancellation | Lean.Server.RequestCancellation → ℕ | false |
SemiRingCat.FilteredColimits.colimitCoconeIsColimit._proof_2 | Mathlib.Algebra.Category.Ring.FilteredColimits | ∀ {J : Type u_1} [inst : CategoryTheory.SmallCategory J] (F : CategoryTheory.Functor J SemiRingCat)
[inst_1 : CategoryTheory.IsFiltered J] (t : CategoryTheory.Limits.Cocone F),
(SemiRingCat.FilteredColimits.colimitCoconeIsColimit.descAddMonoidHom t) 1 = 1 | false |
ContinuousLinearEquiv.equivLike._proof_1 | Mathlib.Topology.Algebra.Module.Equiv | ∀ {R₁ : Type u_3} {R₂ : Type u_4} [inst : Semiring R₁] [inst_1 : Semiring R₂] {σ₁₂ : R₁ →+* R₂} {σ₂₁ : R₂ →+* R₁}
[inst_2 : RingHomInvPair σ₁₂ σ₂₁] [inst_3 : RingHomInvPair σ₂₁ σ₁₂] {M₁ : Type u_1} [inst_4 : TopologicalSpace M₁]
[inst_5 : AddCommMonoid M₁] {M₂ : Type u_2} [inst_6 : TopologicalSpace M₂] [inst_7 : Ad... | false |
Lean.FindLevelMVar.main._unsafe_rec | Lean.Util.FindLevelMVar | (Lean.LMVarId → Bool) → Lean.Expr → Lean.FindLevelMVar.Visitor | false |
CategoryTheory.Enriched.FunctorCategory.homEquiv_apply_π_assoc | Mathlib.CategoryTheory.Enriched.FunctorCategory | ∀ (V : Type u₁) [inst : CategoryTheory.Category.{v₁, u₁} V] [inst_1 : CategoryTheory.MonoidalCategory V] {C : Type u₂}
[inst_2 : CategoryTheory.Category.{v₂, u₂} C] {J : Type u₃} [inst_3 : CategoryTheory.Category.{v₃, u₃} J]
[inst_4 : CategoryTheory.EnrichedOrdinaryCategory V C] {F₁ F₂ : CategoryTheory.Functor J C}... | true |
FirstCountableTopology.frechetUrysohnSpace | Mathlib.Topology.Sequences | ∀ {X : Type u_1} [inst : TopologicalSpace X] [FirstCountableTopology X], FrechetUrysohnSpace X | true |
Int.cast_le_neg_one_of_neg | Mathlib.Algebra.Order.Ring.Cast | ∀ {R : Type u_1} [inst : Ring R] [inst_1 : LinearOrder R] [IsStrictOrderedRing R] {a : ℤ}, a < 0 → ↑a ≤ -1 | true |
WithZero.instAddMonoidWithOne | Mathlib.Algebra.GroupWithZero.WithZero | {α : Type u_1} → [AddMonoidWithOne α] → AddMonoidWithOne (WithZero α) | true |
lt_of_mul_self_lt_mul_self₀ | Mathlib.Algebra.Order.GroupWithZero.Unbundled.Basic | ∀ {M₀ : Type u_2} [inst : MonoidWithZero M₀] [inst_1 : LinearOrder M₀] [PosMulStrictMono M₀] {a b : M₀} [MulPosMono M₀],
0 ≤ b → a * a < b * b → a < b | true |
Module.piEquiv | Mathlib.LinearAlgebra.StdBasis | (ι : Type u_1) →
(R : Type u_2) →
(M : Type u_3) →
[Finite ι] →
[inst : CommSemiring R] → [inst_1 : AddCommMonoid M] → [inst_2 : Module R M] → (ι → M) ≃ₗ[R] (ι → R) →ₗ[R] M | true |
Orientation.rotationAux._proof_1 | Mathlib.Geometry.Euclidean.Angle.Oriented.Rotation | ∀ {V : Type u_1} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V] [inst_2 : Fact (Module.finrank ℝ V = 2)]
(o : Orientation ℝ V (Fin 2)) (θ : Real.Angle) (x y : V),
inner ℝ ((θ.cos • LinearMap.id + θ.sin • ↑o.rightAngleRotation.toLinearEquiv) x)
((θ.cos • LinearMap.id + θ.sin • ↑o.rightAngleRota... | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.