1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: CochainComplex.HomComplex.Cochain.ofHom_comp
File: Mathlib/Algebra/Homology/HomotopyCategory/HomComplex.lean

tactic: simp only [ofHom, HomologicalComplex.comp_f, ofHoms_comp]
state_before: C : Type u
inst✝³ : Category.{v, u} C
inst✝² : Preadditive C
R : Type u_1
inst✝¹ : Ring R
inst✝ : Linear R C
F G K L : CochainComplex C ℤ
n m : ℤ
f : F ⟶ G
g : G ⟶ K
⊢ ofHom (f ≫ g) = (ofHom f).comp (ofHom g) ⋯
state_after: no goals
Theorem: CompleteLattice.independent_def'
File: Mathlib/Order/SupIndep.lean

tactic: simp_rw [sSup_image]
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
ι' : Type u_4
inst✝ : CompleteLattice α
s : Set α
hs : SetIndependent s
t : ι → α
ht : Independent t
⊢ Independent t ↔ ∀ (i : ι), Disjoint (t i) (sSup (t '' {j | j ≠ i}))
state_after: α : Type u_1
β : Type u_2
ι : Type u_3
ι' : Type u_4
inst✝ : CompleteLattice α
s : Set α
hs : SetIndependent s
t : ι → α
ht : Independent t
⊢ Independent t ↔ ∀ (i : ι), Disjoint (t i) (⨆ a ∈ {j | j ≠ i}, t a)

tactic: rfl
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
ι' : Type u_4
inst✝ : CompleteLattice α
s : Set α
hs : SetIndependent s
t : ι → α
ht : Independent t
⊢ Independent t ↔ ∀ (i : ι), Disjoint (t i) (⨆ a ∈ {j | j ≠ i}, t a)
state_after: no goals
Theorem: Submodule.finrank_add_le_finrank_add_finrank
File: Mathlib/LinearAlgebra/FiniteDimensional.lean

tactic: rw [← finrank_sup_add_finrank_inf_eq]
state_before: K : Type u
V : Type v
inst✝⁴ : DivisionRing K
inst✝³ : AddCommGroup V
inst✝² : Module K V
s t : Submodule K V
inst✝¹ : FiniteDimensional K ↥s
inst✝ : FiniteDimensional K ↥t
⊢ finrank K ↥(s ⊔ t) ≤ finrank K ↥s + finrank K ↥t
state_after: K : Type u
V : Type v
inst✝⁴ : DivisionRing K
inst✝³ : AddCommGroup V
inst✝² : Module K V
s t : Submodule K V
inst✝¹ : FiniteDimensional K ↥s
inst✝ : FiniteDimensional K ↥t
⊢ finrank K ↥(s ⊔ t) ≤ finrank K ↥(s ⊔ t) + finrank K ↥(s ⊓ t)

tactic: exact self_le_add_right _ _
state_before: K : Type u
V : Type v
inst✝⁴ : DivisionRing K
inst✝³ : AddCommGroup V
inst✝² : Module K V
s t : Submodule K V
inst✝¹ : FiniteDimensional K ↥s
inst✝ : FiniteDimensional K ↥t
⊢ finrank K ↥(s ⊔ t) ≤ finrank K ↥(s ⊔ t) + finrank K ↥(s ⊓ t)
state_after: no goals
Theorem: SimplexCategory.eq_comp_δ_of_not_surjective
File: Mathlib/AlgebraicTopology/SimplexCategory.lean

tactic: cases' not_forall.mp hθ with i hi
state_before: n : ℕ
Δ : SimplexCategory
θ : Δ ⟶ [n + 1]
hθ : ¬Function.Surjective ⇑(Hom.toOrderHom θ)
⊢ ∃ i θ', θ = θ' ≫ δ i
state_after: case intro
n : ℕ
Δ : SimplexCategory
θ : Δ ⟶ [n + 1]
hθ : ¬Function.Surjective ⇑(Hom.toOrderHom θ)
i : Fin ([n + 1].len + 1)
hi : ¬∃ a, (Hom.toOrderHom θ) a = i
⊢ ∃ i θ', θ = θ' ≫ δ i

tactic: use i
state_before: case intro
n : ℕ
Δ : SimplexCategory
θ : Δ ⟶ [n + 1]
hθ : ¬Function.Surjective ⇑(Hom.toOrderHom θ)
i : Fin ([n + 1].len + 1)
hi : ¬∃ a, (Hom.toOrderHom θ) a = i
⊢ ∃ i θ', θ = θ' ≫ δ i
state_after: case h
n : ℕ
Δ : SimplexCategory
θ : Δ ⟶ [n + 1]
hθ : ¬Function.Surjective ⇑(Hom.toOrderHom θ)
i : Fin ([n + 1].len + 1)
hi : ¬∃ a, (Hom.toOrderHom θ) a = i
⊢ ∃ θ', θ = θ' ≫ δ i

