name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
_private.Mathlib.Algebra.FreeAlgebra.0.Algebra.adjoin_range_eq_range_freeAlgebra_lift._simp_1_2 | Mathlib.Algebra.FreeAlgebra | ∀ (R : Type u_1) (X : Type u_2) [inst : CommSemiring R], ⊤ = Algebra.adjoin R (Set.range (FreeAlgebra.ι R)) | false |
_private.Mathlib.LinearAlgebra.Prod.0.Submodule.map_inl._simp_1_6 | Mathlib.LinearAlgebra.Prod | ∀ {α : Sort u_1} {p : α → Prop} {a' : α}, (∃ a, a' = a ∧ p a) = p a' | false |
CategoryTheory.IsPushout.inr_isoPushout_hom_assoc | Mathlib.CategoryTheory.Limits.Shapes.Pullback.IsPullback.Defs | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {Z X Y P : C} {f : Z ⟶ X} {g : Z ⟶ Y} {inl : X ⟶ P}
{inr : Y ⟶ P} (h : CategoryTheory.IsPushout f g inl inr) [inst_1 : CategoryTheory.Limits.HasPushout f g] {Z_1 : C}
(h_1 : CategoryTheory.Limits.pushout f g ⟶ Z_1),
CategoryTheory.CategoryStruct.comp inr... | true |
NumberField.canonicalEmbedding.latticeBasis._proof_2 | Mathlib.NumberTheory.NumberField.CanonicalEmbedding.Basic | ∀ (K : Type u_1) [inst : Field K] [NumberField K], Finite (K →+* ℂ) | false |
_private.Mathlib.MeasureTheory.Measure.CharacteristicFunction.TaylorExpansion.0.MeasureTheory.iteratedFDeriv_charFun._simp_1_12 | Mathlib.MeasureTheory.Measure.CharacteristicFunction.TaylorExpansion | ∀ {G₀ : Type u_3} [inst : GroupWithZero G₀] {a : G₀} (n : ℤ), a ≠ 0 → (a ^ n = 0) = False | false |
instBooleanAlgebraSubtypeIsIdempotentElem._proof_2 | Mathlib.Algebra.Order.Ring.Idempotent | ∀ {R : Type u_1} [inst : CommRing R] (a : { a // IsIdempotentElem a }), ↑a - ↑a * ↑a = 0 | false |
_private.Lean.Elab.BuiltinDo.Match.0.Lean.Elab.Do.expandToTermMatch.match_1.eq_2 | Lean.Elab.BuiltinDo.Match | ∀ (motive : Bool × Option Lean.Expr → Sort u_1) (x : Bool × Option Lean.Expr)
(h_1 : (type : Lean.Expr) → motive (true, some type)) (h_2 : (x : Bool × Option Lean.Expr) → motive x),
(∀ (type : Lean.Expr), x = (true, some type) → False) →
(match x with
| (true, some type) => h_1 type
| x => h_2 x) =
... | true |
_private.Mathlib.Algebra.Algebra.Bilinear.0.LinearMap.pow_mulRight.match_1_1 | Mathlib.Algebra.Algebra.Bilinear | ∀ (motive : ℕ → Prop) (n : ℕ), (∀ (a : Unit), motive 0) → (∀ (n : ℕ), motive n.succ) → motive n | false |
ContAction | Mathlib.CategoryTheory.Action.Continuous | (V : Type u_1) →
[inst : CategoryTheory.Category.{v_1, u_1} V] →
{FV : V → V → Type u_2} →
{CV : V → Type u_3} →
[inst_1 : (X Y : V) → FunLike (FV X Y) (CV X) (CV Y)] →
[inst_2 : CategoryTheory.ConcreteCategory V FV] →
[CategoryTheory.HasForget₂ V TopCat] →
(G : T... | true |
_private.Mathlib.GroupTheory.Perm.Cycle.Type.0.Equiv.Perm.IsThreeCycle.nodup_iff_mem_support._proof_1_208 | Mathlib.GroupTheory.Perm.Cycle.Type | ∀ {α : Type u_1} [inst_1 : DecidableEq α] (w w_1 : α),
List.idxOfNth w [] 1 + 1 ≤ (List.filter (fun x => decide (x = w_1)) []).length →
List.idxOfNth w [] 1 < (List.filter (fun x => decide (x = w_1)) []).length | false |
Submodule.span.ringHom_apply | Mathlib.Algebra.Algebra.Operations | ∀ {R : Type u} [inst : CommSemiring R] {A : Type v} [inst_1 : Semiring A] [inst_2 : Algebra R A] (s : SetSemiring A),
Submodule.span.ringHom s = Submodule.span R (SetSemiring.down s) | true |
Submodule.span_empty | Mathlib.LinearAlgebra.Span.Defs | ∀ {R : Type u_1} {M : Type u_4} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M],
Submodule.span R ∅ = ⊥ | true |
Nat.zero_eq_one_mod_iff._simp_1 | Init.Data.Nat.Div.Basic | ∀ {n : ℕ}, (0 = 1 % n) = (n = 1) | false |
Aesop.Frontend.RuleSets.rec | Aesop.Frontend.RuleExpr | {motive : Aesop.Frontend.RuleSets → Sort u} →
((ruleSets : Array Aesop.RuleSetName) → motive { ruleSets := ruleSets }) → (t : Aesop.Frontend.RuleSets) → motive t | false |
UpperHalfPlane.center_zero | Mathlib.Analysis.Complex.UpperHalfPlane.Metric | ∀ (z : UpperHalfPlane), z.center 0 = z | true |
CategoryTheory.Limits.Types.binaryProductFunctor._proof_3 | Mathlib.CategoryTheory.Limits.Types.Products | ∀ {X₁ X₂ : Type u_1} (f : X₁ ⟶ X₂) ⦃X Y : Type u_1⦄ (f_1 : X ⟶ Y),
CategoryTheory.CategoryStruct.comp
({ obj := fun Y => X₁ × Y,
map := fun {x Y₂} f =>
(CategoryTheory.Limits.Types.binaryProductLimit X₁ Y₂).lift
(CategoryTheory.Limits.BinaryFan.mk Prod.fst (CategoryTheo... | false |
Int.modEq_add_fac_self | Mathlib.Data.Int.ModEq | ∀ {a t n : ℤ}, a + n * t ≡ a [ZMOD n] | true |
Rat.cast_commute | Mathlib.Data.Rat.Cast.Defs | ∀ {α : Type u_3} [inst : DivisionRing α] (r : ℚ) (a : α), Commute (↑r) a | true |
Turing.TM1to0.tr.match_1 | Mathlib.Computability.TuringMachine.PostTuringMachine | {Γ : Type u_1} →
{Λ : Type u_2} →
{σ : Type u_3} →
(M : Λ → Turing.TM1.Stmt Γ Λ σ) →
(motive : Turing.TM1to0.Λ' M → Γ → Sort u_4) →
(x : Turing.TM1to0.Λ' M) →
(x_1 : Γ) →
((snd : σ) → (x : Γ) → motive (none, snd) x) →
((q : Turing.TM1.Stmt Γ Λ σ) →... | false |
Projectivization.Subspace.span_eq_of_le | Mathlib.LinearAlgebra.Projectivization.Subspace | ∀ {K : Type u_1} {V : Type u_2} [inst : Field K] [inst_1 : AddCommGroup V] [inst_2 : Module K V]
{S : Set (Projectivization K V)} {W : Projectivization.Subspace K V},
S ⊆ ↑W → W ≤ Projectivization.Subspace.span S → Projectivization.Subspace.span S = W | true |
CategoryTheory.MorphismProperty.isoClosure_eq_self | Mathlib.CategoryTheory.MorphismProperty.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (P : CategoryTheory.MorphismProperty C) [P.RespectsIso],
P.isoClosure = P | true |
Mathlib.Meta.FunProp.Config.mk.inj | Mathlib.Tactic.FunProp.Types | ∀ {maxTransitionDepth maxSteps maxTransitionDepth_1 maxSteps_1 : ℕ},
{ maxTransitionDepth := maxTransitionDepth, maxSteps := maxSteps } =
{ maxTransitionDepth := maxTransitionDepth_1, maxSteps := maxSteps_1 } →
maxTransitionDepth = maxTransitionDepth_1 ∧ maxSteps = maxSteps_1 | true |
Lean.JsonNumber.casesOn | Lean.Data.Json.Basic | {motive : Lean.JsonNumber → Sort u} →
(t : Lean.JsonNumber) →
((mantissa : ℤ) → (exponent : ℕ) → motive { mantissa := mantissa, exponent := exponent }) → motive t | false |
Lean.PrettyPrinter.Delaborator.delabNameMkStr._regBuiltin.Lean.PrettyPrinter.Delaborator.delabNameMkStr_15 | Lean.PrettyPrinter.Delaborator.Builtins | IO Unit | false |
Mathlib.Meta.NormNum.NormNums._sizeOf_inst | Mathlib.Tactic.NormNum.Core | SizeOf Mathlib.Meta.NormNum.NormNums | false |
Rep.sub_hom | Mathlib.RepresentationTheory.Rep.Basic | ∀ {k : Type u} {G : Type v} [inst : Semiring k] [inst_1 : Monoid G] {A B : Rep.{w, u, v} k G} (f g : A ⟶ B),
Rep.Hom.hom (f - g) = Rep.Hom.hom f - Rep.Hom.hom g | true |
DirichletCharacter.changeLevel_toUnitHom | Mathlib.NumberTheory.DirichletCharacter.Basic | ∀ {R : Type u_1} [inst : CommMonoidWithZero R] {n : ℕ} (χ : DirichletCharacter R n) {m : ℕ} (hm : n ∣ m),
MulChar.toUnitHom ((DirichletCharacter.changeLevel hm) χ) = (MulChar.toUnitHom χ).comp (ZMod.unitsMap hm) | true |
CategoryTheory.Limits.PushoutCocone.isColimitEquivIsLimitUnop._proof_1 | Mathlib.CategoryTheory.Limits.Shapes.Opposites.Pullbacks | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} C] {X Y Z : Cᵒᵖ} {f : X ⟶ Y} {g : X ⟶ Z}
(c : CategoryTheory.Limits.PushoutCocone f g), Subsingleton (CategoryTheory.Limits.IsColimit c) | false |
Pi.seminormedCommRing._proof_3 | Mathlib.Analysis.Normed.Ring.Lemmas | ∀ {ι : Type u_1} {R : ι → Type u_2} [inst : Fintype ι] [inst_1 : (i : ι) → SeminormedCommRing (R i)]
(a b c : (i : ι) → R i), (a + b) * c = a * c + b * c | false |
IsAlgebraic.eq_1 | Mathlib.RingTheory.Algebraic.Defs | ∀ (R : Type u) {A : Type v} [inst : CommRing R] [inst_1 : Ring A] [inst_2 : Algebra R A] (x : A),
IsAlgebraic R x = ∃ p, p ≠ 0 ∧ (Polynomial.aeval x) p = 0 | true |
vadd_right_cancel | Mathlib.Algebra.AddTorsor.Defs | ∀ {G : Type u_1} {P : Type u_2} [inst : AddGroup G] [T : AddTorsor G P] {g₁ g₂ : G} (p : P), g₁ +ᵥ p = g₂ +ᵥ p → g₁ = g₂ | true |
Lean.Kernel.Exception.funExpected.sizeOf_spec | Lean.Environment | ∀ (env : Lean.Kernel.Environment) (lctx : Lean.LocalContext) (expr : Lean.Expr),
sizeOf (Lean.Kernel.Exception.funExpected env lctx expr) = 1 + sizeOf env + sizeOf lctx + sizeOf expr | true |
TopologicalSpace.CompactOpens.instSProdProd._proof_1 | Mathlib.Topology.Sets.Compacts | ∀ {α : Type u_1} {β : Type u_2} [inst : TopologicalSpace α] [inst_1 : TopologicalSpace β]
(K : TopologicalSpace.CompactOpens α) (L : TopologicalSpace.CompactOpens β), IsOpen (↑K ×ˢ ↑L.toCompacts) | false |
ContMDiffMap.compLeftMonoidHom._proof_1 | Mathlib.Geometry.Manifold.Algebra.SmoothFunctions | ∀ {𝕜 : Type u_3} [inst : NontriviallyNormedField 𝕜] {E : Type u_4} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {E' : Type u_9} [inst_3 : NormedAddCommGroup E'] [inst_4 : NormedSpace 𝕜 E'] {H : Type u_6}
[inst_5 : TopologicalSpace H] (I : ModelWithCorners 𝕜 E H) {H' : Type u_10} [inst_6 : Topolog... | false |
AddSubsemigroup.mem_closure_of_mem | Mathlib.Algebra.Group.Subsemigroup.Basic | ∀ {M : Type u_1} [inst : Add M] {s : Set M} {x : M}, x ∈ s → x ∈ AddSubsemigroup.closure s | true |
CFC.rpow_one | Mathlib.Analysis.SpecialFunctions.ContinuousFunctionalCalculus.Rpow.Basic | ∀ {A : Type u_1} [inst : PartialOrder A] [inst_1 : Ring A] [inst_2 : StarRing A] [inst_3 : TopologicalSpace A]
[inst_4 : StarOrderedRing A] [inst_5 : Algebra ℝ A] [inst_6 : ContinuousFunctionalCalculus ℝ A IsSelfAdjoint]
[inst_7 : NonnegSpectrumClass ℝ A] (a : A), autoParam (0 ≤ a) CFC.rpow_one._auto_1 → a ^ 1 = a | true |
MeasureTheory.exists_ne_forall_mem_nhds_pos_measure_preimage | Mathlib.MeasureTheory.Measure.Typeclasses.Finite | ∀ {α : Type u_1} {m0 : MeasurableSpace α} {μ : MeasureTheory.Measure α} {β : Type u_5} [inst : TopologicalSpace β]
[T1Space β] [SecondCountableTopology β] [Nonempty β] {f : α → β},
(∀ (b : β), ∃ᵐ (x : α) ∂μ, f x ≠ b) → ∃ a b, a ≠ b ∧ (∀ s ∈ nhds a, 0 < μ (f ⁻¹' s)) ∧ ∀ t ∈ nhds b, 0 < μ (f ⁻¹' t) | true |
OrderDual.instDivisionRing._proof_5 | Mathlib.Algebra.Field.Basic | ∀ {K : Type u_1} [h : DivisionRing K], Nontrivial Kᵒᵈ | false |
ContinuousCohomology.invariants._proof_1 | Mathlib.Algebra.Category.ContinuousCohomology.Basic | ∀ (R : Type u_2) (G : Type u_3) [inst : CommRing R] [inst_1 : Group G] [inst_2 : TopologicalSpace R]
(M : Action (TopModuleCat R) G) {a b : ↑M.V.toModuleCat},
a ∈ {x | ∀ (g : G), (TopModuleCat.Hom.hom (M.ρ g)) x = x} →
b ∈ {x | ∀ (g : G), (TopModuleCat.Hom.hom (M.ρ g)) x = x} →
∀ (g : G), (TopModuleCat.Ho... | false |
List.partitionMap | Init.Data.List.BasicAux | {α : Type u_1} → {β : Type u_2} → {γ : Type u_3} → (α → β ⊕ γ) → List α → List β × List γ | true |
_private.Mathlib.Probability.ConditionalProbability.0.ProbabilityTheory.cond_cond_eq_cond_inter'._simp_1_2 | Mathlib.Probability.ConditionalProbability | ∀ {G : Type u_1} [inst : Semigroup G] (a b c : G), a * (b * c) = a * b * c | false |
contDiffOn_prod_iff | 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] {s : Set E} {n : WithTop ℕ∞} (f : E →... | true |
CategoryTheory.kernelCokernelCompSequence.ι._proof_2 | Mathlib.CategoryTheory.Abelian.DiagramLemmas.KernelCokernelComp | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Abelian C] {X Y : C},
CategoryTheory.Limits.HasBinaryBiproduct X Y | false |
AlgebraicGeometry.Scheme.Pullback.openCoverOfRight_I₀ | Mathlib.AlgebraicGeometry.Pullbacks | ∀ {X Y Z : AlgebraicGeometry.Scheme} (𝒰 : Y.OpenCover) (f : X ⟶ Z) (g : Y ⟶ Z),
(AlgebraicGeometry.Scheme.Pullback.openCoverOfRight 𝒰 f g).I₀ = 𝒰.I₀ | true |
_private.Mathlib.Algebra.Polynomial.Lifts.0.Polynomial.lifts_iff_set_range._simp_1_3 | Mathlib.Algebra.Polynomial.Lifts | ∀ {R : Type u} {S : Type v} [inst : NonAssocSemiring R] [inst_1 : NonAssocSemiring S] {f : R →+* S} {y : S},
(y ∈ f.rangeS) = ∃ x, f x = y | false |
derivationQuotKerSq._proof_2 | Mathlib.RingTheory.Smooth.Kaehler | ∀ (R : Type u_2) (P : Type u_1) (S : Type u_3) [inst : CommRing R] [inst_1 : CommRing P] [inst_2 : CommRing S]
[inst_3 : Algebra R P] [inst_4 : Algebra P S] [inst_5 : Algebra R S] [IsScalarTower R P S], SMulCommClass P R S | false |
Sum.instLocallyFiniteOrderTop._proof_2 | Mathlib.Data.Sum.Interval | ∀ {α : Type u_1} {β : Type u_2} [inst : Preorder α] [inst_1 : Preorder β] [inst_2 : LocallyFiniteOrderTop α]
[inst_3 : LocallyFiniteOrderTop β] (a x : α ⊕ β),
x ∈
Sum.elim (fun x => Finset.map Function.Embedding.inl (Finset.Ioi x))
(fun x => Finset.map Function.Embedding.inr (Finset.Ioi x)) a ↔
a ... | false |
Filter.EventuallyEq.of_forall_separating_preimage | Mathlib.Order.Filter.CountableSeparatingOn | ∀ {α : Type u_1} {β : Type u_2} {l : Filter α} [CountableInterFilter l] {f g : α → β} (p : Set β → Prop)
[HasCountableSeparatingOn β p Set.univ], (∀ (U : Set β), p U → f ⁻¹' U =ᶠ[l] g ⁻¹' U) → f =ᶠ[l] g | true |
AffineMap.hasDerivWithinAt | Mathlib.Analysis.Calculus.Deriv.AffineMap | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] (f : 𝕜 →ᵃ[𝕜] E) {s : Set 𝕜} {x : 𝕜}, HasDerivWithinAt (⇑f) (f.linear 1) s x | true |
mul_le_of_mul_le_right | Mathlib.Algebra.Order.Monoid.Unbundled.Basic | ∀ {α : Type u_1} [inst : Mul α] [inst_1 : Preorder α] [MulRightMono α] {a b c d : α}, a * b ≤ c → d ≤ a → d * b ≤ c | true |
_private.Lean.Compiler.LCNF.Simp.ConstantFold.0.Lean.Compiler.LCNF.Simp.ConstantFold.arithmeticFolders._proof_29 | Lean.Compiler.LCNF.Simp.ConstantFold | ∀ (a : UInt32), a * 1 = a | false |
_private.Mathlib.Data.W.Basic.0.WType.ofSigma_toSigma.match_1_1 | Mathlib.Data.W.Basic | ∀ {α : Type u_1} {β : α → Type u_2} (motive : WType β → Prop) (x : WType β),
(∀ (a : α) (f : β a → WType β), motive (WType.mk a f)) → motive x | false |
Mathlib.Tactic.LibraryRewrite.Rewrite.replacement | Mathlib.Tactic.Widget.LibraryRewrite | Mathlib.Tactic.LibraryRewrite.Rewrite → Lean.Expr | true |
CategoryTheory.ShortComplex.SnakeInput.composableArrowsFunctor_obj | Mathlib.Algebra.Homology.ShortComplex.SnakeLemma | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Abelian C]
(S : CategoryTheory.ShortComplex.SnakeInput C),
CategoryTheory.ShortComplex.SnakeInput.composableArrowsFunctor.obj S = S.composableArrows | true |
Int64.toInt_ofIntLE | Init.Data.SInt.Lemmas | ∀ {x : ℤ} {h₁ : Int64.minValue.toInt ≤ x} {h₂ : x ≤ Int64.maxValue.toInt}, (Int64.ofIntLE x h₁ h₂).toInt = x | true |
ContinuousAffineMap.instAddTorsor._proof_1 | Mathlib.Topology.Algebra.ContinuousAffineMap | ∀ {R : Type u_4} {V : Type u_5} {W : Type u_3} {P : Type u_1} {Q : Type u_2} [inst : Ring R] [inst_1 : AddCommGroup V]
[inst_2 : Module R V] [inst_3 : TopologicalSpace P] [inst_4 : AddTorsor V P] [inst_5 : AddCommGroup W]
[inst_6 : Module R W] [inst_7 : TopologicalSpace Q] [inst_8 : AddTorsor W Q] [inst_9 : Topolog... | false |
Lean.Widget.instInhabitedUserWidgetDefinition | Lean.Widget.UserWidget | Inhabited Lean.Widget.UserWidgetDefinition | true |
LineDeriv.lineDerivOp_sum | Mathlib.Analysis.Distribution.DerivNotation | ∀ {ι : Type u_1} {V : Type u_5} {E : Type u_6} {F : Type u_7} [inst : AddCommGroup V] [inst_1 : AddCommGroup E]
[inst_2 : AddCommGroup F] [inst_3 : LineDeriv V E F] [LineDerivAdd V E F] (v : V) (f : ι → E) (s : Finset ι),
LineDeriv.lineDerivOp v (∑ i ∈ s, f i) = ∑ i ∈ s, LineDeriv.lineDerivOp v (f i) | true |
Lean.Meta.Sym.Pattern.recOn | Lean.Meta.Sym.Pattern | {motive : Lean.Meta.Sym.Pattern → Sort u} →
(t : Lean.Meta.Sym.Pattern) →
((levelParams : List Lean.Name) →
(varTypes : Array Lean.Expr) →
(varInfos? : Option Lean.Meta.Sym.ProofInstInfo) →
(pattern : Lean.Expr) →
(fnInfos : Lean.AssocList Lean.Name Lean.Meta.Sym.ProofI... | false |
String.Slice.Pattern.SearchStep.rejected.injEq | Init.Data.String.Pattern.Basic | ∀ {s : String.Slice} (startPos endPos startPos_1 endPos_1 : s.Pos),
(String.Slice.Pattern.SearchStep.rejected startPos endPos =
String.Slice.Pattern.SearchStep.rejected startPos_1 endPos_1) =
(startPos = startPos_1 ∧ endPos = endPos_1) | true |
RestrictedProduct.mkUnit._proof_1 | Mathlib.Topology.Algebra.RestrictedProduct.Units | ∀ {ι : Type u_1} {R : ι → Type u_2} [inst : (i : ι) → Monoid (R i)] {S : ι → Type u_3}
[inst_1 : (i : ι) → SetLike (S i) (R i)] [inst_2 : ∀ (i : ι), SubmonoidClass (S i) (R i)] {B : (i : ι) → S i}
{𝓕 : Filter ι} (x : (i : ι) → (R i)ˣ),
(∀ᶠ (i : ι) in 𝓕, x i ∈ (Submonoid.ofClass (B i)).units) → ∀ᶠ (i : ι) in 𝓕,... | false |
Multiplicative.monoid._proof_2 | Mathlib.Algebra.Group.TypeTags.Basic | ∀ {α : Type u_1} [h : AddMonoid α] (a : Multiplicative α), 1 * a = a | false |
Convex.toCone._proof_2 | Mathlib.Geometry.Convex.Cone.Basic | ∀ {𝕜 : Type u_2} {M : Type u_1} [inst : Field 𝕜] [inst_1 : LinearOrder 𝕜] [IsStrictOrderedRing 𝕜]
[inst_3 : AddCommGroup M] [inst_4 : Module 𝕜 M] (s : Set M),
Convex 𝕜 s →
∀ ⦃x : M⦄,
x ∈ ⋃ c, ⋃ (_ : 0 < c), c • s → ∀ ⦃y : M⦄, y ∈ ⋃ c, ⋃ (_ : 0 < c), c • s → x + y ∈ ⋃ c, ⋃ (_ : 0 < c), c • s | false |
Lean.Meta.Grind.Arith.Cutsat.inDiseqValues | Lean.Meta.Tactic.Grind.Arith.Cutsat.Search | ℤ → Array (ℚ × Lean.Meta.Grind.Arith.Cutsat.DiseqCnstr) → Bool | true |
_private.Aesop.Frontend.Tactic.0.Aesop.Frontend.TacticConfig.parse.go | Aesop.Frontend.Tactic | Lean.MVarId → Bool → Array (Lean.TSyntax `Aesop.tactic_clause) → Lean.Elab.TermElabM Aesop.Frontend.TacticConfig | true |
CStarMatrix.instNonAssocSemiring._proof_1 | Mathlib.Analysis.CStarAlgebra.CStarMatrix | ∀ {n : Type u_1} {A : Type u_2} [inst : Fintype n] [inst_1 : DecidableEq n] [inst_2 : NonAssocSemiring A]
(a : CStarMatrix n n A), 1 * a = a | false |
Lean.Meta.LazyDiscrTree.Key.lit.inj | Lean.Meta.LazyDiscrTree | ∀ {a a_1 : Lean.Literal}, Lean.Meta.LazyDiscrTree.Key.lit a = Lean.Meta.LazyDiscrTree.Key.lit a_1 → a = a_1 | true |
Std.DHashMap.Internal.Raw₀.getKey_eq_of_equiv | Std.Data.DHashMap.Internal.RawLemmas | ∀ {α : Type u} {β : α → Type v} [inst : BEq α] [inst_1 : Hashable α] (m₁ m₂ : Std.DHashMap.Internal.Raw₀ α β)
[inst_2 : EquivBEq α] [inst_3 : LawfulHashable α] (h₁ : (↑m₁).WF) (h₂ : (↑m₂).WF) (h : (↑m₁).Equiv ↑m₂) {k : α}
(h' : m₁.contains k = true), m₁.getKey k h' = m₂.getKey k ⋯ | true |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.Const.get?_map_of_getKey?_eq_some._simp_1_2 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {instOrd : Ord α} {a b : α}, (compare a b ≠ Ordering.eq) = ((a == b) = false) | false |
MonCat.Colimits.hasColimits_monCat | Mathlib.Algebra.Category.MonCat.Colimits | CategoryTheory.Limits.HasColimits MonCat | true |
Matroid.isBase_compl_iff_maximal_disjoint_isBase | Mathlib.Combinatorics.Matroid.Basic | ∀ {α : Type u_1} {M : Matroid α} {B : Set α},
autoParam (B ⊆ M.E) Matroid.isBase_compl_iff_maximal_disjoint_isBase._auto_1 →
(M.IsBase (M.E \ B) ↔ Maximal (fun I => I ⊆ M.E ∧ ∃ B, M.IsBase B ∧ Disjoint I B) B) | true |
OrderRingIso.symm_bijective | Mathlib.Algebra.Order.Hom.Ring | ∀ {α : Type u_2} {β : Type u_3} [inst : Mul α] [inst_1 : Add α] [inst_2 : LE α] [inst_3 : Mul β] [inst_4 : Add β]
[inst_5 : LE β], Function.Bijective OrderRingIso.symm | true |
AddMonoidHom.coeToAddHom | Mathlib.Algebra.Group.Hom.Defs | {M : Type u_4} → {N : Type u_5} → [inst : AddZero M] → [inst_1 : AddZero N] → Coe (M →+ N) (M →ₙ+ N) | true |
add_eq_left | Mathlib.Algebra.Group.Basic | ∀ {M : Type u_4} [inst : AddMonoid M] [IsLeftCancelAdd M] {a b : M}, a + b = a ↔ b = 0 | true |
Std.HashMap.insertManyIfNewUnit_list_equiv_foldl | Std.Data.HashMap.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {m : Std.HashMap α Unit} {l : List α},
(m.insertManyIfNewUnit l).Equiv (List.foldl (fun acc a => acc.insertIfNew a ()) m l) | true |
Std.DTreeMap.maxKey?_erase_le_maxKey? | Std.Data.DTreeMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t : Std.DTreeMap α β cmp} [inst : Std.TransCmp cmp]
{k km kme : α} (hkme : (t.erase k).maxKey? = some kme), t.maxKey?.get ⋯ = km → (cmp kme km).isLE = true | true |
String.splitOnAux | Init.Data.String.Legacy | String → String → String.Pos.Raw → String.Pos.Raw → String.Pos.Raw → List String → List String | true |
Std.DTreeMap.Raw.getD_eq_fallback_of_contains_eq_false | 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 → ∀ {a : α} {fallback : β a}, t.contains a = false → t.getD a fallback = fallback | true |
IsMulCommutative.instCommGroup.eq_1 | Mathlib.Algebra.Group.Defs | ∀ {G : Type u_2} [inst : Group G] [inst_1 : IsMulCommutative G],
IsMulCommutative.instCommGroup = { toGroup := inst, mul_comm := ⋯ } | true |
IsAdjoinRoot.lift_root | Mathlib.RingTheory.IsAdjoinRoot | ∀ {R : Type u} {S : Type v} [inst : CommRing R] [inst_1 : Ring S] {f : Polynomial R} [inst_2 : Algebra R S]
(h : IsAdjoinRoot S f) {T : Type u_1} [inst_3 : CommRing T] {i : R →+* T} {x : T} (hx : Polynomial.eval₂ i x f = 0),
(h.lift i x hx) h.root = x | true |
Aesop.PhaseName.instOrd | Aesop.Rule.Name | Ord Aesop.PhaseName | true |
UInt32.not_ne_self | Init.Data.UInt.Bitwise | ∀ {a : UInt32}, ~~~a ≠ a | true |
ValueDistribution.characteristic_congr_codiscrete | Mathlib.Analysis.Complex.ValueDistribution.CharacteristicFunction | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℂ E] {f g : ℂ → E} {a : WithTop E} {r : ℝ},
f =ᶠ[Filter.codiscrete ℂ] g → r ≠ 0 → ValueDistribution.characteristic f a r = ValueDistribution.characteristic g a r | true |
Nat.le_pow | Init.Data.Nat.Lemmas | ∀ {a b : ℕ}, 0 < b → a ≤ a ^ b | true |
Antivary.sub_smul_sub_nonpos | Mathlib.Algebra.Order.Monovary | ∀ {ι : Type u_1} {α : Type u_2} {β : Type u_3} [inst : Ring α] [inst_1 : LinearOrder α] [IsStrictOrderedRing α]
[inst_3 : AddCommGroup β] [inst_4 : LinearOrder β] [IsOrderedAddMonoid β] [inst_6 : Module α β]
[IsStrictOrderedModule α β] {f : ι → α} {g : ι → β}, Antivary f g → ∀ (i j : ι), (f j - f i) • (g j - g i) ≤... | true |
Group.covariant_swap_iff_contravariant_swap | Mathlib.Algebra.Order.Monoid.Unbundled.Defs | ∀ {N : Type u_2} {r : N → N → Prop} [inst : Group N],
Covariant N N (Function.swap fun x1 x2 => x1 * x2) r ↔ Contravariant N N (Function.swap fun x1 x2 => x1 * x2) r | true |
CircleDeg1Lift.translationNumber_conj_eq | Mathlib.Dynamics.Circle.RotationNumber.TranslationNumber | ∀ (f : CircleDeg1Liftˣ) (g : CircleDeg1Lift), (↑f * g * ↑f⁻¹).translationNumber = g.translationNumber | true |
_private.Mathlib.RingTheory.Localization.Defs.0.IsLocalization.of_le_of_exists_dvd.match_1_1 | Mathlib.RingTheory.Localization.Defs | ∀ {R : Type u_1} [inst : CommSemiring R] (M : Submonoid R) (n : R) (motive : (∃ m ∈ M, n ∣ m) → Prop)
(x : ∃ m ∈ M, n ∣ m), (∀ (m : R) (hm : m ∈ M) (dvd : n ∣ m), motive ⋯) → motive x | false |
Batteries.Tactic.GeneralizeProofs.AContext.depth._default | Batteries.Tactic.GeneralizeProofs | ℕ | false |
Lean.PrettyPrinter.OneLine.State.tags | Lean.PrettyPrinter.Formatter | Lean.PrettyPrinter.OneLine.State → List (ℕ × Std.Format) | true |
SimpleGraph.vertexCoverNum_eq_zero | Mathlib.Combinatorics.SimpleGraph.VertexCover | ∀ {V : Type u_1} {G : SimpleGraph V}, G.vertexCoverNum = 0 ↔ G = ⊥ | true |
CategoryTheory.SmallCategoryOfSet.mk | Mathlib.CategoryTheory.SmallRepresentatives | {Ω : Type w} →
(obj : Set Ω) →
(hom : ↑obj → ↑obj → Set Ω) →
(id : (X : ↑obj) → ↑(hom X X)) →
(comp : {X Y Z : ↑obj} → ↑(hom X Y) → ↑(hom Y Z) → ↑(hom X Z)) →
autoParam (∀ {X Y : ↑obj} (f : ↑(hom X Y)), comp (id X) f = f)
CategoryTheory.SmallCategoryOfSet.id_comp._autoParam →... | true |
Mathlib.Notation3.DelabKey | Mathlib.Util.Notation3 | Type | true |
Lean.Compiler.LCNF.FindUsed.Context.casesOn | Lean.Compiler.LCNF.ReduceArity | {motive : Lean.Compiler.LCNF.FindUsed.Context → Sort u} →
(t : Lean.Compiler.LCNF.FindUsed.Context) →
((decl : Lean.Compiler.LCNF.Decl Lean.Compiler.LCNF.Purity.pure) →
(params : Lean.FVarIdSet) → motive { decl := decl, params := params }) →
motive t | false |
_private.Lean.Meta.Tactic.Grind.Arith.CommRing.Proof.0.Lean.Meta.Grind.Arith.CommRing.derivToExprProof._sunfold | Lean.Meta.Tactic.Grind.Arith.CommRing.Proof | Lean.Meta.Grind.Arith.CommRing.PolyDerivation →
Lean.Meta.Grind.Arith.CommRing.ProofM (ℤ × Lean.Grind.CommRing.Poly × Lean.Expr) | false |
CategoryTheory.NatTrans.prod._proof_2 | Mathlib.CategoryTheory.Products.Basic | ∀ {A : Type u_1} [inst : CategoryTheory.Category.{u_3, u_1} A] {B : Type u_7}
[inst_1 : CategoryTheory.Category.{u_5, u_7} B] {C : Type u_2} [inst_2 : CategoryTheory.Category.{u_4, u_2} C]
{D : Type u_8} [inst_3 : CategoryTheory.Category.{u_6, u_8} D] {F G : CategoryTheory.Functor A B}
{H I : CategoryTheory.Funct... | false |
AffineSubspace.SSameSide.oangle_sign_eq | Mathlib.Geometry.Euclidean.Angle.Oriented.Affine | ∀ {V : Type u_1} {P : Type u_2} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V] [inst_2 : MetricSpace P]
[inst_3 : NormedAddTorsor V P] [hd2 : Fact (Module.finrank ℝ V = 2)] [inst_4 : Module.Oriented ℝ V (Fin 2)]
{s : AffineSubspace ℝ P} {p₁ p₂ p₃ p₄ : P},
p₁ ∈ s →
p₂ ∈ s → s.SSameSide p₃ p₄ → ... | true |
SimpleGraph.IsFiveWheelLike.casesOn | Mathlib.Combinatorics.SimpleGraph.FiveWheelLike | {α : Type u_1} →
[inst : DecidableEq α] →
{G : SimpleGraph α} →
{r k : ℕ} →
{v w₁ w₂ : α} →
{s t : Finset α} →
{motive : G.IsFiveWheelLike r k v w₁ w₂ s t → Sort u} →
(t_1 : G.IsFiveWheelLike r k v w₁ w₂ s t) →
((isPathGraph3Compl : G.IsPathGraph3C... | false |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.Const.minKey!_modify._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 |
Representation.IntertwiningMap.instAddCommMonoid._proof_4 | Mathlib.RepresentationTheory.Intertwining | ∀ {A : Type u_1} {G : Type u_2} {V : Type u_3} {W : Type u_4} [inst : Semiring A] [inst_1 : Monoid G]
[inst_2 : AddCommMonoid V] [inst_3 : AddCommMonoid W] [inst_4 : Module A V] [inst_5 : Module A W]
(ρ : Representation A G V) (σ : Representation A G W) (a : ρ.IntertwiningMap σ), a + 0 = a | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.