1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: DirectSum.coe_decompose_mul_of_right_mem_of_not_le
File: Mathlib/RingTheory/GradedAlgebra/Basic.lean

tactic: lift b to 𝒜 i using b_mem
state_before: ι : Type u_1
R : Type u_2
A : Type u_3
σ : Type u_4
inst✝⁵ : Semiring A
inst✝⁴ : DecidableEq ι
inst✝³ : CanonicallyOrderedAddCommMonoid ι
inst✝² : SetLike σ A
inst✝¹ : AddSubmonoidClass σ A
𝒜 : ι → σ
inst✝ : GradedRing 𝒜
a b : A
n i : ι
b_mem : b ∈ 𝒜 i
h : ¬i ≤ n
⊢ ↑(((decompose 𝒜) (a * b)) n) = 0
state_after: case intro
ι : Type u_1
R : Type u_2
A : Type u_3
σ : Type u_4
inst✝⁵ : Semiring A
inst✝⁴ : DecidableEq ι
inst✝³ : CanonicallyOrderedAddCommMonoid ι
inst✝² : SetLike σ A
inst✝¹ : AddSubmonoidClass σ A
𝒜 : ι → σ
inst✝ : GradedRing 𝒜
a : A
n i : ι
h : ¬i ≤ n
b : ↥(𝒜 i)
⊢ ↑(((decompose 𝒜) (a * ↑b)) n) = 0

tactic: rwa [decompose_mul, decompose_coe, coe_mul_of_apply_of_not_le]
state_before: case intro
ι : Type u_1
R : Type u_2
A : Type u_3
σ : Type u_4
inst✝⁵ : Semiring A
inst✝⁴ : DecidableEq ι
inst✝³ : CanonicallyOrderedAddCommMonoid ι
inst✝² : SetLike σ A
inst✝¹ : AddSubmonoidClass σ A
𝒜 : ι → σ
inst✝ : GradedRing 𝒜
a : A
n i : ι
h : ¬i ≤ n
b : ↥(𝒜 i)
⊢ ↑(((decompose 𝒜) (a * ↑b)) n) = 0
state_after: no goals
Theorem: Finset.Ico_filter_lt_of_le_right
File: Mathlib/Order/Interval/Finset/Basic.lean

tactic: ext x
state_before: ι : Type u_1
α : Type u_2
inst✝² : Preorder α
inst✝¹ : LocallyFiniteOrder α
a a₁ a₂ b b₁ b₂ c x : α
inst✝ : DecidablePred fun x => x < c
hcb : c ≤ b
⊢ filter (fun x => x < c) (Ico a b) = Ico a c
state_after: case a
ι : Type u_1
α : Type u_2
inst✝² : Preorder α
inst✝¹ : LocallyFiniteOrder α
a a₁ a₂ b b₁ b₂ c x✝ : α
inst✝ : DecidablePred fun x => x < c
hcb : c ≤ b
x : α
⊢ x ∈ filter (fun x => x < c) (Ico a b) ↔ x ∈ Ico a c

tactic: rw [mem_filter, mem_Ico, mem_Ico, and_right_comm]
state_before: case a
ι : Type u_1
α : Type u_2
inst✝² : Preorder α
inst✝¹ : LocallyFiniteOrder α
a a₁ a₂ b b₁ b₂ c x✝ : α
inst✝ : DecidablePred fun x => x < c
hcb : c ≤ b
x : α
⊢ x ∈ filter (fun x => x < c) (Ico a b) ↔ x ∈ Ico a c
state_after: case a
ι : Type u_1
α : Type u_2
inst✝² : Preorder α
inst✝¹ : LocallyFiniteOrder α
a a₁ a₂ b b₁ b₂ c x✝ : α
inst✝ : DecidablePred fun x => x < c
hcb : c ≤ b
x : α
⊢ (a ≤ x ∧ x < c) ∧ x < b ↔ a ≤ x ∧ x < c

tactic: exact and_iff_left_of_imp fun h => h.2.trans_le hcb
state_before: case a
ι : Type u_1
α : Type u_2
inst✝² : Preorder α
inst✝¹ : LocallyFiniteOrder α
a a₁ a₂ b b₁ b₂ c x✝ : α
inst✝ : DecidablePred fun x => x < c
hcb : c ≤ b
x : α
⊢ (a ≤ x ∧ x < c) ∧ x < b ↔ a ≤ x ∧ x < c
state_after: no goals
Theorem: CategoryTheory.Limits.kernelSubobjectIsoComp_inv_arrow
File: Mathlib/CategoryTheory/Subobject/Limits.lean

tactic: simp [kernelSubobjectIsoComp]
state_before: C : Type u
inst✝⁴ : Category.{v, u} C
X Y Z : C
inst✝³ : HasZeroMorphisms C
f✝ : X ⟶ Y
inst✝² : HasKernel f✝
X' : C
f : X' ⟶ X
inst✝¹ : IsIso f
g : X ⟶ Y
inst✝ : HasKernel g
⊢ (kernelSubobjectIsoComp f g).inv ≫ (kernelSubobject (f ≫ g)).arrow = (kernelSubobject g).arrow ≫ inv f
state_after: no goals
Theorem: Filter.IsBoundedUnder.sup
File: Mathlib/Order/LiminfLimsup.lean