tactic: exact eq_comp_δ_of_not_surjective' θ i (not_exists.mp hi)
state_before: case h
n : ℕ
Δ : SimplexCategory
θ : Δ ⟶ [n + 1]
hθ : ¬Function.Surjective ⇑(Hom.toOrderHom θ)
i : Fin ([n + 1].len + 1)
hi : ¬∃ a, (Hom.toOrderHom θ) a = i
⊢ ∃ θ', θ = θ' ≫ δ i
state_after: no goals
Theorem: le_sup_iff
File: Mathlib/Order/Lattice.lean

tactic: exact ⟨fun h =>
  (le_total c b).imp
    (fun bc => by rwa [sup_eq_left.2 bc] at h)
    (fun bc => by rwa [sup_eq_right.2 bc] at h),
  fun h => h.elim le_sup_of_le_left le_sup_of_le_right⟩
state_before: α : Type u
β : Type v
inst✝ : LinearOrder α
a b c d : α
⊢ a ≤ b ⊔ c ↔ a ≤ b ∨ a ≤ c
state_after: no goals

tactic: rwa [sup_eq_left.2 bc] at h
state_before: α : Type u
β : Type v
inst✝ : LinearOrder α
a b c d : α
h : a ≤ b ⊔ c
bc : c ≤ b
⊢ a ≤ b
state_after: no goals

tactic: rwa [sup_eq_right.2 bc] at h
state_before: α : Type u
β : Type v
inst✝ : LinearOrder α
a b c d : α
h : a ≤ b ⊔ c
bc : b ≤ c
⊢ a ≤ c
state_after: no goals
Theorem: CategoryTheory.Functor.surjective_toEventualRanges
File: Mathlib/CategoryTheory/CofilteredSystem.lean

tactic: obtain ⟨y, hy, rfl⟩ := h.subset_image_eventualRange F f hx
state_before: J : Type u
inst✝¹ : Category.{u_1, u} J
F : J ⥤ Type v
i✝ j✝ k : J
s : Set (F.obj i✝)
inst✝ : IsCofilteredOrEmpty J
h : F.IsMittagLeffler
i j : J
f : i ⟶ j
x✝ : F.toEventualRanges.obj j
x : F.obj j
hx : x ∈ F.eventualRange j
⊢ ∃ a, F.toEventualRanges.map f a = ⟨x, hx⟩
state_after: case intro.intro
J : Type u
inst✝¹ : Category.{u_1, u} J
F : J ⥤ Type v
i✝ j✝ k : J
s : Set (F.obj i✝)
inst✝ : IsCofilteredOrEmpty J
h : F.IsMittagLeffler
i j : J
f : i ⟶ j
x✝ : F.toEventualRanges.obj j
y : F.obj i
hy : y ∈ F.eventualRange i
hx : F.map f y ∈ F.eventualRange j
⊢ ∃ a, F.toEventualRanges.map f a = ⟨F.map f y, hx⟩

tactic: exact ⟨⟨y, hy⟩, rfl⟩
state_before: case intro.intro
J : Type u
inst✝¹ : Category.{u_1, u} J
F : J ⥤ Type v
i✝ j✝ k : J
s : Set (F.obj i✝)
inst✝ : IsCofilteredOrEmpty J
h : F.IsMittagLeffler
i j : J
f : i ⟶ j
x✝ : F.toEventualRanges.obj j
y : F.obj i
hy : y ∈ F.eventualRange i
hx : F.map f y ∈ F.eventualRange j
⊢ ∃ a, F.toEventualRanges.map f a = ⟨F.map f y, hx⟩
state_after: no goals
Theorem: CategoryTheory.Limits.PreservesPullback.iso_inv_fst
File: Mathlib/CategoryTheory/Limits/Preserves/Shapes/Pullbacks.lean

tactic: simp [PreservesPullback.iso, Iso.inv_comp_eq]
state_before: C : Type u₁
inst✝⁴ : Category.{v₁, u₁} C
D : Type u₂
inst✝³ : Category.{v₂, u₂} D
G : C ⥤ D
W X Y Z : C
f : X ⟶ Z
g : Y ⟶ Z
h : W ⟶ X
k : W ⟶ Y
comm : h ≫ f = k ≫ g
inst✝² : PreservesLimit (cospan f g) G
inst✝¹ : HasPullback f g
inst✝ : HasPullback (G.map f) (G.map g)
⊢ (iso G f g).inv ≫ G.map pullback.fst = pullback.fst
state_after: no goals
Theorem: PMF.mem_support_ofMultiset_iff
File: Mathlib/Probability/Distributions/Uniform.lean

