ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
c : Char
cs₁✝ cs₂✝ : List Char
i₁✝ i₂✝ : Pos
cs₁ cs₂ : List Char
i₁ i₂ : Pos
a✝³ : { s := { data := cs₂ }, i := i₂ }.hasNext = true
a✝² : { s := { data := cs₁ }, i := i₁ }.hasNext = true
a✝¹ : { data := cs₁ }.get i₁ = { data := cs₂ }.get i₂
a✝ : ltb { s := { data := c :: { s := { data := cs₁ }, i := i₁ }.next.1.data }, i := { s := { data := cs₁ }, i := i₁ }.next.i + c } { s := { data := c :: { s := { data := cs₂ }, i := i₂ }.next.1.data }, i := { s := { data := cs₂ }, i := i₂ }.next.i + c } = ltb { s := { data := { s := { data := cs₁ }, i := i₁ }.next.1.data }, i := { s := { data := cs₁ }, i := i₁ }.next.i } { s := { data := { s := { data := cs₂ }, i := i₂ }.next.1.data }, i := { s := { data := cs₂ }, i := i₂ }.next.i }
⊢ (if { s := { data := c :: cs₁ }, i := i₁ + c }.curr = { s := { data := c :: cs₂ }, i := i₂ + c }.curr then ltb { s := { data := c :: cs₁ }, i := i₁ + c }.next { s := { data := c :: cs₂ }, i := i₂ + c }.next else decide ({ s := { data := c :: cs₁ }, i := i₁ + c }.curr < { s := { data := c :: cs₂ }, i := i₂ + c }.curr)) = if { s := { data := cs₁ }, i := i₁ }.curr = { s := { data := cs₂ }, i := i₂ }.curr then ltb { s := { data := cs₁ }, i := i₁ }.next { s := { data := cs₂ }, i := i₂ }.next else decide ({ s := { data := cs₁ }, i := i₁ }.curr < { s := { data := cs₂ }, i := i₂ }.curr)
ι : Type u_1
M : Type u_2
n : ℕ
I J : Box ι
i : ι
x : ℝ
y : ι → ℝ
h₁ : J ∈ split I i x
h₂ : y ∈ J
h₃ : y i ≤ x
H : ↑J = ↑I ∩ {y | x < y i}
⊢ False
k : Type u_1
V : Type u_2
P : Type u_3
Ring k
AddCommGroup V
Module k V
AffineSpace V P
m n : ℕ
s : Affine.Simplex k P m
e : Fin (m + 1) ≃ Fin (n + 1)
⊢ ∀ (a : Fin (n + 1)), (s.reindex e).points a = (s.points ∘ ⇑e.symm) a
ι : Type u_1
K : Type u_2
V : Type u_3
inst✝² : DivisionRing K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
f : ι → ℙ K V
u v : ℙ K V
⊢ ¬(¬v.rep = 0 ∧ ∀ (a : K), a • v.rep ≠ (Projectivization.rep ∘ ![u, v]) 0) ↔ u = v
R : Type u_2
L : Type u_3
M : Type u_4
CommRing R
LieRing L
LieAlgebra R L
LieAlgebra.IsNilpotent R L
AddCommGroup M
Module R M
LieRingModule L M
LieModule R L M
M₂ : Type u_5
AddCommGroup M₂
Module R M₂
LieRingModule L M₂
LieModule R L M₂
e : M ≃ₗ⁅R,L⁆ M₂
⊢ LieSubmodule.map e.toLieModuleHom (LieModule.posFittingComp R L M) = LieModule.posFittingComp R L M₂
α : Type u
β : Type v
γ : Type w
ι : Sort x
inst✝² : Preorder α
inst✝¹ : Preorder β
s✝ t : Set α
a✝ b✝ : α
inst✝ : LinearOrder γ
a b : γ
s : Set γ
hs : IsLeast s b
⊢ IsLeast ({a} ∪ s) (min a b)
α : Type u_1
MeasurableSpace α
StandardBorelSpace α
Infinite α
Countable α
⊢ Nonempty (α ≃ᵐ ↑(Set.range Nat.cast))
α : Type u_1
arr : Array α
l : List α
⊢ arr.appendList l = arr ++ l
α : Type u_1
F : Type u_2
F' : Type u_3
𝕜 : Type u_4
p : ℝ≥0∞
inst✝⁶ : RCLike 𝕜
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
inst✝³ : NormedAddCommGroup F'
inst✝² : NormedSpace 𝕜 F'
inst✝¹ : NormedSpace ℝ F'
inst✝ : CompleteSpace F'
m m0 : MeasurableSpace α
μ : Measure α
f✝ g : α → F'
s : Set α
hμ : NeZero μ
f : α → F'
hμ_finite : IsFiniteMeasure μ
h_meas : StronglyMeasurable (μ[f|⊥])
c : F'
h_eq : μ[f|⊥] = fun x => c
h_integral : (μ Set.univ).toReal • c = ∫ (x : α), f x ∂μ
⊢ (fun x => c) = fun x => (μ Set.univ).toReal⁻¹ • ∫ (x : α), f x ∂μ
C : Type u₁
inst✝² : Category.{v₁, u₁} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
F : C ⥤ D
X Y Z : C
f✝ : Y ⟶ X
S✝ R : Sieve X
i : X ⟶ Y
f : Y ⟶ Z
inst✝ : IsIso i
S : Sieve Z
⊢ S.arrows (i ≫ f) ↔ S.arrows f
p : ℕ
hp : Fact (Nat.Prime p)
f g : PadicSeq p
hfg : ¬f + g ≈ 0
hf : f ≈ 0
hfg' : f + g ≈ g
hcfg : (f + g).norm = g.norm
⊢ (f + g).norm ≤ max f.norm g.norm
α : Type u_1
β : Type u_2
m : MeasurableSpace α
μ ν : Measure α
inst✝¹ : SigmaFinite μ
ν' : Measure α
inst✝ : SigmaFinite ν'
h : μ ⟂ₘ ν
hνν' : ν ≪ ν'
t : Set α := h.nullSet
ht : MeasurableSet t
⊢ μ.rnDeriv ν' =ᶠ[ae (ν.restrict t)] 0
R : Type u
Monoid R
A : Type v
NonUnitalNonAssocSemiring A
DistribMulAction R A
⊢ ⇑1 = id
α : Type u
l : List α
Inhabited α
n : ℕ
hn : n < l.length
⊢ l.getI n = l.get ⟨n, hn⟩
p q : ℚ
hp : 0 ≤ p
hq : 0 ≤ q
⊢ (p * q).toNNRat = p.toNNRat * q.toNNRat
α : Type u_1
E' : Type u_6
F' : Type u_7
SeminormedAddCommGroup E'
SeminormedAddCommGroup F'
f' : α → E'
g' : α → F'
l : Filter α
Subsingleton E'
⊢ f' =o[l] g'
α : Type u_1
β : Type u_2
γ : Type u_3
AddCommMonoid α
TopologicalSpace α
ContinuousAdd α
T3Space α
f : β × γ → α
h : Summable f
h₁ : ∀ (b : β), Summable fun c => f (b, c)
⊢ ∑' (p : β × γ), f p = ∑' (b : β) (c : γ), f (b, c)
α : Type u_2
Preorder α
LocallyFiniteOrderBot α
a : α
Fintype α
DecidablePred fun x => x ≤ a
⊢ Finset.filter (fun x => x ≤ a) Finset.univ = Finset.Iic a
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
ι' : Type u_5
r p q : α → α → Prop
inst✝¹ : PartialOrder α
inst✝ : OrderBot α
s t : Set ι
f g✝ : ι → α
g : ↑s → ι
hg : ∀ (i : ↑s), f (g i) ≤ f ↑i
ht : s.PairwiseDisjoint f
x y : ↑s
hxy : g x ≠ g y
⊢ (Disjoint on f) (g x) (g y)
ι : Type u_1
V : Type u
CategoryTheory.Category.{v, u} V
CategoryTheory.Preadditive V
c : ComplexShape ι
C D E : HomologicalComplex V c
hom : (i j : ι) → c.Rel j i → (C.X i ⟶ D.X j)
g : D ⟶ E
⊢ Homotopy.nullHomotopicMap' hom ≫ g = Homotopy.nullHomotopicMap' fun i j hij => hom i j hij ≫ g.f j
R : Type u
inst✝¹ : EuclideanDomain R
inst✝ : DecidableEq R
x y : R
hxy : gcd x y = 0
⊢ x ∣ 0
R : Type u
S : Type v
inst✝¹ : CommRing R
inst✝ : CommRing S
I : Ideal R
⊢ I.jacobson = I ↔ ⊥.jacobson = ⊥
α : Type u_1
R : Type u_2
inst✝⁴ : CancelCommMonoidWithZero R
inst✝³ : UniqueFactorizationMonoid R
inst✝² : CancelCommMonoidWithZero α
inst✝¹ : UniqueFactorizationMonoid α
β : Type u_3
inst✝ : CancelCommMonoidWithZero β
P : α → Prop
i : α → ℕ
h1 : ∀ {x : α}, IsUnit x → P x
hpr : ∀ {p : α} (i : ℕ), Prime p → P (p ^ i)
hcp : ∀ {x y : α}, IsRelPrime x y → P x → P y → P (x * y)
this : DecidableEq α := Classical.decEq α
p : α
f' : Finset α
hpf' : p ∉ f'
ih : (∀ p ∈ f', Prime p) → (∀ p ∈ f', ∀ q ∈ f', p ∣ q → p = q) → P (∏ p ∈ f', p ^ i p)
is_prime : ∀ p_1 ∈ insert p f', Prime p_1
is_coprime : ∀ p_1 ∈ insert p f', ∀ q ∈ insert p f', p_1 ∣ q → p_1 = q
⊢ P (∏ p ∈ insert p f', p ^ i p)
R : Type u_1
inst✝ : Ring R
f g : ℕ → R
s : Set ℕ
hs : ∀ (m n : ℕ), m ∣ n → n ∈ s → m ∈ s
a : ℕ
⊢ a > 0 → (a ∈ s → ∑ x ∈ a.divisorsAntidiagonal, μ x.1 • g x.2 = f a ↔ a ∈ s → ∑ x ∈ a.divisorsAntidiagonal, ↑(μ x.1) * g x.2 = f a)
R : Type u_1
M : Type u_4
Semiring R
AddCommMonoid M
Module R M
p : Submodule R M
s : Set M
h₁ : s ⊆ ↑p
h₂ : p ≤ Submodule.span R s
⊢ Submodule.span R s = p
α : Type u_1
inst✝¹ : CommGroup α
inst✝ : DecidableEq α
A B✝ C✝ : Finset α
hA : A.Nonempty
B : Finset α
m n : ℕ
hA' : A ∈ A.powerset.erase ∅
C : Finset α
hC : C.Nonempty ∧ C ⊆ A
hCA : ∀ x' ∈ A.powerset.erase ∅, ↑(C * B).card / ↑C.card ≤ ↑(x' * B).card / ↑x'.card
⊢ (↑(C * B).card / ↑C.card) ^ m * ↑C.card * ((↑(C * B).card / ↑C.card) ^ n * ↑C.card) ≤ (↑(A * B).card / ↑A.card) ^ (m + n) * ↑A.card * ↑C.card
a b : ℕ+
d : ℕ+ := a.gcdD b
w : ℕ+ := a.gcdW b
x : ℕ := a.gcdX b
y : ℕ := a.gcdY b
z : ℕ+ := a.gcdZ b
a' : ℕ+ := a.gcdA' b
b' : ℕ+ := a.gcdB' b
u : XgcdType := XgcdType.start a b
ur : XgcdType := u.reduce
x✝ : d = ur.a
hb : d = ur.b
ha' : ↑a' = ↑w + x
hb' : ↑b' = y + ↑z
hdet : w * z = (x * y).succPNat
hdet' : ↑w * ↑z = x * y + 1
⊢ a = a' * d ∧ b = b' * d ∧ z * a' = (x * ↑b').succPNat ∧ w * b' = (y * ↑a').succPNat ∧ ↑z * ↑a = x * ↑b + ↑d ∧ ↑w * ↑b = y * ↑a + ↑d
n b : ℕ
hn : 0 < n
i m : ℕ
hm : m + 1 ≠ 1
hb : log (m + 1) n < b
h : 1 ≤ i ∧ (m + 1) ^ i ∣ n
⊢ i ≤ log (m + 1) n
α : Type u_1
DecidableEq α
Fintype α
f : Equiv.Perm α
x : α
⊢ x ∉ f.support ↔ f x = x
a b c d : ℝ≥0∞
r p q : ℝ≥0
⊢ a / ⊤ = 0
X : Type u_1
M : Type u_7
R : Type u_9
ι : Type u_10
TopologicalSpace X
Zero R
Zero M
SMulWithZero R M
s : ι → X → R
h : LocallyFinite fun i => Function.support (s i)
f : ι → X → M
⊢ LocallyFinite fun i => Function.support (s i • f i)
S : Type u_1
R : Type u_3
CommRing R
Monoid S
DistribMulAction S R
s : S
a : ℍ[R]
⊢ star (s • a) = s • star a
a b : Ordinal.{u_1}
h : a ≤ b
i : a.toPGame.LeftMoves
⊢ (↑(toLeftMovesToPGame.symm i)).toPGame ⧏ b.toPGame
α₁ : Type u_5
α₂ : Type u_6
β₁ : Type u_7
β₂ : Type u_8
AddCommMonoid α₁
AddCommMonoid α₂
AddCommMonoid β₁
AddCommMonoid β₂
A₁ : Set α₁
A₂ : Set α₂
B₁ : Set β₁
B₂ : Set β₂
f₁ : α₁ → β₁
f₂ : α₂ → β₂
n : ℕ
h₁ : IsAddFreimanHom n A₁ B₁ f₁
h₂ : IsAddFreimanHom n A₂ B₂ f₂
⊢ IsAddFreimanHom n (A₁ ×ˢ A₂) (B₁ ×ˢ B₂) (Prod.map f₁ f₂)
a : Cardinal.{u}
n : ℕ
⊢ Cardinal.lift.{v, u} a = ↑n ↔ a = ↑n
α : Type u_1
r : α → α → Prop
a b : α
h : Pairwise r
⊢ ¬r a b → a = b
α : Type u
β : Type u_1
γ : Type u_2
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
a b : Ordinal.{v}
⊢ lift.{u, v} a < lift.{u, v} b ↔ a < b
𝕜 : Type u_1
inst✝⁸ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type u_3
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type u_4
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
G' : Type u_5
inst✝¹ : NormedAddCommGroup G'
inst✝ : NormedSpace 𝕜 G'
f f₀ f₁ g : E → F
f' f₀' f₁' g' e : E →L[𝕜] F
x : E
s t : Set E
L L₁ L₂ : Filter E
h : x ∉ closure s
⊢ 𝓝[s] x = ⊥
α : Type u_2
m0 : MeasurableSpace α
μ : MeasureTheory.Measure α
⊢ μ.restrict ∅ = 0
C : Type u
motive : {X Y : CategoryTheory.FreeMonoidalCategory C} → (X ⟶ Y) → Prop
X Y : CategoryTheory.FreeMonoidalCategory C
t : X ⟶ Y
id : ∀ (X : CategoryTheory.FreeMonoidalCategory C), motive (CategoryTheory.CategoryStruct.id X)
α_hom :
  ∀ (X Y Z : CategoryTheory.FreeMonoidalCategory C), motive (CategoryTheory.MonoidalCategory.associator X Y Z).hom
