ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: tendsto_floor_left_pure_ceil_sub_one
File: Mathlib/Topology/Algebra/Order/Floor.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝³ : LinearOrderedRing α
inst✝² : FloorRing α
inst✝¹ : TopologicalSpace α
inst✝ : OrderClosedTopology α
x : α
⊢ ↑(⌈x⌉ - 1) < x
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝³ : LinearOrderedRing α
inst✝² : FloorRing α
inst✝¹ : TopologicalSpace α
inst✝ : OrderClosedTopology α
x : α
⊢ ↑⌈x⌉ < x + 1
tactic: rw [cast_sub, cast_one, sub_lt_iff_lt_add]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝³ : LinearOrderedRing α
inst✝² : FloorRing α
inst✝¹ : TopologicalSpace α
inst✝ : OrderClosedTopology α
x : α
⊢ ↑⌈x⌉ < x + 1
state_after: no goals
tactic: exact ceil_lt_add_one _
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝³ : LinearOrderedRing α
inst✝² : FloorRing α
inst✝¹ : TopologicalSpace α
inst✝ : OrderClosedTopology α
x : α
h₁ : ↑(⌈x⌉ - 1) < x
⊢ x ≤ ↑(⌈x⌉ - 1) + 1
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝³ : LinearOrderedRing α
inst✝² : FloorRing α
inst✝¹ : TopologicalSpace α
inst✝ : OrderClosedTopology α
x : α
h₁ : ↑(⌈x⌉ - 1) < x
⊢ x ≤ ↑⌈x⌉
tactic: rw [cast_sub, cast_one, sub_add_cancel]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝³ : LinearOrderedRing α
inst✝² : FloorRing α
inst✝¹ : TopologicalSpace α
inst✝ : OrderClosedTopology α
x : α
h₁ : ↑(⌈x⌉ - 1) < x
⊢ x ≤ ↑⌈x⌉
state_after: no goals
tactic: exact le_ceil _
Theorem: Real.summable_pow_mul_exp_neg_nat_mul
File: Mathlib/Analysis/SpecialFunctions/Exp.lean

Proof steps:
state_before: α : Type u_1
x y z : ℝ
l : Filter α
k : ℕ
r : ℝ
hr : 0 < r
⊢ Summable fun n => ↑n ^ k * rexp (-r * ↑n)
state_after: α : Type u_1
x y z : ℝ
l : Filter α
k : ℕ
r : ℝ
hr : 0 < r
⊢ Summable fun n => ↑n ^ k * rexp (-r) ^ n
tactic: simp_rw [mul_comm (-r), exp_nat_mul]
state_before: α : Type u_1
x y z : ℝ
l : Filter α
k : ℕ
r : ℝ
hr : 0 < r
⊢ Summable fun n => ↑n ^ k * rexp (-r) ^ n
state_after: case hr
α : Type u_1
x y z : ℝ
l : Filter α
k : ℕ
r : ℝ
hr : 0 < r
⊢ ‖rexp (-r)‖ < 1
tactic: apply summable_pow_mul_geometric_of_norm_lt_one
state_before: case hr
α : Type u_1
x y z : ℝ
l : Filter α
k : ℕ
r : ℝ
hr : 0 < r
⊢ ‖rexp (-r)‖ < 1
state_after: no goals
tactic: rwa [norm_of_nonneg (exp_nonneg _), exp_lt_one_iff, neg_lt_zero]
Theorem: Mathlib.Tactic.Ring.pow_atom
File: Mathlib/Tactic/Ring/Basic.lean

Proof steps:
state_before: u✝ : Lean.Level
arg : Q(Type u✝)
sα✝ : Q(CommSemiring «$arg»)
u : Lean.Level
α : Q(Type u)
sα : Q(CommSemiring «$α»)
R : Type u_1
inst✝ : CommSemiring R
a✝ a' a₁ a₂ a₃ b✝ b' b₁ b₂ b₃ c c₁ c₂ a : R
b : ℕ
⊢ a ^ b = a ^ b * Nat.rawCast 1 + 0
state_after: no goals
tactic: simp
Theorem: Finset.attach_image_val
File: Mathlib/Data/Finset/Image.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝¹ : DecidableEq β
f g : α → β
s✝ : Finset α
t : Finset β
a : α
b c : β
inst✝ : DecidableEq α
s : Finset α
⊢ (image Subtype.val s.attach).val = s.val
state_after: no goals
tactic: rw [image_val, attach_val, Multiset.attach_map_val, dedup_eq_self]
Theorem: Subgroup.center_eq_iInf
File: Mathlib/Algebra/Group/Subgroup/ZPowers.lean