tactic: simp
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
s : Multiset α
hs : s ≠ 0
a : α
⊢ a ∈ (ofMultiset s hs).support ↔ a ∈ s.toFinset
state_after: no goals
Theorem: Mathlib.Meta.NormNum.IsInt.to_isNat
File: Mathlib/Tactic/NormNum/Result.lean

tactic: simp
state_before: α : Type u_1
inst✝ : Ring α
a✝ : ℕ
⊢ ↑(Int.ofNat a✝) = ↑a✝
state_after: no goals
Theorem: Finset.sups_eq_self
File: Mathlib/Data/Finset/Sups.lean

tactic: simp [← coe_inj]
state_before: F : Type u_1
α : Type u_2
β : Type u_3
inst✝⁵ : DecidableEq α
inst✝⁴ : DecidableEq β
inst✝³ : SemilatticeSup α
inst✝² : SemilatticeSup β
inst✝¹ : FunLike F α β
inst✝ : SupHomClass F α β
s s₁ s₂ t t₁ t₂ u v : Finset α
a b c : α
⊢ s ⊻ s = s ↔ SupClosed ↑s
state_after: no goals
Theorem: Dioph.div_dioph
File: Mathlib/NumberTheory/Dioph.lean

tactic: refine Iff.trans ?_ eq_comm
state_before: α β : Type
n : ℕ
f g : (α → ℕ) → ℕ
df : DiophFn f
dg : DiophFn g
this : Dioph fun v => v &2 = 0 ∧ v &0 = 0 ∨ v &0 * v &2 ≤ v &1 ∧ v &1 < (v &0 + 1) * v &2
z x y : ℕ
⊢ y = 0 ∧ z = 0 ∨ z * y ≤ x ∧ x < (z + 1) * y ↔ x / y = z
state_after: α β : Type
n : ℕ
f g : (α → ℕ) → ℕ
df : DiophFn f
dg : DiophFn g
this : Dioph fun v => v &2 = 0 ∧ v &0 = 0 ∨ v &0 * v &2 ≤ v &1 ∧ v &1 < (v &0 + 1) * v &2
z x y : ℕ
⊢ y = 0 ∧ z = 0 ∨ z * y ≤ x ∧ x < (z + 1) * y ↔ z = x / y

tactic: exact y.eq_zero_or_pos.elim
  (fun y0 => by
    rw [y0, Nat.div_zero]
    exact ⟨fun o => (o.resolve_right fun ⟨_, h2⟩ => Nat.not_lt_zero _ h2).right,
      fun z0 => Or.inl ⟨rfl, z0⟩⟩)
  fun ypos =>
    Iff.trans ⟨fun o => o.resolve_left fun ⟨h1, _⟩ => Nat.ne_of_gt ypos h1, Or.inr⟩
      (le_antisymm_iff.trans <| and_congr (Nat.le_div_iff_mul_le ypos) <|
        Iff.trans ⟨lt_succ_of_le, le_of_lt_succ⟩ (div_lt_iff_lt_mul ypos)).symm
state_before: α β : Type
n : ℕ
f g : (α → ℕ) → ℕ
df : DiophFn f
dg : DiophFn g
this : Dioph fun v => v &2 = 0 ∧ v &0 = 0 ∨ v &0 * v &2 ≤ v &1 ∧ v &1 < (v &0 + 1) * v &2
z x y : ℕ
⊢ y = 0 ∧ z = 0 ∨ z * y ≤ x ∧ x < (z + 1) * y ↔ z = x / y
state_after: no goals

tactic: rw [y0, Nat.div_zero]
state_before: α β : Type
n : ℕ
f g : (α → ℕ) → ℕ
df : DiophFn f
dg : DiophFn g
this : Dioph fun v => v &2 = 0 ∧ v &0 = 0 ∨ v &0 * v &2 ≤ v &1 ∧ v &1 < (v &0 + 1) * v &2
z x y : ℕ
y0 : y = 0
⊢ y = 0 ∧ z = 0 ∨ z * y ≤ x ∧ x < (z + 1) * y ↔ z = x / y
state_after: α β : Type
n : ℕ
f g : (α → ℕ) → ℕ
df : DiophFn f
dg : DiophFn g
this : Dioph fun v => v &2 = 0 ∧ v &0 = 0 ∨ v &0 * v &2 ≤ v &1 ∧ v &1 < (v &0 + 1) * v &2
z x y : ℕ
y0 : y = 0
⊢ 0 = 0 ∧ z = 0 ∨ z * 0 ≤ x ∧ x < (z + 1) * 0 ↔ z = 0

tactic: exact ⟨fun o => (o.resolve_right fun ⟨_, h2⟩ => Nat.not_lt_zero _ h2).right,
  fun z0 => Or.inl ⟨rfl, z0⟩⟩