α_inv :
  ∀ (X Y Z : CategoryTheory.FreeMonoidalCategory C), motive (CategoryTheory.MonoidalCategory.associator X Y Z).inv
l_hom : ∀ (X : CategoryTheory.FreeMonoidalCategory C), motive (CategoryTheory.MonoidalCategory.leftUnitor X).hom
l_inv : ∀ (X : CategoryTheory.FreeMonoidalCategory C), motive (CategoryTheory.MonoidalCategory.leftUnitor X).inv
ρ_hom : ∀ (X : CategoryTheory.FreeMonoidalCategory C), motive (CategoryTheory.MonoidalCategory.rightUnitor X).hom
ρ_inv : ∀ (X : CategoryTheory.FreeMonoidalCategory C), motive (CategoryTheory.MonoidalCategory.rightUnitor X).inv
comp :
  ∀ {X Y Z : CategoryTheory.FreeMonoidalCategory C} (f : X ⟶ Y) (g : Y ⟶ Z),
    motive f → motive g → motive (CategoryTheory.CategoryStruct.comp f g)
whiskerLeft :
  ∀ (X : CategoryTheory.FreeMonoidalCategory C) {Y Z : CategoryTheory.FreeMonoidalCategory C} (f : Y ⟶ Z),
    motive f → motive (CategoryTheory.MonoidalCategory.whiskerLeft X f)