Proof steps:
state_before: G : Type u_1
inst✝² : Group G
A : Type u_2
inst✝¹ : AddGroup A
N : Type u_3
inst✝ : Group N
s : Set G
g : G
S : Set G
hS : closure S = ⊤
⊢ center G = ⨅ g ∈ S, centralizer ↑(zpowers g)
state_after: no goals
tactic: rw [← centralizer_univ, ← coe_top, ← hS, centralizer_closure]
Theorem: regionBetween_subset
File: Mathlib/MeasureTheory/Measure/Lebesgue/Basic.lean

Proof steps:
state_before: α : Type u_1
f g : α → ℝ
s : Set α
⊢ regionBetween f g s ⊆ s ×ˢ univ
state_after: no goals
tactic: simpa only [prod_univ, regionBetween, Set.preimage, setOf_subset_setOf] using fun a => And.left
Theorem: MeasurableSpace.generateFrom_induction
File: Mathlib/MeasureTheory/MeasurableSpace/Defs.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
δ' : Type u_5
ι : Sort u_6
s✝ t u : Set α
p : Set α → Prop
C : Set (Set α)
hC : ∀ t ∈ C, p t
h_empty : p ∅
h_compl : ∀ (t : Set α), p t → p tᶜ
h_Union : ∀ (f : ℕ → Set α), (∀ (n : ℕ), p (f n)) → p (⋃ i, f i)
s : Set α
hs : MeasurableSet s
⊢ p s
state_after: case basic
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
δ' : Type u_5
ι : Sort u_6
s✝ t u : Set α
p : Set α → Prop
C : Set (Set α)
hC : ∀ t ∈ C, p t
h_empty : p ∅
h_compl : ∀ (t : Set α), p t → p tᶜ
h_Union : ∀ (f : ℕ → Set α), (∀ (n : ℕ), p (f n)) → p (⋃ i, f i)
s u✝ : Set α
a✝ : u✝ ∈ C
⊢ p u✝

case empty
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
δ' : Type u_5
ι : Sort u_6
s✝ t u : Set α
p : Set α → Prop
C : Set (Set α)
hC : ∀ t ∈ C, p t
h_empty : p ∅
h_compl : ∀ (t : Set α), p t → p tᶜ
h_Union : ∀ (f : ℕ → Set α), (∀ (n : ℕ), p (f n)) → p (⋃ i, f i)
s : Set α
⊢ p ∅

case compl
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
δ' : Type u_5
ι : Sort u_6
s✝ t u : Set α
p : Set α → Prop
C : Set (Set α)
hC : ∀ t ∈ C, p t
h_empty : p ∅
h_compl : ∀ (t : Set α), p t → p tᶜ
h_Union : ∀ (f : ℕ → Set α), (∀ (n : ℕ), p (f n)) → p (⋃ i, f i)
s t✝ : Set α
a✝ : GenerateMeasurable C t✝
a_ih✝ : p t✝
⊢ p t✝ᶜ

case iUnion
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
δ' : Type u_5
ι : Sort u_6
s✝ t u : Set α
p : Set α → Prop
C : Set (Set α)
hC : ∀ t ∈ C, p t
h_empty : p ∅
h_compl : ∀ (t : Set α), p t → p tᶜ
h_Union : ∀ (f : ℕ → Set α), (∀ (n : ℕ), p (f n)) → p (⋃ i, f i)
s : Set α
f✝ : ℕ → Set α
a✝ : ∀ (n : ℕ), GenerateMeasurable C (f✝ n)
a_ih✝ : ∀ (n : ℕ), p (f✝ n)
⊢ p (⋃ i, f✝ i)
tactic: induction hs
state_before: case basic
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
δ' : Type u_5
ι : Sort u_6
s✝ t u : Set α
p : Set α → Prop
C : Set (Set α)
hC : ∀ t ∈ C, p t
h_empty : p ∅
h_compl : ∀ (t : Set α), p t → p tᶜ
h_Union : ∀ (f : ℕ → Set α), (∀ (n : ℕ), p (f n)) → p (⋃ i, f i)
s u✝ : Set α
a✝ : u✝ ∈ C
⊢ p u✝

case empty
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
δ' : Type u_5
ι : Sort u_6
s✝ t u : Set α
p : Set α → Prop
C : Set (Set α)
hC : ∀ t ∈ C, p t
h_empty : p ∅
h_compl : ∀ (t : Set α), p t → p tᶜ
h_Union : ∀ (f : ℕ → Set α), (∀ (n : ℕ), p (f n)) → p (⋃ i, f i)
s : Set α
⊢ p ∅