state_before: α β : Type
n : ℕ
f g : (α → ℕ) → ℕ
df : DiophFn f
dg : DiophFn g
this : Dioph fun v => v &2 = 0 ∧ v &0 = 0 ∨ v &0 * v &2 ≤ v &1 ∧ v &1 < (v &0 + 1) * v &2
z x y : ℕ
y0 : y = 0
⊢ 0 = 0 ∧ z = 0 ∨ z * 0 ≤ x ∧ x < (z + 1) * 0 ↔ z = 0
state_after: no goals
Theorem: sign_eq_of_affineCombination_mem_affineSpan_pair
File: Mathlib/LinearAlgebra/AffineSpace/Independent.lean

tactic: rw [affineCombination_mem_affineSpan_pair h hw hw₁ hw₂] at hs
state_before: k : Type u_1
V : Type u_2
P : Type u_3
inst✝³ : LinearOrderedRing k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
ι : Type u_4
p : ι → P
h : AffineIndependent k p
w w₁ w₂ : ι → k
s : Finset ι
hw : ∑ i ∈ s, w i = 1
hw₁ : ∑ i ∈ s, w₁ i = 1
hw₂ : ∑ i ∈ s, w₂ i = 1
hs : (affineCombination k s p) w ∈ affineSpan k {(affineCombination k s p) w₁, (affineCombination k s p) w₂}
i j : ι
hi : i ∈ s
hj : j ∈ s
hi0 : w₁ i = 0
hj0 : w₁ j = 0
hij : SignType.sign (w₂ i) = SignType.sign (w₂ j)
⊢ SignType.sign (w i) = SignType.sign (w j)
state_after: k : Type u_1
V : Type u_2
P : Type u_3
inst✝³ : LinearOrderedRing k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
ι : Type u_4
p : ι → P
h : AffineIndependent k p
w w₁ w₂ : ι → k
s : Finset ι
hw : ∑ i ∈ s, w i = 1
hw₁ : ∑ i ∈ s, w₁ i = 1
hw₂ : ∑ i ∈ s, w₂ i = 1
hs : ∃ r, ∀ i ∈ s, w i = r * (w₂ i - w₁ i) + w₁ i
i j : ι
hi : i ∈ s
hj : j ∈ s
hi0 : w₁ i = 0
hj0 : w₁ j = 0
hij : SignType.sign (w₂ i) = SignType.sign (w₂ j)
⊢ SignType.sign (w i) = SignType.sign (w j)

tactic: rcases hs with ⟨r, hr⟩
state_before: k : Type u_1
V : Type u_2
P : Type u_3
inst✝³ : LinearOrderedRing k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
ι : Type u_4
p : ι → P
h : AffineIndependent k p
w w₁ w₂ : ι → k
s : Finset ι
hw : ∑ i ∈ s, w i = 1
hw₁ : ∑ i ∈ s, w₁ i = 1
hw₂ : ∑ i ∈ s, w₂ i = 1
hs : ∃ r, ∀ i ∈ s, w i = r * (w₂ i - w₁ i) + w₁ i
i j : ι
hi : i ∈ s
hj : j ∈ s
hi0 : w₁ i = 0
hj0 : w₁ j = 0
hij : SignType.sign (w₂ i) = SignType.sign (w₂ j)
⊢ SignType.sign (w i) = SignType.sign (w j)
state_after: case intro
k : Type u_1
V : Type u_2
P : Type u_3
inst✝³ : LinearOrderedRing k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
ι : Type u_4
p : ι → P
h : AffineIndependent k p
w w₁ w₂ : ι → k
s : Finset ι
hw : ∑ i ∈ s, w i = 1
hw₁ : ∑ i ∈ s, w₁ i = 1
hw₂ : ∑ i ∈ s, w₂ i = 1
i j : ι
hi : i ∈ s
hj : j ∈ s
hi0 : w₁ i = 0
hj0 : w₁ j = 0
hij : SignType.sign (w₂ i) = SignType.sign (w₂ j)
r : k
hr : ∀ i ∈ s, w i = r * (w₂ i - w₁ i) + w₁ i
⊢ SignType.sign (w i) = SignType.sign (w j)

tactic: rw [hr i hi, hr j hj, hi0, hj0, add_zero, add_zero, sub_zero, sub_zero, sign_mul, sign_mul, hij]
state_before: case intro
k : Type u_1
V : Type u_2
P : Type u_3
inst✝³ : LinearOrderedRing k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
ι : Type u_4
p : ι → P
h : AffineIndependent k p
w w₁ w₂ : ι → k
s : Finset ι
hw : ∑ i ∈ s, w i = 1
hw₁ : ∑ i ∈ s, w₁ i = 1
hw₂ : ∑ i ∈ s, w₂ i = 1
i j : ι
hi : i ∈ s
hj : j ∈ s
hi0 : w₁ i = 0
hj0 : w₁ j = 0
hij : SignType.sign (w₂ i) = SignType.sign (w₂ j)
r : k
hr : ∀ i ∈ s, w i = r * (w₂ i - w₁ i) + w₁ i
⊢ SignType.sign (w i) = SignType.sign (w j)
state_after: no goals
Theorem: MeasureTheory.lintegral_eq_lmarginal_univ
File: Mathlib/MeasureTheory/Integral/Marginal.lean