tactic: filter_upwards [hu, hv] with _ using sup_le_sup
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
ι' : Type u_5
inst✝ : SemilatticeSup α
f : Filter β
u v : β → α
bu : α
hu : ∀ᶠ (x : β) in f, u x ≤ bu
bv : α
hv : ∀ᶠ (x : β) in f, v x ≤ bv
⊢ ∀ᶠ (x : β) in f, u x ⊔ v x ≤ bu ⊔ bv
state_after: no goals
Theorem: Cardinal.extend_function_finite
File: Mathlib/SetTheory/Cardinal/Ordinal.lean

tactic: apply extend_function.{u, v} f
state_before: α : Type u
β : Type v
inst✝ : Finite α
s : Set α
f : ↑s ↪ β
h : Nonempty (α ≃ β)
⊢ ∃ g, ∀ (x : ↑s), g ↑x = f x
state_after: α : Type u
β : Type v
inst✝ : Finite α
s : Set α
f : ↑s ↪ β
h : Nonempty (α ≃ β)
⊢ Nonempty (↑sᶜ ≃ ↑(range ⇑f)ᶜ)

tactic: cases' id h with g
state_before: α : Type u
β : Type v
inst✝ : Finite α
s : Set α
f : ↑s ↪ β
h : Nonempty (α ≃ β)
⊢ Nonempty (↑sᶜ ≃ ↑(range ⇑f)ᶜ)
state_after: case intro
α : Type u
β : Type v
inst✝ : Finite α
s : Set α
f : ↑s ↪ β
h : Nonempty (α ≃ β)
g : α ≃ β
⊢ Nonempty (↑sᶜ ≃ ↑(range ⇑f)ᶜ)

tactic: rw [← lift_mk_eq.{u, v, max u v}] at h
state_before: case intro
α : Type u
β : Type v
inst✝ : Finite α
s : Set α
f : ↑s ↪ β
h : Nonempty (α ≃ β)
g : α ≃ β
⊢ Nonempty (↑sᶜ ≃ ↑(range ⇑f)ᶜ)
state_after: case intro
α : Type u
β : Type v
inst✝ : Finite α
s : Set α
f : ↑s ↪ β
h : lift.{max u v, u} #α = lift.{max u v, v} #β
g : α ≃ β
⊢ Nonempty (↑sᶜ ≃ ↑(range ⇑f)ᶜ)

tactic: rw [← lift_mk_eq.{u, v, max u v}, mk_compl_eq_mk_compl_finite_lift.{u, v, max u v} h]
state_before: case intro
α : Type u
β : Type v
inst✝ : Finite α
s : Set α
f : ↑s ↪ β
h : lift.{max u v, u} #α = lift.{max u v, v} #β
g : α ≃ β
⊢ Nonempty (↑sᶜ ≃ ↑(range ⇑f)ᶜ)
state_after: case intro
α : Type u
β : Type v
inst✝ : Finite α
s : Set α
f : ↑s ↪ β
h : lift.{max u v, u} #α = lift.{max u v, v} #β
g : α ≃ β
⊢ lift.{max u v, u} #↑s = lift.{max u v, v} #↑(range ⇑f)

tactic: rw [mk_range_eq_lift.{u, v, max u v}]
state_before: case intro
α : Type u
β : Type v
inst✝ : Finite α
s : Set α
f : ↑s ↪ β
h : lift.{max u v, u} #α = lift.{max u v, v} #β
g : α ≃ β
⊢ lift.{max u v, u} #↑s = lift.{max u v, v} #↑(range ⇑f)
state_after: case intro
α : Type u
β : Type v
inst✝ : Finite α
s : Set α
f : ↑s ↪ β
h : lift.{max u v, u} #α = lift.{max u v, v} #β
g : α ≃ β
⊢ Injective ⇑f

tactic: exact f.2
state_before: case intro
α : Type u
β : Type v
inst✝ : Finite α
s : Set α
f : ↑s ↪ β
h : lift.{max u v, u} #α = lift.{max u v, v} #β
g : α ≃ β
⊢ Injective ⇑f
state_after: no goals
Theorem: WeierstrassCurve.ΨSq_even
File: Mathlib/AlgebraicGeometry/EllipticCurve/DivisionPolynomial/Basic.lean