case compl
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
δ' : Type u_5
ι : Sort u_6
s✝ t u : Set α
p : Set α → Prop
C : Set (Set α)
hC : ∀ t ∈ C, p t
h_empty : p ∅
h_compl : ∀ (t : Set α), p t → p tᶜ
h_Union : ∀ (f : ℕ → Set α), (∀ (n : ℕ), p (f n)) → p (⋃ i, f i)
s t✝ : Set α
a✝ : GenerateMeasurable C t✝
a_ih✝ : p t✝
⊢ p t✝ᶜ

case iUnion
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
δ' : Type u_5
ι : Sort u_6
s✝ t u : Set α
p : Set α → Prop
C : Set (Set α)
hC : ∀ t ∈ C, p t
h_empty : p ∅
h_compl : ∀ (t : Set α), p t → p tᶜ
h_Union : ∀ (f : ℕ → Set α), (∀ (n : ℕ), p (f n)) → p (⋃ i, f i)
s : Set α
f✝ : ℕ → Set α
a✝ : ∀ (n : ℕ), GenerateMeasurable C (f✝ n)
a_ih✝ : ∀ (n : ℕ), p (f✝ n)
⊢ p (⋃ i, f✝ i)
state_after: no goals
tactic: exacts [hC _ ‹_›, h_empty, h_compl _ ‹_›, h_Union ‹_› ‹_›]
Theorem: Lagrange.interpolate_eq_add_interpolate_erase
File: Mathlib/LinearAlgebra/Lagrange.lean

Proof steps:
state_before: F : Type u_1
inst✝¹ : Field F
ι : Type u_2
inst✝ : DecidableEq ι
s t : Finset ι
i j : ι
v r r' : ι → F
hvs : Set.InjOn v ↑s
hi : i ∈ s
hj : j ∈ s
hij : i ≠ j
⊢ (interpolate s v) r =
    (interpolate (s.erase j) v) r * basisDivisor (v i) (v j) + (interpolate (s.erase i) v) r * basisDivisor (v j) (v i)
state_after: F : Type u_1
inst✝¹ : Field F
ι : Type u_2
inst✝ : DecidableEq ι
s t : Finset ι
i j : ι
v r r' : ι → F
hvs : Set.InjOn v ↑s
hi : i ∈ s
hj : j ∈ s
hij : i ≠ j
⊢ {i, j} ⊆ s
tactic: rw [interpolate_eq_sum_interpolate_insert_sdiff _ hvs ⟨i, mem_insert_self i {j}⟩ _,
    sum_insert (not_mem_singleton.mpr hij), sum_singleton, basis_pair_left hij,
    basis_pair_right hij, sdiff_insert_insert_of_mem_of_not_mem hi (not_mem_singleton.mpr hij),
    sdiff_singleton_eq_erase, pair_comm,
    sdiff_insert_insert_of_mem_of_not_mem hj (not_mem_singleton.mpr hij.symm),
    sdiff_singleton_eq_erase]
state_before: F : Type u_1
inst✝¹ : Field F
ι : Type u_2
inst✝ : DecidableEq ι
s t : Finset ι
i j : ι
v r r' : ι → F
hvs : Set.InjOn v ↑s
hi : i ∈ s
hj : j ∈ s
hij : i ≠ j
⊢ {i, j} ⊆ s
state_after: no goals
tactic: exact insert_subset_iff.mpr ⟨hi, singleton_subset_iff.mpr hj⟩
Theorem: IntermediateField.mem_adjoin_iff
File: Mathlib/FieldTheory/Adjoin.lean

Proof steps:
state_before: F : Type u_1
inst✝² : Field F
E : Type u_2
inst✝¹ : Field E
inst✝ : Algebra F E
S : Set E
x : E
⊢ x ∈ adjoin F S ↔ ∃ r s, x = (MvPolynomial.aeval Subtype.val) r / (MvPolynomial.aeval Subtype.val) s
state_after: F : Type u_1
inst✝² : Field F
E : Type u_2
inst✝¹ : Field E
inst✝ : Algebra F E
S : Set E
x : E
⊢ (∃ a a_1, (MvPolynomial.aeval Subtype.val) a / (MvPolynomial.aeval Subtype.val) a_1 = x) ↔
    ∃ r s, x = (MvPolynomial.aeval Subtype.val) r / (MvPolynomial.aeval Subtype.val) s
tactic: simp only [adjoin, mem_mk, Subring.mem_toSubsemiring, Subfield.mem_toSubring,
    Subfield.mem_closure_iff, ← Algebra.adjoin_eq_ring_closure, Subalgebra.mem_toSubring,
    Algebra.adjoin_eq_range, AlgHom.mem_range, exists_exists_eq_and]