tactic: simp
state_before: δ : Type u_1
δ' : Type u_2
π : δ → Type u_3
inst✝³ : (x : δ) → MeasurableSpace (π x)
μ : (i : δ) → Measure (π i)
inst✝² : ∀ (i : δ), SigmaFinite (μ i)
inst✝¹ : DecidableEq δ
s t : Finset δ
f✝ g : ((i : δ) → π i) → ℝ≥0∞
x✝ y : (i : δ) → π i
i : δ
inst✝ : Fintype δ
f : ((i : δ) → π i) → ℝ≥0∞
x : (i : δ) → π i
⊢ ∫⁻ (x : (i : δ) → π i), f x ∂Measure.pi μ = (∫⋯∫⁻_Finset.univ, f ∂μ) x
state_after: no goals
Theorem: DFinsupp.filter_smul
File: Mathlib/Data/DFinsupp/Basic.lean

tactic: ext
state_before: ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
inst✝³ : Monoid γ
inst✝² : (i : ι) → AddMonoid (β i)
inst✝¹ : (i : ι) → DistribMulAction γ (β i)
p : ι → Prop
inst✝ : DecidablePred p
r : γ
f : Π₀ (i : ι), β i
⊢ filter p (r • f) = r • filter p f
state_after: case h
ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
inst✝³ : Monoid γ
inst✝² : (i : ι) → AddMonoid (β i)
inst✝¹ : (i : ι) → DistribMulAction γ (β i)
p : ι → Prop
inst✝ : DecidablePred p
r : γ
f : Π₀ (i : ι), β i
i✝ : ι
⊢ (filter p (r • f)) i✝ = (r • filter p f) i✝

tactic: simp [smul_apply, smul_ite]
state_before: case h
ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
inst✝³ : Monoid γ
inst✝² : (i : ι) → AddMonoid (β i)
inst✝¹ : (i : ι) → DistribMulAction γ (β i)
p : ι → Prop
inst✝ : DecidablePred p
r : γ
f : Π₀ (i : ι), β i
i✝ : ι
⊢ (filter p (r • f)) i✝ = (r • filter p f) i✝
state_after: no goals
Theorem: Set.filter_mem_univ_eq_toFinset
File: Mathlib/Data/Fintype/Basic.lean

tactic: ext
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
s✝ t : Set α
inst✝² : Fintype α
s : Set α
inst✝¹ : Fintype ↑s
inst✝ : DecidablePred fun x => x ∈ s
⊢ filter (fun x => x ∈ s) Finset.univ = s.toFinset
state_after: case a
α : Type u_1
β : Type u_2
γ : Type u_3
s✝ t : Set α
inst✝² : Fintype α
s : Set α
inst✝¹ : Fintype ↑s
inst✝ : DecidablePred fun x => x ∈ s
a✝ : α
⊢ a✝ ∈ filter (fun x => x ∈ s) Finset.univ ↔ a✝ ∈ s.toFinset

tactic: simp only [Finset.mem_univ, decide_eq_true_eq, forall_true_left, mem_filter,
  true_and, mem_toFinset]
state_before: case a
α : Type u_1
β : Type u_2
γ : Type u_3
s✝ t : Set α
inst✝² : Fintype α
s : Set α
inst✝¹ : Fintype ↑s
inst✝ : DecidablePred fun x => x ∈ s
a✝ : α
⊢ a✝ ∈ filter (fun x => x ∈ s) Finset.univ ↔ a✝ ∈ s.toFinset
state_after: no goals
Theorem: intervalIntegral.integral_sub_integral_sub_linear_isLittleO_of_tendsto_ae
File: Mathlib/MeasureTheory/Integral/FundThmCalculus.lean

tactic: simpa [integral_const]
  using measure_integral_sub_integral_sub_linear_isLittleO_of_tendsto_ae hab hmeas_a hmeas_b
    ha_lim hb_lim hua hva hub hvb