whiskerRight :
  ∀ {X Y : CategoryTheory.FreeMonoidalCategory C} (f : X ⟶ Y) (Z : CategoryTheory.FreeMonoidalCategory C),
    motive f → motive (CategoryTheory.MonoidalCategory.whiskerRight f Z)
⊢ motive t
α : Type u_1
σ : Type u_2
inst✝¹ : Primcodable α
inst✝ : Primcodable σ
c : α → Code
hc : Computable c
z : α → σ
hz : Computable z
s : α → σ
hs : Computable s
l : α → σ
hl : Computable l
r : α → σ
hr : Computable r
pr : α → Code × Code × σ × σ → σ
hpr : Computable₂ pr
co : α → Code × Code × σ × σ → σ
hco : Computable₂ co
pc : α → Code × Code × σ × σ → σ
hpc : Computable₂ pc
rf : α → Code × σ → σ
hrf : Computable₂ rf
PR✝ : α → Code → Code → σ → σ → σ := fun a cf cg hf hg => pr a (cf, cg, hf, hg)
CO✝ : α → Code → Code → σ → σ → σ := fun a cf cg hf hg => co a (cf, cg, hf, hg)
PC✝ : α → Code → Code → σ → σ → σ := fun a cf cg hf hg => pc a (cf, cg, hf, hg)
RF✝ : α → Code → σ → σ := fun a cf hf => rf a (cf, hf)
F : α → Code → σ := fun a c => Code.recOn c (z a) (s a) (l a) (r a) (PR✝ a) (CO✝ a) (PC✝ a) (RF✝ a)
G₁ : (α × List σ) × ℕ × ℕ → Option σ := fun p => (p.1.2.get? p.2.2).bind fun s => (p.1.2.get? (unpair p.2.2).1).bind fun s₁ => Option.map (fun s₂ => bif p.2.1.bodd then bif p.2.1.div2.bodd then rf p.1.1 (ofNat Code p.2.2, s) else pc p.1.1 (ofNat Code (unpair p.2.2).1, ofNat Code (unpair p.2.2).2, s₁, s₂) else bif p.2.1.div2.bodd then co p.1.1 (ofNat Code (unpair p.2.2).1, ofNat Code (unpair p.2.2).2, s₁, s₂) else pr p.1.1 (ofNat Code (unpair p.2.2).1, ofNat Code (unpair p.2.2).2, s₁, s₂)) (p.1.2.get? (unpair p.2.2).2)
this✝ : Computable G₁
G : α → List σ → Option σ := fun a IH => Nat.casesOn IH.length (some (z a)) fun n => Nat.casesOn n (some (s a)) fun n => Nat.casesOn n (some (l a)) fun n => Nat.casesOn n (some (r a)) fun n => G₁ ((a, IH), n, n.div2.div2)
this : Computable₂ G
a : α
n : ℕ
m : ℕ := n.div2.div2
hm : m < n + 4
m1 : (unpair m).1 < n + 4
m2 : (unpair m).2 < n + 4
⊢ ((Option.map (fun n => F a (ofNat Code n)) (List.range (n + 4))[m]?).bind fun a_1 => (Option.map (fun n => F a (ofNat Code n)) (List.range (n + 4))[(unpair m).1]?).bind fun a_2 => Option.map ((fun s₂ => bif n.bodd then bif n.div2.bodd then rf a (ofNat Code m, a_1) else pc a (ofNat Code (unpair m).1, ofNat Code (unpair m).2, a_2, s₂) else bif n.div2.bodd then co a (ofNat Code (unpair m).1, ofNat Code (unpair m).2, a_2, s₂) else pr a (ofNat Code (unpair m).1, ofNat Code (unpair m).2, a_2, s₂)) ∘ fun n => F a (ofNat Code n)) (List.range (n + 4))[(unpair m).2]?) = some (F a (ofNat Code (n + 4)))
F : Type u_1
α✝ : Type u_2
β : Type u_3
α : Type u_4
inst✝ : LinearOrderedSemiring α
H₁ H₂ : FloorSemiring α
⊢ H₁ = H₂
K : Type u
inst✝⁴ : Field K
R : Type u_1
F : Type u_2
inst✝³ : CommRing R
inst✝² : IsDomain R
inst✝¹ : FunLike F K[X] R[X]
inst✝ : MonoidHomClass F K[X] R[X]
φ : F
hφ : K[X]⁰ ≤ Submonoid.comap φ R[X]⁰
f : RatFunc K
⊢ f.denom ≠ 0
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
inst✝² : MonoidalCategory C
X Y Z : C
inst✝¹ : HasLeftDual X
inst✝ : HasLeftDual Y
f : X ⟶ Y
g : ᘁX ⟶ Z
⊢ 𝟙 ᘁY ⊗≫ η_ (ᘁX) X ▷ ᘁY ⊗≫ ᘁX ◁ f ▷ ᘁY ⊗≫ (g ▷ (Y ⊗ ᘁY) ≫ Z ◁ ε_ (ᘁY) Y) ⊗≫ 𝟙 Z = (λ_ ᘁY).inv ≫ η_ (ᘁX) X ▷ ᘁY ≫ (ᘁX ◁ f ≫ g ▷ Y) ▷ ᘁY ≫ (α_ Z Y ᘁY).hom ≫ Z ◁ ε_ (ᘁY) Y ≫ (ρ_ Z).hom
C : Type u₁
D : Type u₂
E : Type u₃
inst✝³ : Category.{v₁, u₁} C
inst✝² : Category.{v₂, u₂} D
inst✝¹ : Category.{v₃, u₃} E
i : D ⥤ C
inst✝ : Reflective i
X Y : D
f : X ⟶ Y
⊢ f ≫ inv ((reflectorAdjunction i).counit.app Y) = inv ((reflectorAdjunction i).counit.app X) ≫ (reflector i).map (i.map f)
α : Type u_1
β : Type u_2
E : Type u_3
inst✝⁴ : TopologicalSpace α
inst✝³ : CompactSpace α
inst✝² : MetricSpace β
inst✝¹ : NormedAddCommGroup E
f g : C(α, β)
C : ℝ
inst✝ : Nonempty α
⊢ dist f g < C ↔ ∀ (x : α), dist (f x) (g x) < C
n k : ℕ
h : k ≤ n
aux₁ : (fun a => a.1 ≤ k) = (fun a => a.2 ≤ k) ∘ ⇑(Equiv.prodComm ℕ ℕ).symm
aux₂ : ∀ (i j : ℕ), (∃ a b, a + b = k ∧ b = i ∧ a + (n - k) = j) ↔ ∃ a b, a + b = k ∧ a = i ∧ b + (n - k) = j
⊢ filter (fun a => a.1 ≤ k) (antidiagonal n) = map ((Embedding.refl ℕ).prodMap { toFun := fun x => x + (n - k), inj' := ⋯ }) (antidiagonal k)
α : Type u_1
κ : Sort u_6
r : α → α → Prop
f : κ → Set α
h : Directed (fun x x_1 => x ⊆ x_1) f
⊢ (⋃ n, f n).Pairwise r ↔ ∀ (n : κ), (f n).Pairwise r
α : Type u
HasSSubset α
IsIrrefl α fun x x_1 => x ⊂ x_1
a b : α
⊢ a ⊂ b → a ≠ b
m : Type u_1 → Type u_2
α : Type u_3
β : Type u_1
Monad m
f : α → β → m (ForInStep β)
a : α
as : List α
b : β
⊢ forIn (a :: as) b f = do
  let x ← f a b
  match x with
    | ForInStep.done b => pure b
    | ForInStep.yield b => forIn as b f
α : Type u_1
β : Type u_2
Ω : Type u_3
F : Type u_4
inst✝⁶ : MeasurableSpace Ω
inst✝⁵ : StandardBorelSpace Ω
inst✝⁴ : Nonempty Ω
inst✝³ : NormedAddCommGroup F
mα : MeasurableSpace α
μ : Measure α
inst✝² : IsFiniteMeasure μ
X : α → β
Y : α → Ω
mβ : MeasurableSpace β
s : Set Ω
t : Set β
f : β × Ω → F
inst✝¹ : NormedSpace ℝ F
inst✝ : CompleteSpace F
hY : AEMeasurable Y μ
hf : AEStronglyMeasurable f (Measure.map (fun a => (X a, Y a)) μ)
⊢ AEStronglyMeasurable (fun x => ∫ (y : Ω), f (x, y) ∂(condDistrib Y X μ) x) (Measure.map X μ)
a b : ℝ
n : ℕ
⊢ deriv sin = cos
R : Type u_1
CommSemiring R
M : Submonoid R
S : Type u_2
CommSemiring S
Algebra R S
IsLocalization M S
a : R
b c : ↥M
⊢ IsLocalization.mk' S (a * ↑c) (b * c) = IsLocalization.mk' S a b
R : Type u_1
A : Type u_2
inst✝³ : CommSemiring R
inst✝² : CommRing A
inst✝¹ : Algebra R A
𝒜 : ℕ → Submodule R A
inst✝ : GradedAlgebra 𝒜
r : A
x : ProjectiveSpectrum 𝒜
⊢ x ∈ ↑(basicOpen 𝒜 r) ↔ r ∉ ↑x.asHomogeneousIdeal
α : Type u_1
β : Type u_2
m : MeasurableSpace α
μ✝ ν✝ : Measure α
mβ : MeasurableSpace β
f : α → β
hf : MeasurableEmbedding f
μ ν : Measure α
inst✝¹ : SigmaFinite μ
inst✝ : SigmaFinite ν
⊢ (map f μ).singularPart (map f ν) = map f (μ.singularPart ν)
C : Type u_1
inst✝¹ : Category.{u_2, u_1} C
inst✝ : Preadditive C
X : SimplicialObject C
Y : C
n q : ℕ
φ : Y ⟶ X _[n + 1]
v : HigherFacesVanish q φ
j : Fin (n + 2)
hj₁ : j ≠ 0
hj₂ : n + 2 ≤ ↑j + q
⊢ φ ≫ X.δ j = 0
R : Type x
CommRing R
a b : R
⊢ a * a - b * b = (a + b) * (a - b)
R : Type u_1
M : Type u_2
CommRing R
AddCommGroup M
Module R M
Q : QuadraticForm R M
i j : ZMod 2
⊢ CliffordAlgebra.evenOdd Q i * CliffordAlgebra.evenOdd Q j ≤ CliffordAlgebra.evenOdd Q (i + j)
k : Type u_1
V : Type u_2
P : Type u_3
Ring k
AddCommGroup V
Module k V
AffineSpace V P
s₁ s₂ : AffineSubspace k P
h : s₁ ∥ s₂
⊢ s₁.direction = s₂.direction
n✝ n : ℕ
hn : n > 0
⊢ n.primeFactors = filter Prime n.divisors
l : Type u_1
m : Type u_2
n : Type u_3
o : Type u_4
m' : o → Type u_5
n' : o → Type u_6
R : Type u_7
S : Type u_8
α : Type v
β : Type w
γ : Type u_9
inst✝⁶ : Fintype n
inst✝⁵ : DecidableEq n
inst✝⁴ : CommSemiring R
inst✝³ : Semiring α
inst✝² : Semiring β
inst✝¹ : Algebra R α
inst✝ : Algebra R β
r : R
f : α → β
hf : f 0 = 0
hf₂ : f ((algebraMap R α) r) = (algebraMap R β) r
⊢ n → f ((algebraMap R α) r) = (algebraMap R β) r
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F : C ⥤ D
G : D ⥤ C
adj : CoreHomEquiv F G
X✝ Y✝ : C
f✝ : X✝ ⟶ Y✝
⊢ (adj.homEquiv ((𝟭 C).obj X✝) (F.obj Y✝)) (F.map ((𝟭 C).map f✝) ≫ 𝟙 (F.obj Y✝)) = (adj.homEquiv ((𝟭 C).obj X✝) (F.obj Y✝)) (𝟙 (F.obj X✝) ≫ F.map f✝)
α : Type u_1
β : Type u_2
f✝ fa : α → α
fb : β → β
x✝ y : α
m n✝ : ℕ
f : α → α
n : ℕ
hn : 0 < n
x : α
hx : x ∈ ptsOfPeriod f n
⊢ f (f^[n.pred] x) = x
ι : Type u_1
σ : Type u_2
R : Type u_4
Ring R
AddMonoid ι
SetLike σ R
AddSubgroupClass σ R
A : ι → σ
SetLike.GradedMonoid A
z : ℤ
⊢ ↑↑z = ↑z
C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : HasZeroObject C
inst✝² : HasShift C ℤ
inst✝¹ : Preadditive C
inst✝ : ∀ (n : ℤ), (shiftFunctor C n).Additive
hC : Pretriangulated C
T : Triangle C
hT : T ∈ distinguishedTriangles
zero : T.mor₃ = 0
this✝ : Epi T.mor₂
this : IsSplitEpi T.mor₂
⊢ ∃ e, T.mor₁ ≫ e.hom = biprod.inl ∧ T.mor₂ = e.hom ≫ biprod.snd
n m : Nat
⊢ n ≤ m → Exists fun k => n + k = m
m : Type u_1 → Type u_2
α β : Type u_1
p : α → Prop
x✝ : m α
q : β → Prop
inst✝¹ : Monad m
inst✝ : LawfulMonad m
f : α → m β
hx : SatisfiesM p x✝
hf : ∀ (a : α), p a → SatisfiesM q (f a)
x : m { a // p a }
g : (a : α) → p a → { x // Subtype.val <$> x = f a }
⊢ (Subtype.val <$> do let x ← x match x with | ⟨a, h⟩ => (g a h).val) = Subtype.val <$> x >>= f
α : Type u
L₁ : List (α × Bool)
⊢ (FreeGroup.invRev L₁).length = L₁.length
C : Type u₁
CategoryTheory.Category.{v₁, u₁} C
CategoryTheory.Preadditive C
T : CategoryTheory.Monad C
T.Additive
F G : T.Algebra
α : F ⟶ G
⊢ (-α).f = -α.f
α : Type u_2
Add α
f g h : Filter α
⊢ h ≤ f + g ↔ ∀ ⦃s : Set α⦄, s ∈ f → ∀ ⦃t : Set α⦄, t ∈ g → s + t ∈ h
Ω : Type u_1
ι : Type u_3
m : MeasurableSpace Ω
Preorder ι
f : MeasureTheory.Filtration ι m
s : Set Ω
i : ι
hs : MeasurableSet s
⊢ MeasurableSet s
M : Type u_1
CommMonoid M
S : Submonoid M
N : Type u_2
CommMonoid N
f : S.LocalizationMap N
x : M
⊢ f.mk' x 1 = f.toMap x
α : Type u_3
TopologicalSpace α
PolishSpace α
Nonempty α
⊢ ∃ f, Continuous f ∧ Function.Surjective f
α : Type u_1
M : Type u_2
N : Type u_3
P : Type u_4
R : Type u_5
S : Type u_6
inst✝⁷ : Semiring R
inst✝⁶ : Semiring S
inst✝⁵ : AddCommMonoid M
inst✝⁴ : Module R M
inst✝³ : AddCommMonoid N
inst✝² : Module R N
inst✝¹ : AddCommMonoid P
inst✝ : Module R P
δ : Type u_7
s : δ → Set α
this : DecidablePred fun x => x ∈ ⋃ i, s i
l : α →₀ M
⊢ 0 ∈ comap ((supported M R (⋃ i, s i)).subtype ∘ₗ restrictDom M R (⋃ i, s i)) (⨆ i, supported M R (s i))
R : Type u_1
inst✝⁸ : CommRing R
I : Ideal R
M : Type u_2
inst✝⁷ : AddCommGroup M
inst✝⁶ : Module R M
N : Type u_3
inst✝⁵ : AddCommGroup N
inst✝⁴ : Module R N
P : Type u_4
inst✝³ : AddCommGroup P
inst✝² : Module R P
T : Type u_5
inst✝¹ : AddCommGroup T
inst✝ : Module (AdicCompletion I R) T
f g : AdicCompletion I M → N
h : ∀ (a : AdicCauchySequence I M), f ((mk I M) a) = g ((mk I M) a)
x : AdicCompletion I M
⊢ f x = g x
C : Type u₁
CategoryTheory.Category.{v₁, u₁} C
D : Type u₂
CategoryTheory.Category.{v₂, u₂} D
S : D
Y : C
T : CategoryTheory.Functor C D
f : S ⟶ T.obj Y
⊢ (CategoryTheory.StructuredArrow.mk f).homMk' (CategoryTheory.CategoryStruct.id Y) = CategoryTheory.eqToHom ⋯
J : Type w
C✝ : Type u
inst✝² : Category.{v, u} C✝
C : Type u
inst✝¹ : Category.{v, u} C
B : C
objs : J → C
arrows : (j : J) → B ⟶ objs j
inst✝ : HasWidePushout B objs arrows
X : C
f : B ⟶ X
fs : (j : J) → objs j ⟶ X
w : ∀ (j : J), arrows j ≫ fs j = f
g : widePushout B objs arrows ⟶ X
⊢ g = desc (head arrows ≫ g) (fun j => ι arrows j ≫ g) ⋯
R : Type u
S : Type v
NonUnitalNonAssocSemiring R
NonUnitalNonAssocSemiring S
F : Type u_1
FunLike F R S
NonUnitalRingHomClass F R S
g : S → R
f : F
h : Function.LeftInverse g ⇑f
x : ↥(NonUnitalRingHom.srange f)
⊢ (RingEquiv.sofLeftInverse' h).symm x = g ↑x
R : Type u
S : Type v
T : Type w
a b : R
n : ℕ
inst✝ : CommRing R
p : R[X]
h : ¬p = 0
⊢ rootMultiplicity 0 p = p.natTrailingDegree
α : Type u_1
DecidableEq α
Add α
s t : Finset α
⊢ s.addEnergy t =
  ∑ a ∈ s + t,
    (Finset.filter (fun x => Finset.addEnergy_eq_sum_sq'.match_1 (fun x => Prop) x fun x y => x + y = a)
          (s ×ˢ t)).card ^
      2
α : Type u
β : Type v
γ : Type u_1
f : Ultrafilter α
m : α → β
n : β → γ
⊢ Ultrafilter.map n (Ultrafilter.map m f) = Ultrafilter.map (n ∘ m) f
α : Type u_1
LE α
s t : LowerSet α
⊢ ↑(s ⊓ t) = ↑s ∩ ↑t
α : Type u_1
DecidableEq α
x y : α
⊢ (FreeAddMonoid.count x) (FreeAddMonoid.of y) = Pi.single x 1 y
Ω : Type u_1
E : Type u_2
m0 : MeasurableSpace Ω
μ : Measure Ω
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace ℝ E
inst✝¹ : CompleteSpace E
f✝ : ℕ → Ω → E
ℱ : Filtration ℕ m0
n✝ : ℕ
inst✝ : SigmaFiniteFiltration μ ℱ
f g : ℕ → Ω → E
hf : Martingale f ℱ μ
hg : Adapted ℱ fun n => g (n + 1)
hg0 : g 0 = 0
hgint : ∀ (n : ℕ), Integrable (g n) μ
n : ℕ
h : ℕ → Ω → E := f - martingalePart (f + g) ℱ μ
hhdef : h = f - martingalePart (f + g) ℱ μ
hh : h = predictablePart (f + g) ℱ μ - g
hhpred : Adapted ℱ fun n => h (n + 1)
hhmgle : Martingale h ℱ μ
⊢ martingalePart (f + g) ℱ μ n =ᶠ[ae μ] f n
R : Type u_1
A : Type u_2
CommSemiring R
CommRing A
Algebra R A
𝒜 : ℕ → Submodule R A
GradedAlgebra 𝒜
⊢ ProjectiveSpectrum.zeroLocus 𝒜 Set.univ = ∅
C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : HasZeroObject C
inst✝² : HasShift C ℤ
inst✝¹ : Preadditive C
inst✝ : ∀ (n : ℤ), (shiftFunctor C n).Additive
hC : Pretriangulated C
T : Triangle C
H : T ∈ distinguishedTriangles
⊢ T.mor₃ ≫ (shiftFunctor C 1).map T.mor₁ = 0
α : Type u_1
β : Type u_2
LinearOrderedField α
Ring β
abv : β → α
IsAbsoluteValue abv
G : Type u_3
SMul G β
IsScalarTower G β β
f1 f2 : CauSeq β abv
c : G
hf : f1 ≈ f2
⊢ c • f1 ≈ c • f2
α : Type u_2
Lattice α
L M : Sublattice α
h : L ≤ M
⊢ ⇑(Sublattice.inclusion h) = Set.inclusion h
K : Type u
CommRing K
p : ℕ
Fact (Nat.Prime p)
CharP K p
⊢ Function.Surjective (PerfectClosure.mk K p)
X : Type u_1
Y : Type u_2
TopologicalSpace X
TopologicalSpace Y
x y : X
γ : Y → Path x y
f : Y → ℝ
hγ : Continuous ↿γ
hf : Continuous f
⊢ Continuous fun t => (γ t).extend (f t)
𝕜 : Type u_2
NontriviallyNormedField 𝕜
E : Type u_3
F : Type u_4
NormedAddCommGroup E
NormedSpace 𝕜 E
NormedAddCommGroup F
NormedSpace 𝕜 F
f : E → F
x : E
⊢ AnalyticWithinAt 𝕜 f Set.univ x ↔ AnalyticAt 𝕜 f x
ι : Type u_1
ι' : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
inst✝ : LinearOrder α
s : Set α
hs : ¬BddAbove s
⊢ atTop = generate (Ici '' s)
α : Type u_1
β : Type u_2
s✝ t : Set α
inst✝ : Preorder α
s : Set α
hs : s.chainHeight ≠ ⊤
this : IsTrans { x // x ∈ s } fun x x_1 => x < x_1
n : ℕ
hn : ↑n = s.chainHeight
f : (fun x x_1 => x > x_1) ↪r fun x x_1 => x > x_1
⊢ ↑n.succ ≤ s.chainHeight
α : Type u
s : Set (Set α)
i✝ i : (Quotient.out (aleph 1).ord).α
IH : ∀ (y : (Quotient.out (aleph 1).ord).α), (Quotient.out (aleph 1).ord).r y i → #↑(generateMeasurableRec s y) ≤ max (#↑s) 2 ^ ℵ₀
A : ℵ₀ ≤ aleph 1
B : aleph 1 ≤ max (#↑s) 2 ^ ℵ₀
C : ℵ₀ ≤ max (#↑s) 2 ^ ℵ₀
J : #↑(⋃ j, generateMeasurableRec s ↑j) ≤ max (#↑s) 2 ^ ℵ₀
⊢ #↑(generateMeasurableRec s i) ≤ max (#↑s) 2 ^ ℵ₀
R : Type u_1
inst✝¹ : EuclideanDomain R
inst✝ : GCDMonoid R
p✝ q✝ p q : R
hq : q ≠ 0
⊢ q / GCDMonoid.gcd p q ≠ 0