state_before: F : Type u_1
inst✝² : Field F
E : Type u_2
inst✝¹ : Field E
inst✝ : Algebra F E
S : Set E
x : E
⊢ (∃ a a_1, (MvPolynomial.aeval Subtype.val) a / (MvPolynomial.aeval Subtype.val) a_1 = x) ↔
    ∃ r s, x = (MvPolynomial.aeval Subtype.val) r / (MvPolynomial.aeval Subtype.val) s
state_after: no goals
tactic: tauto
Theorem: CategoryTheory.OplaxNatTrans.Modification.whiskerRight_naturality
File: Mathlib/CategoryTheory/Bicategory/NaturalTransformation/Oplax.lean

Proof steps:
state_before: B : Type u₁
inst✝¹ : Bicategory B
C : Type u₂
inst✝ : Bicategory C
F G : OplaxFunctor B C
η θ ι : F ⟶ G
Γ : Modification η θ
a b c : B
a' : C
f : a ⟶ b
g : G.obj b ⟶ a'
⊢ F.map f ◁ Γ.app b ▷ g ≫ (α_ (F.map f) (θ.app b) g).inv ≫ θ.naturality f ▷ g =
    (α_ (F.map f) (η.app b) g).inv ≫ η.naturality f ▷ g ≫ Γ.app a ▷ G.map f ▷ g
state_after: no goals
tactic: simp_rw [associator_inv_naturality_middle_assoc, ← comp_whiskerRight, naturality]
Theorem: inner_neg_right
File: Mathlib/Analysis/InnerProductSpace/Basic.lean