state_before: ι : Type u_1
𝕜 : Type u_2
E : Type u_3
F : Type u_4
A : Type u_5
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedSpace ℝ E
inst✝² : CompleteSpace E
f : ℝ → E
c ca cb : E
l l' la la' lb lb' : Filter ℝ
lt : Filter ι
a b z : ℝ
u v ua ub va vb : ι → ℝ
inst✝¹ : FTCFilter a la la'
inst✝ : FTCFilter b lb lb'
hab : IntervalIntegrable f volume a b
hmeas_a : StronglyMeasurableAtFilter f la' volume
hmeas_b : StronglyMeasurableAtFilter f lb' volume
ha_lim : Tendsto f (la' ⊓ ae volume) (𝓝 ca)
hb_lim : Tendsto f (lb' ⊓ ae volume) (𝓝 cb)
hua : Tendsto ua lt la
hva : Tendsto va lt la
hub : Tendsto ub lt lb
hvb : Tendsto vb lt lb
⊢ (fun t =>
      ((∫ (x : ℝ) in va t..vb t, f x) - ∫ (x : ℝ) in ua t..ub t, f x) -
        ((vb t - ub t) • cb - (va t - ua t) • ca)) =o[lt]
    fun t => ‖va t - ua t‖ + ‖vb t - ub t‖
state_after: no goals
Theorem: Multiset.Nat.map_swap_antidiagonal
File: Mathlib/Data/Multiset/NatAntidiagonal.lean

tactic: rw [antidiagonal, map_coe, List.Nat.map_swap_antidiagonal, coe_reverse]
state_before: n : ℕ
⊢ map Prod.swap (antidiagonal n) = antidiagonal n
state_after: no goals
Theorem: Finset.mulEnergy_eq_sum_sq
File: Mathlib/Combinatorics/Additive/Energy.lean

tactic: rw [mulEnergy_eq_sum_sq']
state_before: α : Type u_1
inst✝² : DecidableEq α
inst✝¹ : Mul α
s✝ s₁ s₂ t✝ t₁ t₂ : Finset α
inst✝ : Fintype α
s t : Finset α
⊢ Eₘ[s, t] =
    ∑ a : α,
      (filter
            (fun x =>
              match x with
              | (x, y) => x * y = a)
            (s ×ˢ t)).card ^
        2
state_after: α : Type u_1
inst✝² : DecidableEq α
inst✝¹ : Mul α
s✝ s₁ s₂ t✝ t₁ t₂ : Finset α
inst✝ : Fintype α
s t : Finset α
⊢ ∑ a ∈ s * t,
      (filter
            (fun x =>
              match x with
              | (x, y) => x * y = a)
            (s ×ˢ t)).card ^
        2 =
    ∑ a : α,
      (filter
            (fun x =>
              match x with
              | (x, y) => x * y = a)
            (s ×ˢ t)).card ^
        2

tactic: exact Fintype.sum_subset $ by aesop (add simp [filter_eq_empty_iff, mul_mem_mul])
state_before: α : Type u_1
inst✝² : DecidableEq α
inst✝¹ : Mul α
s✝ s₁ s₂ t✝ t₁ t₂ : Finset α
inst✝ : Fintype α
s t : Finset α
⊢ ∑ a ∈ s * t,
      (filter
            (fun x =>
              match x with
              | (x, y) => x * y = a)
            (s ×ˢ t)).card ^
        2 =
    ∑ a : α,
      (filter
            (fun x =>
              match x with
              | (x, y) => x * y = a)
            (s ×ˢ t)).card ^
        2
state_after: no goals

tactic: aesop (add simp [filter_eq_empty_iff, mul_mem_mul])
state_before: α : Type u_1
inst✝² : DecidableEq α
inst✝¹ : Mul α
s✝ s₁ s₂ t✝ t₁ t₂ : Finset α
inst✝ : Fintype α
s t : Finset α
⊢ ∀ (i : α),
    (filter
              (fun x =>
                match x with
                | (x, y) => x * y = i)
              (s ×ˢ t)).card ^
          2 ≠
        0 →
      i ∈ s * t
state_after: no goals
Theorem: AddConstMapClass.map_sub_nat'
File: Mathlib/Algebra/AddConstMap/Basic.lean

tactic: simpa using map_sub_nsmul f x n
state_before: F : Type u_1
G : Type u_2
H : Type u_3
inst✝³ : FunLike F G H
a : G
b : H
inst✝² : AddGroupWithOne G
inst✝¹ : AddGroup H
inst✝ : AddConstMapClass F G H 1 b
f : F
x : G
n : ℕ
⊢ f (x - ↑n) = f x - n • b
state_after: no goals
Theorem: Partrec.dom_re
File: Mathlib/Computability/Halting.lean

tactic: simp [Part.dom_iff_mem]
state_before: α : Type u_1
β : Type u_2
inst✝¹ : Primcodable α
inst✝ : Primcodable β
f : α →. β
h : Partrec f
n : α
x✝ : Unit
⊢ x✝ ∈ Part.map (fun b => ()) (f n) ↔ x✝ ∈ Part.assert ((fun a => (f a).Dom) n) fun x => Part.some ()
state_after: no goals
Theorem: MeasureTheory.tendsto_measure_iInter'
File: Mathlib/MeasureTheory/Measure/MeasureSpace.lean

tactic: rw [measure_iInter_eq_iInf' hm hf]
state_before: α✝ : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ι✝ : Type u_5
R : Type u_6
R' : Type u_7
m : MeasurableSpace α✝
μ✝ μ₁ μ₂ : Measure α✝
s s₁ s₂ t : Set α✝
α : Type u_8
ι : Type u_9
inst✝³ : MeasurableSpace α
μ : Measure α
inst✝² : Countable ι
inst✝¹ : Preorder ι
inst✝ : IsDirected ι fun x x_1 => x ≤ x_1
f : ι → Set α
hm : ∀ (i : ι), MeasurableSet (f i)
hf : ∃ i, μ (f i) ≠ ⊤
⊢ Tendsto (fun i => μ (⋂ j ∈ {j | j ≤ i}, f j)) atTop (𝓝 (μ (⋂ i, f i)))
state_after: α✝ : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ι✝ : Type u_5
R : Type u_6
R' : Type u_7
m : MeasurableSpace α✝
μ✝ μ₁ μ₂ : Measure α✝
s s₁ s₂ t : Set α✝
α : Type u_8
ι : Type u_9
inst✝³ : MeasurableSpace α
μ : Measure α
inst✝² : Countable ι
inst✝¹ : Preorder ι
inst✝ : IsDirected ι fun x x_1 => x ≤ x_1
f : ι → Set α
hm : ∀ (i : ι), MeasurableSet (f i)
hf : ∃ i, μ (f i) ≠ ⊤
⊢ Tendsto (fun i => μ (⋂ j ∈ {j | j ≤ i}, f j)) atTop (𝓝 (⨅ i, μ (⋂ j, ⋂ (_ : j ≤ i), f j)))

tactic: exact tendsto_atTop_iInf
  fun i j hij ↦ measure_mono <| biInter_subset_biInter_left fun k hki ↦ le_trans hki hij
state_before: α✝ : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ι✝ : Type u_5
R : Type u_6
R' : Type u_7
m : MeasurableSpace α✝
μ✝ μ₁ μ₂ : Measure α✝
s s₁ s₂ t : Set α✝
α : Type u_8
ι : Type u_9
inst✝³ : MeasurableSpace α
μ : Measure α
inst✝² : Countable ι
inst✝¹ : Preorder ι
inst✝ : IsDirected ι fun x x_1 => x ≤ x_1
f : ι → Set α
hm : ∀ (i : ι), MeasurableSet (f i)
hf : ∃ i, μ (f i) ≠ ⊤
⊢ Tendsto (fun i => μ (⋂ j ∈ {j | j ≤ i}, f j)) atTop (𝓝 (⨅ i, μ (⋂ j, ⋂ (_ : j ≤ i), f j)))
state_after: no goals
Theorem: QuadraticForm.isOrtho_inr_inr_iff
File: Mathlib/LinearAlgebra/QuadraticForm/Prod.lean

tactic: simp [isOrtho_def]
state_before: ι : Type u_1
R : Type u_2
M₁ : Type u_3
M₂ : Type u_4
N₁ : Type u_5
N₂ : Type u_6
Mᵢ : ι → Type u_7
Nᵢ : ι → Type u_8
inst✝⁸ : CommSemiring R
inst✝⁷ : AddCommMonoid M₁
inst✝⁶ : AddCommMonoid M₂
inst✝⁵ : AddCommMonoid N₁
inst✝⁴ : AddCommMonoid N₂
inst✝³ : Module R M₁
inst✝² : Module R M₂
inst✝¹ : Module R N₁
inst✝ : Module R N₂
Q₁ : QuadraticForm R M₁
Q₂ : QuadraticForm R M₂
m₂ m₂' : M₂
⊢ (Q₁.prod Q₂).IsOrtho (0, m₂) (0, m₂') ↔ Q₂.IsOrtho m₂ m₂'
state_after: no goals
Theorem: RCLike.ratCast_re
File: Mathlib/Analysis/RCLike/Basic.lean

tactic: rw [← ofReal_ratCast, ofReal_re]
state_before: K : Type u_1
E : Type u_2
inst✝ : RCLike K
z : K
q : ℚ
⊢ re ↑q = ↑q
state_after: no goals
Theorem: WeierstrassCurve.Jacobian.addXYZ_of_Z_ne_zero
File: Mathlib/AlgebraicGeometry/EllipticCurve/Jacobian.lean

tactic: have hZ {n : ℕ} : IsUnit <| addZ P Q ^ n := (isUnit_addZ_of_X_ne hx).pow n
state_before: R : Type u
inst✝¹ : CommRing R
W' : Jacobian R
F : Type v
inst✝ : Field F
W : Jacobian F
P Q : Fin 3 → F
hP : W.Equation P
hQ : W.Equation Q
hPz : P z ≠ 0
hQz : Q z ≠ 0
hx : P x * Q z ^ 2 ≠ Q x * P z ^ 2
⊢ W.addXYZ P Q =
    addZ P Q •
      ![W.toAffine.addX (P x / P z ^ 2) (Q x / Q z ^ 2)
          (W.toAffine.slope (P x / P z ^ 2) (Q x / Q z ^ 2) (P y / P z ^ 3) (Q y / Q z ^ 3)),
        W.toAffine.addY (P x / P z ^ 2) (Q x / Q z ^ 2) (P y / P z ^ 3)
          (W.toAffine.slope (P x / P z ^ 2) (Q x / Q z ^ 2) (P y / P z ^ 3) (Q y / Q z ^ 3)),
        1]
state_after: R : Type u
inst✝¹ : CommRing R
W' : Jacobian R
F : Type v
inst✝ : Field F
W : Jacobian F
P Q : Fin 3 → F
hP : W.Equation P
hQ : W.Equation Q
hPz : P z ≠ 0
hQz : Q z ≠ 0
hx : P x * Q z ^ 2 ≠ Q x * P z ^ 2
hZ : ∀ {n : ℕ}, IsUnit (addZ P Q ^ n)
⊢ W.addXYZ P Q =
    addZ P Q •
      ![W.toAffine.addX (P x / P z ^ 2) (Q x / Q z ^ 2)
          (W.toAffine.slope (P x / P z ^ 2) (Q x / Q z ^ 2) (P y / P z ^ 3) (Q y / Q z ^ 3)),
        W.toAffine.addY (P x / P z ^ 2) (Q x / Q z ^ 2) (P y / P z ^ 3)
          (W.toAffine.slope (P x / P z ^ 2) (Q x / Q z ^ 2) (P y / P z ^ 3) (Q y / Q z ^ 3)),
        1]

tactic: erw [addXYZ, smul_fin3, ← addX_of_Z_ne_zero hP hQ hPz hQz hx, hZ.mul_div_cancel,
  ← addY_of_Z_ne_zero hP hQ hPz hQz hx, hZ.mul_div_cancel, mul_one]
state_before: R : Type u
inst✝¹ : CommRing R
W' : Jacobian R
F : Type v
inst✝ : Field F
W : Jacobian F
P Q : Fin 3 → F
hP : W.Equation P
hQ : W.Equation Q
hPz : P z ≠ 0
hQz : Q z ≠ 0
hx : P x * Q z ^ 2 ≠ Q x * P z ^ 2
hZ : ∀ {n : ℕ}, IsUnit (addZ P Q ^ n)
⊢ W.addXYZ P Q =
    addZ P Q •
      ![W.toAffine.addX (P x / P z ^ 2) (Q x / Q z ^ 2)
          (W.toAffine.slope (P x / P z ^ 2) (Q x / Q z ^ 2) (P y / P z ^ 3) (Q y / Q z ^ 3)),
        W.toAffine.addY (P x / P z ^ 2) (Q x / Q z ^ 2) (P y / P z ^ 3)
          (W.toAffine.slope (P x / P z ^ 2) (Q x / Q z ^ 2) (P y / P z ^ 3) (Q y / Q z ^ 3)),
        1]
state_after: no goals
Theorem: LinearMap.map_algebraMap_mul
File: Mathlib/Algebra/Algebra/Basic.lean

tactic: rw [← Algebra.smul_def, ← Algebra.smul_def, map_smul]
state_before: R : Type u_1
A : Type u_2
B : Type u_3
inst✝⁴ : CommSemiring R
inst✝³ : Semiring A
inst✝² : Semiring B
inst✝¹ : Algebra R A
inst✝ : Algebra R B
f : A →ₗ[R] B
a : A
r : R
⊢ f ((algebraMap R A) r * a) = (algebraMap R B) r * f a
state_after: no goals
Theorem: MeasureTheory.Measure.setLIntegral_rnDeriv'
File: Mathlib/MeasureTheory/Decomposition/RadonNikodym.lean

tactic: rw [← withDensity_apply _ hs, Measure.withDensity_rnDeriv_eq _ _ hμν]
state_before: α : Type u_1
β : Type u_2
m : MeasurableSpace α
μ ν : Measure α
inst✝ : μ.HaveLebesgueDecomposition ν
hμν : μ ≪ ν
s : Set α
hs : MeasurableSet s
⊢ ∫⁻ (x : α) in s, μ.rnDeriv ν x ∂ν = μ s
state_after: no goals