tactic: erw [ΨSq_ofNat, preΨ'_even, if_pos <| even_two_mul _]
state_before: R : Type r
S : Type s
inst✝¹ : CommRing R
inst✝ : CommRing S
W : WeierstrassCurve R
m : ℕ
⊢ W.ΨSq (2 * (↑m + 3)) =
    (W.preΨ' (m + 2) ^ 2 * W.preΨ' (m + 3) * W.preΨ' (m + 5) -
          W.preΨ' (m + 1) * W.preΨ' (m + 3) * W.preΨ' (m + 4) ^ 2) ^
        2 *
      W.Ψ₂Sq
state_after: no goals
Theorem: Sum.Lex.Ioo_inl_inl
File: Mathlib/Data/Sum/Interval.lean

tactic: rw [← Finset.map_map]
state_before: α : Type u_1
β : Type u_2
inst✝⁵ : Preorder α
inst✝⁴ : Preorder β
inst✝³ : OrderTop α
inst✝² : OrderBot β
inst✝¹ : LocallyFiniteOrder α
inst✝ : LocallyFiniteOrder β
a a₁ a₂ : α
b b₁ b₂ : β
⊢ Ioo (inlₗ a₁) (inlₗ a₂) = map (Embedding.inl.trans toLex.toEmbedding) (Ioo a₁ a₂)
state_after: α : Type u_1
β : Type u_2
inst✝⁵ : Preorder α
inst✝⁴ : Preorder β
inst✝³ : OrderTop α
inst✝² : OrderBot β
inst✝¹ : LocallyFiniteOrder α
inst✝ : LocallyFiniteOrder β
a a₁ a₂ : α
b b₁ b₂ : β
⊢ Ioo (inlₗ a₁) (inlₗ a₂) = map toLex.toEmbedding (map Embedding.inl (Ioo a₁ a₂))

tactic: rfl
state_before: α : Type u_1
β : Type u_2
inst✝⁵ : Preorder α
inst✝⁴ : Preorder β
inst✝³ : OrderTop α
inst✝² : OrderBot β
inst✝¹ : LocallyFiniteOrder α
inst✝ : LocallyFiniteOrder β
a a₁ a₂ : α
b b₁ b₂ : β
⊢ Ioo (inlₗ a₁) (inlₗ a₂) = map toLex.toEmbedding (map Embedding.inl (Ioo a₁ a₂))
state_after: no goals
Theorem: Multiset.dedup_ext
File: Mathlib/Data/Multiset/Dedup.lean

tactic: simp [Nodup.ext]
state_before: α : Type u_1
β : Type u_2
inst✝ : DecidableEq α
s t : Multiset α
⊢ s.dedup = t.dedup ↔ ∀ (a : α), a ∈ s ↔ a ∈ t
state_after: no goals
Theorem: List.countP_attach
File: Mathlib/Data/List/Count.lean

tactic: simp_rw [← Function.comp_apply (g := Subtype.val), ← countP_map, attach_map_val]
state_before: α : Type u_1
l✝ : List α
p q : α → Bool
l : List α
⊢ countP (fun a => p ↑a) l.attach = countP p l
state_after: no goals
Theorem: Function.Injective.preimage_pullbackDiagonal
File: Mathlib/Data/Set/Prod.lean

tactic: rfl
state_before: X : Type ?u.78296
Y : Sort ?u.78270
Z : Type ?u.78297
f : X → Y
g : Z → X
inj : Injective g
⊢ f ∘ g = id ∘ f ∘ g
state_after: no goals
Theorem: Real.arccos_zero
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Inverse.lean

tactic: simp [arccos]
state_before: x y : ℝ
⊢ arccos 0 = π / 2
state_after: no goals
Theorem: CategoryTheory.Equalizer.Sieve.SecondObj.ext
File: Mathlib/CategoryTheory/Sites/EqualizerSheafCondition.lean

tactic: apply Limits.Types.limit_ext
state_before: C : Type u
inst✝ : Category.{v, u} C
P : Cᵒᵖ ⥤ Type (max v u)
X : C
R : Presieve X
S : Sieve X
z₁ z₂ : SecondObj P S
h :
  ∀ (Y Z : C) (g : Z ⟶ Y) (f : Y ⟶ X) (hf : S.arrows f),
    Pi.π (fun f => P.obj { unop := f.snd.fst }) ⟨Y, ⟨Z, ⟨g, ⟨f, hf⟩⟩⟩⟩ z₁ =
      Pi.π (fun f => P.obj { unop := f.snd.fst }) ⟨Y, ⟨Z, ⟨g, ⟨f, hf⟩⟩⟩⟩ z₂
⊢ z₁ = z₂
state_after: case w
C : Type u
inst✝ : Category.{v, u} C
P : Cᵒᵖ ⥤ Type (max v u)
X : C
R : Presieve X
S : Sieve X
z₁ z₂ : SecondObj P S
h :
  ∀ (Y Z : C) (g : Z ⟶ Y) (f : Y ⟶ X) (hf : S.arrows f),
    Pi.π (fun f => P.obj { unop := f.snd.fst }) ⟨Y, ⟨Z, ⟨g, ⟨f, hf⟩⟩⟩⟩ z₁ =
      Pi.π (fun f => P.obj { unop := f.snd.fst }) ⟨Y, ⟨Z, ⟨g, ⟨f, hf⟩⟩⟩⟩ z₂
⊢ ∀ (j : Discrete ((Y : C) × (Z : C) × (_ : Z ⟶ Y) × { f' // S.arrows f' })),
    limit.π (Discrete.functor fun f => P.obj { unop := f.snd.fst }) j z₁ =
      limit.π (Discrete.functor fun f => P.obj { unop := f.snd.fst }) j z₂

tactic: rintro ⟨⟨Y, Z, g, f, hf⟩⟩
state_before: case w
C : Type u
inst✝ : Category.{v, u} C
P : Cᵒᵖ ⥤ Type (max v u)
X : C
R : Presieve X
S : Sieve X
z₁ z₂ : SecondObj P S
h :
  ∀ (Y Z : C) (g : Z ⟶ Y) (f : Y ⟶ X) (hf : S.arrows f),
    Pi.π (fun f => P.obj { unop := f.snd.fst }) ⟨Y, ⟨Z, ⟨g, ⟨f, hf⟩⟩⟩⟩ z₁ =
      Pi.π (fun f => P.obj { unop := f.snd.fst }) ⟨Y, ⟨Z, ⟨g, ⟨f, hf⟩⟩⟩⟩ z₂
⊢ ∀ (j : Discrete ((Y : C) × (Z : C) × (_ : Z ⟶ Y) × { f' // S.arrows f' })),
    limit.π (Discrete.functor fun f => P.obj { unop := f.snd.fst }) j z₁ =
      limit.π (Discrete.functor fun f => P.obj { unop := f.snd.fst }) j z₂
state_after: case w.mk.mk.mk.mk.mk
C : Type u
inst✝ : Category.{v, u} C
P : Cᵒᵖ ⥤ Type (max v u)
X : C
R : Presieve X
S : Sieve X
z₁ z₂ : SecondObj P S
h :
  ∀ (Y Z : C) (g : Z ⟶ Y) (f : Y ⟶ X) (hf : S.arrows f),
    Pi.π (fun f => P.obj { unop := f.snd.fst }) ⟨Y, ⟨Z, ⟨g, ⟨f, hf⟩⟩⟩⟩ z₁ =
      Pi.π (fun f => P.obj { unop := f.snd.fst }) ⟨Y, ⟨Z, ⟨g, ⟨f, hf⟩⟩⟩⟩ z₂
Y Z : C
g : Z ⟶ Y
f : Y ⟶ X
hf : S.arrows f
⊢ limit.π (Discrete.functor fun f => P.obj { unop := f.snd.fst }) { as := ⟨Y, ⟨Z, ⟨g, ⟨f, hf⟩⟩⟩⟩ } z₁ =
    limit.π (Discrete.functor fun f => P.obj { unop := f.snd.fst }) { as := ⟨Y, ⟨Z, ⟨g, ⟨f, hf⟩⟩⟩⟩ } z₂

tactic: apply h
state_before: case w.mk.mk.mk.mk.mk
C : Type u
inst✝ : Category.{v, u} C
P : Cᵒᵖ ⥤ Type (max v u)
X : C
R : Presieve X
S : Sieve X
z₁ z₂ : SecondObj P S
h :
  ∀ (Y Z : C) (g : Z ⟶ Y) (f : Y ⟶ X) (hf : S.arrows f),
    Pi.π (fun f => P.obj { unop := f.snd.fst }) ⟨Y, ⟨Z, ⟨g, ⟨f, hf⟩⟩⟩⟩ z₁ =
      Pi.π (fun f => P.obj { unop := f.snd.fst }) ⟨Y, ⟨Z, ⟨g, ⟨f, hf⟩⟩⟩⟩ z₂
Y Z : C
g : Z ⟶ Y
f : Y ⟶ X
hf : S.arrows f
⊢ limit.π (Discrete.functor fun f => P.obj { unop := f.snd.fst }) { as := ⟨Y, ⟨Z, ⟨g, ⟨f, hf⟩⟩⟩⟩ } z₁ =
    limit.π (Discrete.functor fun f => P.obj { unop := f.snd.fst }) { as := ⟨Y, ⟨Z, ⟨g, ⟨f, hf⟩⟩⟩⟩ } z₂
state_after: no goals
Theorem: ExpChar.exists
File: Mathlib/Algebra/CharP/ExpChar.lean

tactic: obtain _ | ⟨p, ⟨hp⟩, _⟩ := CharP.exists' R
state_before: R : Type u
inst✝¹ : Ring R
inst✝ : IsDomain R
⊢ ∃ q, ExpChar R q
state_after: case inl
R : Type u
inst✝¹ : Ring R
inst✝ : IsDomain R
h✝ : CharZero R
⊢ ∃ q, ExpChar R q

case inr.intro.intro.mk
R : Type u
inst✝¹ : Ring R
inst✝ : IsDomain R
p : ℕ
right✝ : CharP R p
hp : Nat.Prime p
⊢ ∃ q, ExpChar R q

tactic: exacts [⟨1, .zero⟩, ⟨p, .prime hp⟩]
state_before: case inl
R : Type u
inst✝¹ : Ring R
inst✝ : IsDomain R
h✝ : CharZero R
⊢ ∃ q, ExpChar R q

case inr.intro.intro.mk
R : Type u
inst✝¹ : Ring R
inst✝ : IsDomain R
p : ℕ
right✝ : CharP R p
hp : Nat.Prime p
⊢ ∃ q, ExpChar R q
state_after: no goals
Theorem: MeasureTheory.upperCrossingTime_le_lowerCrossingTime
File: Mathlib/Probability/Martingale/Upcrossing.lean

tactic: simp only [lowerCrossingTime, le_hitting upperCrossingTime_le ω]
state_before: Ω : Type u_1
ι : Type u_2
m0 : MeasurableSpace Ω
μ : Measure Ω
inst✝ : ConditionallyCompleteLinearOrderBot ι
a b : ℝ
f : ι → Ω → ℝ
N : ι
n m : ℕ
ω : Ω
⊢ upperCrossingTime a b f N n ω ≤ lowerCrossingTime a b f N n ω
state_after: no goals
Theorem: Zsqrtd.norm_conj
File: Mathlib/NumberTheory/Zsqrtd/Basic.lean

tactic: rw [norm_eq_mul_conj, star_star, mul_comm, norm_eq_mul_conj]
state_before: d : ℤ
x : ℤ√d
⊢ ↑(star x).norm = ↑x.norm
state_after: no goals
Theorem: MeasureTheory.ProbabilityMeasure.tendsto_iff_forall_lintegral_tendsto
File: Mathlib/MeasureTheory/Measure/ProbabilityMeasure.lean

tactic: rw [tendsto_nhds_iff_toFiniteMeasure_tendsto_nhds]
state_before: Ω : Type u_1
inst✝² : MeasurableSpace Ω
inst✝¹ : TopologicalSpace Ω
inst✝ : OpensMeasurableSpace Ω
γ : Type u_2
F : Filter γ
μs : γ → ProbabilityMeasure Ω
μ : ProbabilityMeasure Ω
⊢ Tendsto μs F (𝓝 μ) ↔ ∀ (f : Ω →ᵇ ℝ≥0), Tendsto (fun i => ∫⁻ (ω : Ω), ↑(f ω) ∂↑(μs i)) F (𝓝 (∫⁻ (ω : Ω), ↑(f ω) ∂↑μ))
state_after: Ω : Type u_1
inst✝² : MeasurableSpace Ω
inst✝¹ : TopologicalSpace Ω
inst✝ : OpensMeasurableSpace Ω
γ : Type u_2
F : Filter γ
μs : γ → ProbabilityMeasure Ω
μ : ProbabilityMeasure Ω
⊢ Tendsto (toFiniteMeasure ∘ μs) F (𝓝 μ.toFiniteMeasure) ↔
    ∀ (f : Ω →ᵇ ℝ≥0), Tendsto (fun i => ∫⁻ (ω : Ω), ↑(f ω) ∂↑(μs i)) F (𝓝 (∫⁻ (ω : Ω), ↑(f ω) ∂↑μ))

tactic: exact FiniteMeasure.tendsto_iff_forall_lintegral_tendsto
state_before: Ω : Type u_1
inst✝² : MeasurableSpace Ω
inst✝¹ : TopologicalSpace Ω
inst✝ : OpensMeasurableSpace Ω
γ : Type u_2
F : Filter γ
μs : γ → ProbabilityMeasure Ω
μ : ProbabilityMeasure Ω
⊢ Tendsto (toFiniteMeasure ∘ μs) F (𝓝 μ.toFiniteMeasure) ↔
    ∀ (f : Ω →ᵇ ℝ≥0), Tendsto (fun i => ∫⁻ (ω : Ω), ↑(f ω) ∂↑(μs i)) F (𝓝 (∫⁻ (ω : Ω), ↑(f ω) ∂↑μ))
state_after: no goals
Theorem: LinearMap.range_eq_top_of_cancel
File: Mathlib/LinearAlgebra/Quotient.lean

tactic: have h₁ : (0 : M₂ →ₗ[R₂] M₂ ⧸ (range f)).comp f = 0 := zero_comp _
state_before: R : Type u_1
M : Type u_2
R₂ : Type u_3
M₂ : Type u_4
R₃ : Type u_5
M₃ : Type u_6
inst✝¹⁰ : Ring R
inst✝⁹ : Ring R₂
inst✝⁸ : Ring R₃
inst✝⁷ : AddCommMonoid M
inst✝⁶ : AddCommGroup M₂
inst✝⁵ : AddCommMonoid M₃
inst✝⁴ : Module R M
inst✝³ : Module R₂ M₂
inst✝² : Module R₃ M₃
τ₁₂ : R →+* R₂
τ₂₃ : R₂ →+* R₃
τ₁₃ : R →+* R₃
inst✝¹ : RingHomCompTriple τ₁₂ τ₂₃ τ₁₃
inst✝ : RingHomSurjective τ₁₂
f : M →ₛₗ[τ₁₂] M₂
h : ∀ (u v : M₂ →ₗ[R₂] M₂ ⧸ range f), u.comp f = v.comp f → u = v
⊢ range f = ⊤
state_after: R : Type u_1
M : Type u_2
R₂ : Type u_3
M₂ : Type u_4
R₃ : Type u_5
M₃ : Type u_6
inst✝¹⁰ : Ring R
inst✝⁹ : Ring R₂
inst✝⁸ : Ring R₃
inst✝⁷ : AddCommMonoid M
inst✝⁶ : AddCommGroup M₂
inst✝⁵ : AddCommMonoid M₃
inst✝⁴ : Module R M
inst✝³ : Module R₂ M₂
inst✝² : Module R₃ M₃
τ₁₂ : R →+* R₂
τ₂₃ : R₂ →+* R₃
τ₁₃ : R →+* R₃
inst✝¹ : RingHomCompTriple τ₁₂ τ₂₃ τ₁₃
inst✝ : RingHomSurjective τ₁₂
f : M →ₛₗ[τ₁₂] M₂
h : ∀ (u v : M₂ →ₗ[R₂] M₂ ⧸ range f), u.comp f = v.comp f → u = v
h₁ : comp 0 f = 0
⊢ range f = ⊤

tactic: rw [← Submodule.ker_mkQ (range f), ← h 0 f.range.mkQ (Eq.trans h₁ (range_mkQ_comp _).symm)]
state_before: R : Type u_1
M : Type u_2
R₂ : Type u_3
M₂ : Type u_4
R₃ : Type u_5
M₃ : Type u_6
inst✝¹⁰ : Ring R
inst✝⁹ : Ring R₂
inst✝⁸ : Ring R₃
inst✝⁷ : AddCommMonoid M
inst✝⁶ : AddCommGroup M₂
inst✝⁵ : AddCommMonoid M₃
inst✝⁴ : Module R M
inst✝³ : Module R₂ M₂
inst✝² : Module R₃ M₃
τ₁₂ : R →+* R₂
τ₂₃ : R₂ →+* R₃
τ₁₃ : R →+* R₃
inst✝¹ : RingHomCompTriple τ₁₂ τ₂₃ τ₁₃
inst✝ : RingHomSurjective τ₁₂
f : M →ₛₗ[τ₁₂] M₂
h : ∀ (u v : M₂ →ₗ[R₂] M₂ ⧸ range f), u.comp f = v.comp f → u = v
h₁ : comp 0 f = 0
⊢ range f = ⊤
state_after: R : Type u_1
M : Type u_2
R₂ : Type u_3
M₂ : Type u_4
R₃ : Type u_5
M₃ : Type u_6
inst✝¹⁰ : Ring R
inst✝⁹ : Ring R₂
inst✝⁸ : Ring R₃
inst✝⁷ : AddCommMonoid M
inst✝⁶ : AddCommGroup M₂
inst✝⁵ : AddCommMonoid M₃
inst✝⁴ : Module R M
inst✝³ : Module R₂ M₂
inst✝² : Module R₃ M₃
τ₁₂ : R →+* R₂
τ₂₃ : R₂ →+* R₃
τ₁₃ : R →+* R₃
inst✝¹ : RingHomCompTriple τ₁₂ τ₂₃ τ₁₃
inst✝ : RingHomSurjective τ₁₂
f : M →ₛₗ[τ₁₂] M₂
h : ∀ (u v : M₂ →ₗ[R₂] M₂ ⧸ range f), u.comp f = v.comp f → u = v
h₁ : comp 0 f = 0
⊢ ker 0 = ⊤

tactic: exact ker_zero
state_before: R : Type u_1
M : Type u_2
R₂ : Type u_3
M₂ : Type u_4
R₃ : Type u_5
M₃ : Type u_6
inst✝¹⁰ : Ring R
inst✝⁹ : Ring R₂
inst✝⁸ : Ring R₃
inst✝⁷ : AddCommMonoid M
inst✝⁶ : AddCommGroup M₂
inst✝⁵ : AddCommMonoid M₃
inst✝⁴ : Module R M
inst✝³ : Module R₂ M₂
inst✝² : Module R₃ M₃
τ₁₂ : R →+* R₂
τ₂₃ : R₂ →+* R₃
τ₁₃ : R →+* R₃
inst✝¹ : RingHomCompTriple τ₁₂ τ₂₃ τ₁₃
inst✝ : RingHomSurjective τ₁₂
f : M →ₛₗ[τ₁₂] M₂
h : ∀ (u v : M₂ →ₗ[R₂] M₂ ⧸ range f), u.comp f = v.comp f → u = v
h₁ : comp 0 f = 0
⊢ ker 0 = ⊤
state_after: no goals
Theorem: Int.bodd_add_div2
File: Mathlib/Data/Int/Bitwise.lean

tactic: rw [show (cond (bodd n) 1 0 : ℤ) = (cond (bodd n) 1 0 : ℕ) by cases bodd n <;> rfl]
state_before: n : ℕ
⊢ (bif (↑n).bodd then 1 else 0) + 2 * (↑n).div2 = ↑n
state_after: n : ℕ
⊢ ↑(bif (↑n).bodd then 1 else 0) + 2 * (↑n).div2 = ↑n

tactic: exact congr_arg ofNat n.bodd_add_div2
state_before: n : ℕ
⊢ ↑(bif (↑n).bodd then 1 else 0) + 2 * (↑n).div2 = ↑n
state_after: no goals

tactic: cases bodd n <;> rfl
state_before: n : ℕ
⊢ (bif (↑n).bodd then 1 else 0) = ↑(bif (↑n).bodd then 1 else 0)
state_after: no goals

tactic: refine Eq.trans ?_ (congr_arg negSucc n.bodd_add_div2)
state_before: n : ℕ
⊢ (bif -[n+1].bodd then 1 else 0) + 2 * -[n+1].div2 = -[n+1]
state_after: n : ℕ
⊢ (bif -[n+1].bodd then 1 else 0) + 2 * -[n+1].div2 = -[(bif n.bodd then 1 else 0) + 2 * n.div2+1]

tactic: dsimp [bodd]
state_before: n : ℕ
⊢ (bif -[n+1].bodd then 1 else 0) + 2 * -[n+1].div2 = -[(bif n.bodd then 1 else 0) + 2 * n.div2+1]
state_after: n : ℕ
⊢ (bif !n.bodd then 1 else 0) + 2 * -[n+1].div2 = -[(bif n.bodd then 1 else 0) + 2 * n.div2+1]

tactic: cases Nat.bodd n <;> dsimp [cond, not, div2, Int.mul]
state_before: n : ℕ
⊢ (bif !n.bodd then 1 else 0) + 2 * -[n+1].div2 = -[(bif n.bodd then 1 else 0) + 2 * n.div2+1]
state_after: case false
n : ℕ
⊢ 1 + 2 * -[n.div2+1] = -[0 + 2 * n.div2+1]

case true
n : ℕ
⊢ 0 + 2 * -[n.div2+1] = -[1 + 2 * n.div2+1]

tactic: change -[2 * Nat.div2 n+1] = _
state_before: case false
n : ℕ
⊢ 1 + 2 * -[n.div2+1] = -[0 + 2 * n.div2+1]
state_after: case false
n : ℕ
⊢ -[2 * n.div2+1] = -[0 + 2 * n.div2+1]

tactic: rw [zero_add]
state_before: case false
n : ℕ
⊢ -[2 * n.div2+1] = -[0 + 2 * n.div2+1]
state_after: no goals

tactic: rw [zero_add, add_comm]
state_before: case true
n : ℕ
⊢ 0 + 2 * -[n.div2+1] = -[1 + 2 * n.div2+1]
state_after: case true
n : ℕ
⊢ 2 * -[n.div2+1] = -[2 * n.div2 + 1+1]

tactic: rfl
state_before: case true
n : ℕ
⊢ 2 * -[n.div2+1] = -[2 * n.div2 + 1+1]
state_after: no goals
Theorem: Real.one_sub_two_div_pi_mul_le_cos
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Bounds.lean

tactic: simpa [sin_pi_div_two_sub, mul_sub, div_mul_div_comm, mul_comm π, div_self two_pi_pos.ne']
  using two_div_pi_mul_le_sin (x := π / 2 - x) (by simpa) (by simpa)
state_before: x : ℝ
hx₀ : 0 ≤ x
hx : x ≤ π / 2
⊢ 1 - 2 / π * x ≤ cos x
state_after: no goals

tactic: simpa
state_before: x : ℝ
hx₀ : 0 ≤ x
hx : x ≤ π / 2
⊢ 0 ≤ π / 2 - x
state_after: no goals

tactic: simpa
state_before: x : ℝ
hx₀ : 0 ≤ x
hx : x ≤ π / 2
⊢ π / 2 - x ≤ π / 2
state_after: no goals
Theorem: Real.integral_rpow_mul_exp_neg_mul_Ioi
File: Mathlib/Analysis/SpecialFunctions/Gamma/Basic.lean

tactic: rw [← ofReal_inj, ofReal_mul, ← Gamma_ofReal, ofReal_cpow (by positivity), ofReal_div]
state_before: a r : ℝ
ha : 0 < a
hr : 0 < r
⊢ ∫ (t : ℝ) in Ioi 0, t ^ (a - 1) * rexp (-(r * t)) = (1 / r) ^ a * Gamma a
state_after: a r : ℝ
ha : 0 < a
hr : 0 < r
⊢ ↑(∫ (t : ℝ) in Ioi 0, t ^ (a - 1) * rexp (-(r * t))) = (↑1 / ↑r) ^ ↑a * Complex.Gamma ↑a

tactic: convert integral_cpow_mul_exp_neg_mul_Ioi (by rwa [ofReal_re] : 0 < (a : ℂ).re) hr
state_before: a r : ℝ
ha : 0 < a
hr : 0 < r
⊢ ↑(∫ (t : ℝ) in Ioi 0, t ^ (a - 1) * rexp (-(r * t))) = (↑1 / ↑r) ^ ↑a * Complex.Gamma ↑a
state_after: case h.e'_2
a r : ℝ
ha : 0 < a
hr : 0 < r
⊢ ↑(∫ (t : ℝ) in Ioi 0, t ^ (a - 1) * rexp (-(r * t))) = ∫ (t : ℝ) in Ioi 0, ↑t ^ (↑a - 1) * cexp (-(↑r * ↑t))

tactic: refine _root_.integral_ofReal.symm.trans <| setIntegral_congr measurableSet_Ioi (fun t ht ↦ ?_)
state_before: case h.e'_2
a r : ℝ
ha : 0 < a
hr : 0 < r
⊢ ↑(∫ (t : ℝ) in Ioi 0, t ^ (a - 1) * rexp (-(r * t))) = ∫ (t : ℝ) in Ioi 0, ↑t ^ (↑a - 1) * cexp (-(↑r * ↑t))
state_after: case h.e'_2
a r : ℝ
ha : 0 < a
hr : 0 < r
t : ℝ
ht : t ∈ Ioi 0
⊢ ↑(t ^ (a - 1) * rexp (-(r * t))) = ↑t ^ (↑a - 1) * cexp (-(↑r * ↑t))

tactic: norm_cast
state_before: case h.e'_2
a r : ℝ
ha : 0 < a
hr : 0 < r
t : ℝ
ht : t ∈ Ioi 0
⊢ ↑(t ^ (a - 1) * rexp (-(r * t))) = ↑t ^ (↑a - 1) * cexp (-(↑r * ↑t))
state_after: case h.e'_2
a r : ℝ
ha : 0 < a
hr : 0 < r
t : ℝ
ht : t ∈ Ioi 0
⊢ ↑(t ^ (a - 1) * rexp (-(r * t))) = ↑t ^ ↑(a - 1) * ↑(rexp (-(r * t)))

tactic: rw [← ofReal_cpow (le_of_lt ht), RCLike.ofReal_mul]
state_before: case h.e'_2
a r : ℝ
ha : 0 < a
hr : 0 < r
t : ℝ
ht : t ∈ Ioi 0
⊢ ↑(t ^ (a - 1) * rexp (-(r * t))) = ↑t ^ ↑(a - 1) * ↑(rexp (-(r * t)))
state_after: case h.e'_2
a r : ℝ
ha : 0 < a
hr : 0 < r
t : ℝ
ht : t ∈ Ioi 0
⊢ ↑(t ^ (a - 1)) * ↑(rexp (-(r * t))) = ↑(t ^ (a - 1)) * ↑(rexp (-(r * t)))

tactic: rfl
state_before: case h.e'_2
a r : ℝ
ha : 0 < a
hr : 0 < r
t : ℝ
ht : t ∈ Ioi 0
⊢ ↑(t ^ (a - 1)) * ↑(rexp (-(r * t))) = ↑(t ^ (a - 1)) * ↑(rexp (-(r * t)))
state_after: no goals

tactic: positivity
state_before: a r : ℝ
ha : 0 < a
hr : 0 < r
⊢ 0 ≤ 1 / r
state_after: no goals

tactic: rwa [ofReal_re]
state_before: a r : ℝ
ha : 0 < a
hr : 0 < r
⊢ 0 < (↑a).re
state_after: no goals
Theorem: mul_self_lt_one_iff
File: Mathlib/Algebra/Order/Monoid/Defs.lean

tactic: simp [← not_iff_not]
state_before: α : Type u_1
β : Type u_2
inst✝ : LinearOrderedCommMonoid α
a : α
⊢ a * a < 1 ↔ a < 1
state_after: no goals
Theorem: Set.mulIndicator_diff
File: Mathlib/Algebra/Group/Indicator.lean

tactic: rw [Pi.mul_def, ← mulIndicator_union_of_disjoint, diff_union_self,
  union_eq_self_of_subset_right h]
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
M : Type u_4
N : Type u_5
G : Type u_6
inst✝ : Group G
s t : Set α
f✝ g : α → G
a : α
h : s ⊆ t
f : α → G
⊢ (t \ s).mulIndicator f * s.mulIndicator f = t.mulIndicator f
state_after: case h
α : Type u_1
β : Type u_2
ι : Type u_3
M : Type u_4
N : Type u_5
G : Type u_6
inst✝ : Group G
s t : Set α
f✝ g : α → G
a : α
h : s ⊆ t
f : α → G
⊢ Disjoint (t \ s) s

tactic: exact disjoint_sdiff_self_left
state_before: case h
α : Type u_1
β : Type u_2
ι : Type u_3
M : Type u_4
N : Type u_5
G : Type u_6
inst✝ : Group G
s t : Set α
f✝ g : α → G
a : α
h : s ⊆ t
f : α → G
⊢ Disjoint (t \ s) s
state_after: no goals
Theorem: BoxIntegral.TaggedPrepartition.IsHenstock.card_filter_tag_eq_le
File: Mathlib/Analysis/BoxIntegral/Partition/Tagged.lean

tactic: refine Finset.card_le_card fun J hJ => ?_
state_before: ι : Type u_1
I J : Box ι
π π₁ π₂ : TaggedPrepartition I
x✝ : ι → ℝ
inst✝ : Fintype ι
h : π.IsHenstock
x : ι → ℝ
⊢ (Finset.filter (fun J => π.tag J = x) π.boxes).card ≤ (Finset.filter (fun J => x ∈ Box.Icc J) π.boxes).card
state_after: ι : Type u_1
I J✝ : Box ι
π π₁ π₂ : TaggedPrepartition I
x✝ : ι → ℝ
inst✝ : Fintype ι
h : π.IsHenstock
x : ι → ℝ
J : Box ι
hJ : J ∈ Finset.filter (fun J => π.tag J = x) π.boxes
⊢ J ∈ Finset.filter (fun J => x ∈ Box.Icc J) π.boxes

tactic: rw [Finset.mem_filter] at hJ ⊢
state_before: ι : Type u_1
I J✝ : Box ι
π π₁ π₂ : TaggedPrepartition I
x✝ : ι → ℝ
inst✝ : Fintype ι
h : π.IsHenstock
x : ι → ℝ
J : Box ι
hJ : J ∈ Finset.filter (fun J => π.tag J = x) π.boxes
⊢ J ∈ Finset.filter (fun J => x ∈ Box.Icc J) π.boxes
state_after: ι : Type u_1
I J✝ : Box ι
π π₁ π₂ : TaggedPrepartition I
x✝ : ι → ℝ
inst✝ : Fintype ι
h : π.IsHenstock
x : ι → ℝ
J : Box ι
hJ : J ∈ π.boxes ∧ π.tag J = x
⊢ J ∈ π.boxes ∧ x ∈ Box.Icc J

tactic: rcases hJ with ⟨hJ, rfl⟩
state_before: ι : Type u_1
I J✝ : Box ι
π π₁ π₂ : TaggedPrepartition I
x✝ : ι → ℝ
inst✝ : Fintype ι
h : π.IsHenstock
x : ι → ℝ
J : Box ι
hJ : J ∈ π.boxes ∧ π.tag J = x
⊢ J ∈ π.boxes ∧ x ∈ Box.Icc J
state_after: case intro
ι : Type u_1
I J✝ : Box ι
π π₁ π₂ : TaggedPrepartition I
x : ι → ℝ
inst✝ : Fintype ι
h : π.IsHenstock
J : Box ι
hJ : J ∈ π.boxes
⊢ J ∈ π.boxes ∧ π.tag J ∈ Box.Icc J

tactic: exact ⟨hJ, h J hJ⟩
state_before: case intro
ι : Type u_1
I J✝ : Box ι
π π₁ π₂ : TaggedPrepartition I
x : ι → ℝ
inst✝ : Fintype ι
h : π.IsHenstock
J : Box ι
hJ : J ∈ π.boxes
⊢ J ∈ π.boxes ∧ π.tag J ∈ Box.Icc J
state_after: no goals