Proof steps:
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁴ : _root_.RCLike 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : NormedAddCommGroup F
inst✝ : InnerProductSpace ℝ F
x y : E
⊢ ⟪x, -y⟫_𝕜 = -⟪x, y⟫_𝕜
state_after: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁴ : _root_.RCLike 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : NormedAddCommGroup F
inst✝ : InnerProductSpace ℝ F
x y : E
⊢ (starRingEnd 𝕜) (-⟪y, x⟫_𝕜) = -⟪x, y⟫_𝕜
tactic: rw [← inner_conj_symm, inner_neg_left]
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁴ : _root_.RCLike 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : NormedAddCommGroup F
inst✝ : InnerProductSpace ℝ F
x y : E
⊢ (starRingEnd 𝕜) (-⟪y, x⟫_𝕜) = -⟪x, y⟫_𝕜
state_after: no goals
tactic: simp only [RingHom.map_neg, inner_conj_symm]
Theorem: nsmul_two_semiclosed
File: Mathlib/Algebra/Order/Group/Lattice.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝⁴ : Lattice α
inst✝³ : Group α
inst✝² : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
inst✝¹ inst✝ : CovariantClass α α (swap fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
a : α
ha : 1 ≤ a ^ 2
⊢ 1 ≤ a
state_after: α : Type u_1
β : Type u_2
inst✝⁴ : Lattice α
inst✝³ : Group α
inst✝² : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
inst✝¹ inst✝ : CovariantClass α α (swap fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
a : α
ha : 1 ≤ a ^ 2
⊢ (a ⊓ 1) * (a ⊓ 1) = a ⊓ 1
tactic: suffices this : (a ⊓ 1) * (a ⊓ 1) = a ⊓ 1 by
    rwa [← inf_eq_right, ← mul_right_eq_self]
state_before: α : Type u_1
β : Type u_2
inst✝⁴ : Lattice α
inst✝³ : Group α
inst✝² : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
inst✝¹ inst✝ : CovariantClass α α (swap fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
a : α
ha : 1 ≤ a ^ 2
⊢ (a ⊓ 1) * (a ⊓ 1) = a ⊓ 1
state_after: no goals
tactic: rw [mul_inf, inf_mul, ← pow_two, mul_one, one_mul, inf_assoc, inf_left_idem, inf_comm,
    inf_assoc, inf_of_le_left ha]
Theorem: CliffordAlgebra.even.lift.aux_ι
File: Mathlib/LinearAlgebra/CliffordAlgebra/Even.lean

Proof steps:
state_before: R : Type uR
M : Type uM
inst✝⁶ : CommRing R
inst✝⁵ : AddCommGroup M
inst✝⁴ : Module R M
Q : QuadraticForm R M
A : Type uA
B : Type uB
inst✝³ : Ring A
inst✝² : Ring B
inst✝¹ : Algebra R A
inst✝ : Algebra R B
f : EvenHom Q A
m₁ m₂ : M
⊢ (((foldr Q (CliffordAlgebra.even.lift.fFold f) ⋯)
          (((foldr Q (CliffordAlgebra.even.lift.fFold f) ⋯) (1, 0)) ((CliffordAlgebra.ι Q) m₂)))
        ((CliffordAlgebra.ι Q) m₁)).1 =
    (f.bilin m₁) m₂
state_after: R : Type uR
M : Type uM
inst✝⁶ : CommRing R
inst✝⁵ : AddCommGroup M
inst✝⁴ : Module R M
Q : QuadraticForm R M
A : Type uA
B : Type uB
inst✝³ : Ring A
inst✝² : Ring B
inst✝¹ : Algebra R A
inst✝ : Algebra R B
f : EvenHom Q A
m₁ m₂ : M
⊢ (((CliffordAlgebra.even.lift.fFold f) m₁) (((CliffordAlgebra.even.lift.fFold f) m₂) (1, 0))).1 = (f.bilin m₁) m₂
tactic: rw [foldr_ι, foldr_ι]
state_before: R : Type uR
M : Type uM
inst✝⁶ : CommRing R
inst✝⁵ : AddCommGroup M
inst✝⁴ : Module R M
Q : QuadraticForm R M
A : Type uA
B : Type uB
inst✝³ : Ring A
inst✝² : Ring B
inst✝¹ : Algebra R A
inst✝ : Algebra R B
f : EvenHom Q A
m₁ m₂ : M
⊢ (((CliffordAlgebra.even.lift.fFold f) m₁) (((CliffordAlgebra.even.lift.fFold f) m₂) (1, 0))).1 = (f.bilin m₁) m₂
state_after: no goals
tactic: exact mul_one _
Theorem: Finset.prod_Ico_reflect
File: Mathlib/Algebra/BigOperators/Intervals.lean

Proof steps:
state_before: α : Type u_1
M : Type u_2
inst✝ : CommMonoid M
s₂ s₁ s : Finset α
a : α
g f✝ : α → M
f : ℕ → M
k m n : ℕ
h : m ≤ n + 1
⊢ ∏ j ∈ Ico k m, f (n - j) = ∏ j ∈ Ico (n + 1 - m) (n + 1 - k), f j
state_after: α : Type u_1
M : Type u_2
inst✝ : CommMonoid M
s₂ s₁ s : Finset α
a : α
g f✝ : α → M
f : ℕ → M
k m n : ℕ
h : m ≤ n + 1
this : ∀ i < m, i ≤ n
⊢ ∏ j ∈ Ico k m, f (n - j) = ∏ j ∈ Ico (n + 1 - m) (n + 1 - k), f j
tactic: have : ∀ i < m, i ≤ n := by
    intro i hi
    exact (add_le_add_iff_right 1).1 (le_trans (Nat.lt_iff_add_one_le.1 hi) h)
state_before: α : Type u_1
M : Type u_2
inst✝ : CommMonoid M
s₂ s₁ s : Finset α
a : α
g f✝ : α → M
f : ℕ → M
k m n : ℕ
h : m ≤ n + 1
this : ∀ i < m, i ≤ n
⊢ ∏ j ∈ Ico k m, f (n - j) = ∏ j ∈ Ico (n + 1 - m) (n + 1 - k), f j
state_after: case inl
α : Type u_1
M : Type u_2
inst✝ : CommMonoid M
s₂ s₁ s : Finset α
a : α
g f✝ : α → M
f : ℕ → M
k m n : ℕ
h : m ≤ n + 1
this : ∀ i < m, i ≤ n
hkm : k < m
⊢ ∏ j ∈ Ico k m, f (n - j) = ∏ j ∈ Ico (n + 1 - m) (n + 1 - k), f j

case inr
α : Type u_1
M : Type u_2
inst✝ : CommMonoid M
s₂ s₁ s : Finset α
a : α
g f✝ : α → M
f : ℕ → M
k m n : ℕ
h : m ≤ n + 1
this : ∀ i < m, i ≤ n
hkm : m ≤ k
⊢ ∏ j ∈ Ico k m, f (n - j) = ∏ j ∈ Ico (n + 1 - m) (n + 1 - k), f j
tactic: cases' lt_or_le k m with hkm hkm
Theorem: AddSemiconjBy.function_semiconj_add_right_swap
File: Mathlib/Algebra/GroupPower/IterateHom.lean

Proof steps:
state_before: M : Type u_1
N : Type u_2
G : Type u_3
H : Type u_4
inst✝ : Semigroup G
a b c : G
h : SemiconjBy a b c
j : G
⊢ (fun x => x * a) ((fun x => x * c) j) = (fun x => x * b) ((fun x => x * a) j)
state_after: no goals
tactic: simp_rw [mul_assoc, ← h.eq]
Theorem: Rat.mkRat_one
File: Mathlib/Data/Rat/Defs.lean

Proof steps:
state_before: q a b c : ℚ
n : ℤ
⊢ mkRat n 1 = ↑n
state_after: no goals
tactic: simp [mkRat_eq_divInt]
Theorem: Valuation.Integers.dvd_of_le
File: Mathlib/RingTheory/Valuation/Integers.lean

Proof steps:
state_before: F : Type u
Γ₀ : Type v
inst✝³ : Field F
inst✝² : LinearOrderedCommGroupWithZero Γ₀
v : Valuation F Γ₀
O : Type w
inst✝¹ : CommRing O
inst✝ : Algebra O F
hv : v.Integers O
x y : O
h : v ((algebraMap O F) x) ≤ v ((algebraMap O F) y)
hy : (algebraMap O F) y ≠ 0
⊢ v (((algebraMap O F) y)⁻¹ * (algebraMap O F) x) ≤ 1
state_after: F : Type u
Γ₀ : Type v
inst✝³ : Field F
inst✝² : LinearOrderedCommGroupWithZero Γ₀
v : Valuation F Γ₀
O : Type w
inst✝¹ : CommRing O
inst✝ : Algebra O F
hv : v.Integers O
x y : O
h : v ((algebraMap O F) x) ≤ v ((algebraMap O F) y)
hy : (algebraMap O F) y ≠ 0
⊢ v ((algebraMap O F) y)⁻¹ * v ((algebraMap O F) x) ≤ v ((algebraMap O F) y)⁻¹ * v ((algebraMap O F) y)
tactic: rw [← v.map_one, ← inv_mul_cancel hy, v.map_mul, v.map_mul]
state_before: F : Type u
Γ₀ : Type v
inst✝³ : Field F
inst✝² : LinearOrderedCommGroupWithZero Γ₀
v : Valuation F Γ₀
O : Type w
inst✝¹ : CommRing O
inst✝ : Algebra O F
hv : v.Integers O
x y : O
h : v ((algebraMap O F) x) ≤ v ((algebraMap O F) y)
hy : (algebraMap O F) y ≠ 0
⊢ v ((algebraMap O F) y)⁻¹ * v ((algebraMap O F) x) ≤ v ((algebraMap O F) y)⁻¹ * v ((algebraMap O F) y)
state_after: no goals
tactic: exact mul_le_mul_left' h _
Theorem: Finsupp.sumFinsuppEquivProdFinsupp_symm_apply
File: Mathlib/Data/Finsupp/Basic.lean

Proof steps:
state_before: α✝ : Type u_1
β✝ : Type u_2
γ✝ : Type u_3
ι : Type u_4
M : Type u_5
M' : Type u_6
N : Type u_7
P : Type u_8
G : Type u_9
H : Type u_10
R : Type u_11
S : Type u_12
α : Type u_13
β : Type u_14
γ : Type u_15
inst✝ : Zero γ
f : α ⊕ β →₀ γ
⊢ (fun fg => fg.1.sumElim fg.2) ((fun f => (comapDomain Sum.inl f ⋯, comapDomain Sum.inr f ⋯)) f) = f
state_after: case h
α✝ : Type u_1
β✝ : Type u_2
γ✝ : Type u_3
ι : Type u_4
M : Type u_5
M' : Type u_6
N : Type u_7
P : Type u_8
G : Type u_9
H : Type u_10
R : Type u_11
S : Type u_12
α : Type u_13
β : Type u_14
γ : Type u_15
inst✝ : Zero γ
f : α ⊕ β →₀ γ
ab : α ⊕ β
⊢ ((fun fg => fg.1.sumElim fg.2) ((fun f => (comapDomain Sum.inl f ⋯, comapDomain Sum.inr f ⋯)) f)) ab = f ab
tactic: ext ab
state_before: case h
α✝ : Type u_1
β✝ : Type u_2
γ✝ : Type u_3
ι : Type u_4
M : Type u_5
M' : Type u_6
N : Type u_7
P : Type u_8
G : Type u_9
H : Type u_10
R : Type u_11
S : Type u_12
α : Type u_13
β : Type u_14
γ : Type u_15
inst✝ : Zero γ
f : α ⊕ β →₀ γ
ab : α ⊕ β
⊢ ((fun fg => fg.1.sumElim fg.2) ((fun f => (comapDomain Sum.inl f ⋯, comapDomain Sum.inr f ⋯)) f)) ab = f ab
state_after: no goals
tactic: cases' ab with a b <;> simp
state_before: α✝ : Type u_1
β✝ : Type u_2
γ✝ : Type u_3
ι : Type u_4
M : Type u_5
M' : Type u_6
N : Type u_7
P : Type u_8
G : Type u_9
H : Type u_10
R : Type u_11
S : Type u_12
α : Type u_13
β : Type u_14
γ : Type u_15
inst✝ : Zero γ
fg : (α →₀ γ) × (β →₀ γ)
⊢ (fun f => (comapDomain Sum.inl f ⋯, comapDomain Sum.inr f ⋯)) ((fun fg => fg.1.sumElim fg.2) fg) = fg
state_after: no goals
tactic: ext <;> simp
Theorem: Monoid.isTorsionFree_iff_torsion_eq_bot
File: Mathlib/GroupTheory/Torsion.lean

Proof steps:
state_before: G✝ : Type u_1
H : Type u_2
inst✝¹ : Monoid G✝
G : Type u_3
inst✝ : CommGroup G
⊢ IsTorsionFree G ↔ CommGroup.torsion G = ⊥
state_after: G✝ : Type u_1
H : Type u_2
inst✝¹ : Monoid G✝
G : Type u_3
inst✝ : CommGroup G
⊢ (∀ (g : G), g ≠ 1 → ¬IsOfFinOrder g) ↔ ∀ ⦃x : G⦄, x ∈ CommGroup.torsion G → x ∈ ⊥
tactic: rw [IsTorsionFree, eq_bot_iff, SetLike.le_def]
state_before: G✝ : Type u_1
H : Type u_2
inst✝¹ : Monoid G✝
G : Type u_3
inst✝ : CommGroup G
⊢ (∀ (g : G), g ≠ 1 → ¬IsOfFinOrder g) ↔ ∀ ⦃x : G⦄, x ∈ CommGroup.torsion G → x ∈ ⊥
state_after: no goals
tactic: simp [not_imp_not, CommGroup.mem_torsion]
Theorem: ProbabilityTheory.Kernel.snd_prod
File: Mathlib/Probability/Kernel/Composition.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
κ : Kernel α β
inst✝¹ : IsMarkovKernel κ
η : Kernel α γ
inst✝ : IsSFiniteKernel η
⊢ (κ ×ₖ η).snd = η
state_after: case h.h
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
κ : Kernel α β
inst✝¹ : IsMarkovKernel κ
η : Kernel α γ
inst✝ : IsSFiniteKernel η
x : α
s✝ : Set γ
a✝ : MeasurableSet s✝
⊢ ((κ ×ₖ η).snd x) s✝ = (η x) s✝
tactic: ext x
state_before: case h.h
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
κ : Kernel α β
inst✝¹ : IsMarkovKernel κ
η : Kernel α γ
inst✝ : IsSFiniteKernel η
x : α
s✝ : Set γ
a✝ : MeasurableSet s✝
⊢ ((κ ×ₖ η).snd x) s✝ = (η x) s✝
state_after: no goals
tactic: simp [snd_apply, prod_apply]
Theorem: Sym2.IsDiag.mem_range_diag
File: Mathlib/Data/Sym/Sym2.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
e : Sym2 α
f : α → β
z : Sym2 α
⊢ z.IsDiag → z ∈ Set.range diag
state_after: case h
α : Type u_1
β : Type u_2
γ : Type u_3
e : Sym2 α
f : α → β
x y : α
⊢ s(x, y).IsDiag → s(x, y) ∈ Set.range diag
tactic: induction' z with x y
state_before: case h
α : Type u_1
β : Type u_2
γ : Type u_3
e : Sym2 α
f : α → β
x y : α
⊢ s(x, y).IsDiag → s(x, y) ∈ Set.range diag
state_after: case h
α : Type u_1
β : Type u_2
γ : Type u_3
e : Sym2 α
f : α → β
x : α
⊢ s(x, x) ∈ Set.range diag
tactic: rintro (rfl : x = y)
state_before: case h
α : Type u_1
β : Type u_2
γ : Type u_3
e : Sym2 α
f : α → β
x : α
⊢ s(x, x) ∈ Set.range diag
state_after: no goals
tactic: exact ⟨_, rfl⟩
Theorem: Real.arccos_neg_one
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Inverse.lean

Proof steps:
state_before: x y : ℝ
⊢ arccos (-1) = π
state_after: no goals
tactic: simp [arccos, add_halves]
Theorem: CategoryTheory.Limits.Types.FilteredColimit.isColimit_eq_iff
File: Mathlib/CategoryTheory/Limits/TypesFiltered.lean

Proof steps:
state_before: J : Type v
inst✝² : Category.{w, v} J
F : J ⥤ Type u
inst✝¹ : IsFilteredOrEmpty J
inst✝ : HasColimit F
t : Cocone F
ht : IsColimit t
i j : J
xi : F.obj i
xj : F.obj j
⊢ t.ι.app i xi = t.ι.app j xj ↔ ∃ k f g, F.map f xi = F.map g xj
state_after: J : Type v
inst✝² : Category.{w, v} J
F : J ⥤ Type u
inst✝¹ : IsFilteredOrEmpty J
inst✝ : HasColimit F
t : Cocone F
ht : IsColimit t
i j : J
xi : F.obj i
xj : F.obj j
⊢ t.ι.app i xi = t.ι.app j xj ↔ (colimitCocone F).ι.app i xi = (colimitCocone F).ι.app j xj
tactic: refine Iff.trans ?_ (colimit_eq_iff_aux F)
state_before: J : Type v
inst✝² : Category.{w, v} J
F : J ⥤ Type u
inst✝¹ : IsFilteredOrEmpty J
inst✝ : HasColimit F
t : Cocone F
ht : IsColimit t
i j : J
xi : F.obj i
xj : F.obj j
⊢ t.ι.app i xi = t.ι.app j xj ↔ (colimitCocone F).ι.app i xi = (colimitCocone F).ι.app j xj
state_after: J : Type v
inst✝² : Category.{w, v} J
F : J ⥤ Type u
inst✝¹ : IsFilteredOrEmpty J
inst✝ : HasColimit F
t : Cocone F
ht : IsColimit t
i j : J
xi : F.obj i
xj : F.obj j
⊢ (ht.coconePointUniqueUpToIso (colimitCoconeIsColimit F)).toEquiv (t.ι.app i xi) =
      (ht.coconePointUniqueUpToIso (colimitCoconeIsColimit F)).toEquiv (t.ι.app j xj) ↔
    (colimitCocone F).ι.app i xi = (colimitCocone F).ι.app j xj
tactic: rw [← (IsColimit.coconePointUniqueUpToIso ht (colimitCoconeIsColimit F)).toEquiv.injective.eq_iff]
state_before: J : Type v
inst✝² : Category.{w, v} J
F : J ⥤ Type u
inst✝¹ : IsFilteredOrEmpty J
inst✝ : HasColimit F
t : Cocone F
ht : IsColimit t
i j : J
xi : F.obj i
xj : F.obj j
⊢ (ht.coconePointUniqueUpToIso (colimitCoconeIsColimit F)).toEquiv (t.ι.app i xi) =
      (ht.coconePointUniqueUpToIso (colimitCoconeIsColimit F)).toEquiv (t.ι.app j xj) ↔
    (colimitCocone F).ι.app i xi = (colimitCocone F).ι.app j xj
state_after: case h.e'_2.h.e'_2.h
J : Type v
inst✝² : Category.{w, v} J
F : J ⥤ Type u
inst✝¹ : IsFilteredOrEmpty J
inst✝ : HasColimit F
t : Cocone F
ht : IsColimit t
i j : J
xi : F.obj i
xj : F.obj j
e_1✝ : ((Functor.const J).obj (colimitCocone F).pt).obj i = (colimitCocone F).pt
⊢ (colimitCocone F).ι.app i xi = (ht.coconePointUniqueUpToIso (colimitCoconeIsColimit F)).toEquiv (t.ι.app i xi)

case h.e'_2.h.e'_3.h
J : Type v
inst✝² : Category.{w, v} J
F : J ⥤ Type u
inst✝¹ : IsFilteredOrEmpty J
inst✝ : HasColimit F
t : Cocone F
ht : IsColimit t
i j : J
xi : F.obj i
xj : F.obj j
e_1✝ : ((Functor.const J).obj (colimitCocone F).pt).obj i = (colimitCocone F).pt
⊢ (colimitCocone F).ι.app j xj = (ht.coconePointUniqueUpToIso (colimitCoconeIsColimit F)).toEquiv (t.ι.app j xj)
tactic: convert Iff.rfl
Theorem: AddEquiv.ofLeftInverse'_symm_apply
File: Mathlib/Algebra/Group/Submonoid/Operations.lean

Proof steps:
state_before: M : Type u_1
N : Type u_2
P : Type u_3
inst✝³ : MulOneClass M
inst✝² : MulOneClass N
inst✝¹ : MulOneClass P
S : Submonoid M
A : Type u_4
inst✝ : SetLike A M
hA : SubmonoidClass A M
S' : A
T : Submonoid M
f : M →* N
g : N → M
h : Function.LeftInverse g ⇑f
x : ↥(MonoidHom.mrange f)
x' : M
hx' : f x' = ↑x
⊢ f (g ↑x) = ↑x
state_after: no goals
tactic: rw [← hx', h x']