ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: MeasurableEmbedding.integrableAtFilter_iff_comap
File: Mathlib/MeasureTheory/Integral/IntegrableOn.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
E : Type u_3
F : Type u_4
inst✝² : MeasurableSpace α
inst✝¹ : NormedAddCommGroup E
f✝ g : α → E
s t : Set α
μ✝ ν : Measure α
l l' : Filter α
inst✝ : MeasurableSpace β
e : α → β
he : MeasurableEmbedding e
f : β → E
μ : Measure β
⊢ IntegrableAtFilter f (map e l) μ ↔ IntegrableAtFilter (f ∘ e) l (Measure.comap e μ)
state_after: α : Type u_1
β : Type u_2
E : Type u_3
F : Type u_4
inst✝² : MeasurableSpace α
inst✝¹ : NormedAddCommGroup E
f✝ g : α → E
s t : Set α
μ✝ ν : Measure α
l l' : Filter α
inst✝ : MeasurableSpace β
e : α → β
he : MeasurableEmbedding e
f : β → E
μ : Measure β
⊢ (∃ s ∈ map e l, IntegrableOn f s μ) ↔ ∃ s ∈ map e l, IntegrableOn f s (μ.restrict (range e))
tactic: simp_rw [← he.integrableAtFilter_map_iff, IntegrableAtFilter, he.map_comap]
state_before: α : Type u_1
β : Type u_2
E : Type u_3
F : Type u_4
inst✝² : MeasurableSpace α
inst✝¹ : NormedAddCommGroup E
f✝ g : α → E
s t : Set α
μ✝ ν : Measure α
l l' : Filter α
inst✝ : MeasurableSpace β
e : α → β
he : MeasurableEmbedding e
f : β → E
μ : Measure β
⊢ (∃ s ∈ map e l, IntegrableOn f s μ) ↔ ∃ s ∈ map e l, IntegrableOn f s (μ.restrict (range e))
state_after: case mp.intro.intro
α : Type u_1
β : Type u_2
E : Type u_3
F : Type u_4
inst✝² : MeasurableSpace α
inst✝¹ : NormedAddCommGroup E
f✝ g : α → E
s✝ t : Set α
μ✝ ν : Measure α
l l' : Filter α
inst✝ : MeasurableSpace β
e : α → β
he : MeasurableEmbedding e
f : β → E
μ : Measure β
s : Set β
hs : s ∈ map e l
int : IntegrableOn f s μ
⊢ ∃ s ∈ map e l, IntegrableOn f s (μ.restrict (range e))

case mpr.intro.intro
α : Type u_1
β : Type u_2
E : Type u_3
F : Type u_4
inst✝² : MeasurableSpace α
inst✝¹ : NormedAddCommGroup E
f✝ g : α → E
s✝ t : Set α
μ✝ ν : Measure α
l l' : Filter α
inst✝ : MeasurableSpace β
e : α → β
he : MeasurableEmbedding e
f : β → E
μ : Measure β
s : Set β
hs : s ∈ map e l
int : IntegrableOn f s (μ.restrict (range e))
⊢ ∃ s ∈ map e l, IntegrableOn f s μ
tactic: constructor <;> rintro ⟨s, hs, int⟩
Theorem: Complex.ofReal_cot_ofReal_re
File: Mathlib/Data/Complex/Exponential.lean

Proof steps:
state_before: x✝ y : ℂ
x : ℝ
⊢ (starRingEnd ℂ) (↑x).cot = (↑x).cot
state_after: no goals
tactic: rw [← cot_conj, conj_ofReal]
Theorem: EReal.eq_top_iff_forall_lt
File: Mathlib/Data/Real/EReal.lean

Proof steps:
state_before: x : EReal
⊢ x = ⊤ ↔ ∀ (y : ℝ), ↑y < x
state_after: case mp
x : EReal
⊢ x = ⊤ → ∀ (y : ℝ), ↑y < x

case mpr
x : EReal
⊢ (∀ (y : ℝ), ↑y < x) → x = ⊤
tactic: constructor
Theorem: PrimeMultiset.coe_prod
File: Mathlib/Data/PNat/Factors.lean

Proof steps:
state_before: v : PrimeMultiset
⊢ ↑v.prod = v.toNatMultiset.prod
state_after: v : PrimeMultiset
h : ↑v.prod = (Multiset.map Coe.coe (Multiset.map Coe.coe v)).prod :=
  MonoidHom.map_multiset_prod PNat.coeMonoidHom v.toPNatMultiset
⊢ ↑v.prod = v.toNatMultiset.prod
tactic: let h : (v.prod : ℕ) = ((v.map Coe.coe).map Coe.coe).prod :=
    PNat.coeMonoidHom.map_multiset_prod v.toPNatMultiset
state_before: v : PrimeMultiset
h : ↑v.prod = (Multiset.map Coe.coe (Multiset.map Coe.coe v)).prod :=
  MonoidHom.map_multiset_prod PNat.coeMonoidHom v.toPNatMultiset
⊢ ↑v.prod = v.toNatMultiset.prod
state_after: v : PrimeMultiset
h : ↑v.prod = (Multiset.map (Coe.coe ∘ Coe.coe) v).prod
⊢ ↑v.prod = v.toNatMultiset.prod
tactic: rw [Multiset.map_map] at h
state_before: v : PrimeMultiset
h : ↑v.prod = (Multiset.map (Coe.coe ∘ Coe.coe) v).prod
⊢ ↑v.prod = v.toNatMultiset.prod
state_after: v : PrimeMultiset
h : ↑v.prod = (Multiset.map (Coe.coe ∘ Coe.coe) v).prod
this : Coe.coe ∘ Coe.coe = Coe.coe
⊢ ↑v.prod = v.toNatMultiset.prod
tactic: have : (Coe.coe : ℕ+ → ℕ) ∘ (Coe.coe : Nat.Primes → ℕ+) = Coe.coe := funext fun p => rfl
state_before: v : PrimeMultiset
h : ↑v.prod = (Multiset.map (Coe.coe ∘ Coe.coe) v).prod
this : Coe.coe ∘ Coe.coe = Coe.coe
⊢ ↑v.prod = v.toNatMultiset.prod
state_after: v : PrimeMultiset
h : ↑v.prod = (Multiset.map Coe.coe v).prod
this : Coe.coe ∘ Coe.coe = Coe.coe
⊢ ↑v.prod = v.toNatMultiset.prod
tactic: rw [this] at h
state_before: v : PrimeMultiset
h : ↑v.prod = (Multiset.map Coe.coe v).prod
this : Coe.coe ∘ Coe.coe = Coe.coe
⊢ ↑v.prod = v.toNatMultiset.prod
state_after: no goals
tactic: exact h
Theorem: HahnSeries.leadingCoeff_of_single
File: Mathlib/RingTheory/HahnSeries/Basic.lean

Proof steps:
state_before: Γ : Type u_1
R : Type u_2
inst✝¹ : PartialOrder Γ
inst✝ : Zero R
a✝ b : Γ
r✝ : R
a : Γ
r : R
⊢ ((single a) r).leadingCoeff = r
state_after: Γ : Type u_1
R : Type u_2
inst✝¹ : PartialOrder Γ
inst✝ : Zero R
a✝ b : Γ
r✝ : R
a : Γ
r : R
⊢ (if h : r = 0 then 0 else ((single a) r).coeff (⋯.min ⋯)) = r
tactic: simp only [leadingCoeff, single_eq_zero_iff]
state_before: Γ : Type u_1
R : Type u_2
inst✝¹ : PartialOrder Γ
inst✝ : Zero R
a✝ b : Γ
r✝ : R
a : Γ
r : R
⊢ (if h : r = 0 then 0 else ((single a) r).coeff (⋯.min ⋯)) = r
state_after: no goals
tactic: by_cases h : r = 0 <;> simp [h]
Theorem: commutative_ring_iff_abelian_lie_ring
File: Mathlib/Algebra/Lie/Abelian.lean

Proof steps:
state_before: A : Type v
inst✝ : Ring A
h₁ : (Std.Commutative fun x x_1 => x * x_1) ↔ ∀ (a b : A), a * b = b * a
⊢ (Std.Commutative fun x x_1 => x * x_1) ↔ IsLieAbelian A
state_after: A : Type v
inst✝ : Ring A
h₁ : (Std.Commutative fun x x_1 => x * x_1) ↔ ∀ (a b : A), a * b = b * a
h₂ : IsLieAbelian A ↔ ∀ (a b : A), ⁅a, b⁆ = 0
⊢ (Std.Commutative fun x x_1 => x * x_1) ↔ IsLieAbelian A
tactic: have h₂ : IsLieAbelian A ↔ ∀ a b : A, ⁅a, b⁆ = 0 := ⟨fun h => h.1, fun h => ⟨h⟩⟩
state_before: A : Type v
inst✝ : Ring A
h₁ : (Std.Commutative fun x x_1 => x * x_1) ↔ ∀ (a b : A), a * b = b * a
h₂ : IsLieAbelian A ↔ ∀ (a b : A), ⁅a, b⁆ = 0
⊢ (Std.Commutative fun x x_1 => x * x_1) ↔ IsLieAbelian A
state_after: no goals
tactic: simp only [h₁, h₂, LieRing.of_associative_ring_bracket, sub_eq_zero]
Theorem: AddAction.mem_addSubgroup_orbit_iff
File: Mathlib/GroupTheory/GroupAction/Basic.lean

Proof steps:
state_before: G : Type u_1
α : Type u_2
β : Type u_3
inst✝² : Group G
inst✝¹ : MulAction G α
inst✝ : MulAction G β
H : Subgroup G
x : α
a b : ↑(orbit G x)
⊢ a ∈ orbit (↥H) b ↔ ↑a ∈ orbit ↥H ↑b
state_after: case refine_1
G : Type u_1
α : Type u_2
β : Type u_3
inst✝² : Group G
inst✝¹ : MulAction G α
inst✝ : MulAction G β
H : Subgroup G
x : α
a b : ↑(orbit G x)
h : a ∈ orbit (↥H) b
⊢ ↑a ∈ orbit ↥H ↑b

case refine_2
G : Type u_1
α : Type u_2
β : Type u_3
inst✝² : Group G
inst✝¹ : MulAction G α
inst✝ : MulAction G β
H : Subgroup G
x : α
a b : ↑(orbit G x)
h : ↑a ∈ orbit ↥H ↑b
⊢ a ∈ orbit (↥H) b
tactic: refine ⟨fun h ↦ ?_, fun h ↦ ?_⟩
Theorem: Finset.addEnergy_comm
File: Mathlib/Combinatorics/Additive/Energy.lean

Proof steps:
state_before: α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : CommMonoid α
s t : Finset α
⊢ Eₘ[s, t] = Eₘ[t, s]
state_after: α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : CommMonoid α
s t : Finset α
⊢ (filter ((fun x => x.1.1 * x.2.1 = x.1.2 * x.2.2) ∘ ⇑(Equiv.prodComm (α × α) (α × α)).symm)
        (map (Equiv.prodComm (α × α) (α × α)).toEmbedding ((s ×ˢ s) ×ˢ t ×ˢ t))).card =
    Eₘ[t, s]
tactic: rw [mulEnergy, ← Finset.card_map (Equiv.prodComm _ _).toEmbedding, map_filter]
state_before: α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : CommMonoid α
s t : Finset α
⊢ (filter ((fun x => x.1.1 * x.2.1 = x.1.2 * x.2.2) ∘ ⇑(Equiv.prodComm (α × α) (α × α)).symm)
        (map (Equiv.prodComm (α × α) (α × α)).toEmbedding ((s ×ˢ s) ×ˢ t ×ˢ t))).card =
    Eₘ[t, s]
state_after: no goals
tactic: simp [-Finset.card_map, eq_comm, mulEnergy, mul_comm, map_eq_image, Function.comp]
Theorem: CategoryTheory.Limits.kernel.mapIso_hom
File: Mathlib/CategoryTheory/Limits/Shapes/Kernels.lean

Proof steps:
state_before: C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasZeroMorphisms C
X Y : C
f : X ⟶ Y
inst✝¹ : HasKernel f
X' Y' : C
f' : X' ⟶ Y'
inst✝ : HasKernel f'
p : X ≅ X'
q : Y ≅ Y'
w : f ≫ q.hom = p.hom ≫ f'
⊢ f' ≫ q.inv = p.inv ≫ f
state_after: C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasZeroMorphisms C
X Y : C
f : X ⟶ Y
inst✝¹ : HasKernel f
X' Y' : C
f' : X' ⟶ Y'
inst✝ : HasKernel f'
p : X ≅ X'
q : Y ≅ Y'
w : f ≫ q.hom = p.hom ≫ f'
⊢ (f' ≫ q.inv) ≫ q.hom = (p.inv ≫ f) ≫ q.hom
tactic: refine (cancel_mono q.hom).1 ?_
state_before: C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasZeroMorphisms C
X Y : C
f : X ⟶ Y
inst✝¹ : HasKernel f
X' Y' : C
f' : X' ⟶ Y'
inst✝ : HasKernel f'
p : X ≅ X'
q : Y ≅ Y'
w : f ≫ q.hom = p.hom ≫ f'
⊢ (f' ≫ q.inv) ≫ q.hom = (p.inv ≫ f) ≫ q.hom
state_after: no goals
tactic: simp [w]
Theorem: FixedPoints.minpoly.eval₂
File: Mathlib/FieldTheory/Fixed.lean

Proof steps:
state_before: M : Type u
inst✝⁵ : Monoid M
G : Type u
inst✝⁴ : Group G
F : Type v
inst✝³ : Field F
inst✝² : MulSemiringAction M F
inst✝¹ : MulSemiringAction G F
m : M
inst✝ : Fintype G
x : F
⊢ Polynomial.eval₂ (subfield G F).subtype x (minpoly G F x) = 0
state_after: M : Type u
inst✝⁵ : Monoid M
G : Type u
inst✝⁴ : Group G
F : Type v
inst✝³ : Field F
inst✝² : MulSemiringAction M F
inst✝¹ : MulSemiringAction G F
m : M
inst✝ : Fintype G
x : F
⊢ Polynomial.eval x (Polynomial.map (subfield G F).subtype (minpoly G F x)) = Polynomial.eval x (prodXSubSMul G F x)
tactic: rw [← prodXSubSMul.eval G F x, Polynomial.eval₂_eq_eval_map]
state_before: M : Type u
inst✝⁵ : Monoid M
G : Type u
inst✝⁴ : Group G
F : Type v
inst✝³ : Field F
inst✝² : MulSemiringAction M F
inst✝¹ : MulSemiringAction G F
m : M
inst✝ : Fintype G
x : F
⊢ Polynomial.eval x (Polynomial.map (subfield G F).subtype (minpoly G F x)) = Polynomial.eval x (prodXSubSMul G F x)
state_after: no goals
tactic: simp only [minpoly, Polynomial.map_toSubring]
Theorem: Computation.think_bind
File: Mathlib/Data/Seq/Computation.lean

Proof steps:
state_before: α : Type u
β : Type v
γ : Type w
c : Computation α
f : α → Computation β
⊢ (c.think.bind f).destruct = Sum.inr (c.bind f)
state_after: no goals
tactic: simp [bind, Bind.f]
Theorem: Algebra.norm_norm
File: Mathlib/RingTheory/Norm/Basic.lean

Proof steps:
state_before: R : Type u_1
S : Type u_2
T : Type u_3
inst✝¹² : CommRing R
inst✝¹¹ : Ring S
inst✝¹⁰ : Algebra R S
K : Type u_4
L : Type u_5
F : Type u_6
inst✝⁹ : Field K
inst✝⁸ : Field L
inst✝⁷ : Field F
inst✝⁶ : Algebra K L
inst✝⁵ : Algebra K F
ι : Type w
E : Type u_7
inst✝⁴ : Field E
inst✝³ : Algebra K E
inst✝² : Algebra L F
inst✝¹ : IsScalarTower K L F
inst✝ : Algebra.IsSeparable K F
x : F
⊢ (norm K) ((norm L) x) = (norm K) x
state_after: case pos
R : Type u_1
S : Type u_2
T : Type u_3
inst✝¹² : CommRing R
inst✝¹¹ : Ring S
inst✝¹⁰ : Algebra R S
K : Type u_4
L : Type u_5
F : Type u_6
inst✝⁹ : Field K
inst✝⁸ : Field L
inst✝⁷ : Field F
inst✝⁶ : Algebra K L
inst✝⁵ : Algebra K F
ι : Type w
E : Type u_7
inst✝⁴ : Field E
inst✝³ : Algebra K E
inst✝² : Algebra L F
inst✝¹ : IsScalarTower K L F
inst✝ : Algebra.IsSeparable K F
x : F
hKF : FiniteDimensional K F
⊢ (norm K) ((norm L) x) = (norm K) x

case neg
R : Type u_1
S : Type u_2
T : Type u_3
inst✝¹² : CommRing R
inst✝¹¹ : Ring S
inst✝¹⁰ : Algebra R S
K : Type u_4
L : Type u_5
F : Type u_6
inst✝⁹ : Field K
inst✝⁸ : Field L
inst✝⁷ : Field F
inst✝⁶ : Algebra K L
inst✝⁵ : Algebra K F
ι : Type w
E : Type u_7
inst✝⁴ : Field E
inst✝³ : Algebra K E
inst✝² : Algebra L F
inst✝¹ : IsScalarTower K L F
inst✝ : Algebra.IsSeparable K F
x : F
hKF : ¬FiniteDimensional K F
⊢ (norm K) ((norm L) x) = (norm K) x
tactic: by_cases hKF : FiniteDimensional K F
Theorem: Polynomial.eval₂_X_mul
File: Mathlib/Algebra/Polynomial/Eval.lean

Proof steps:
state_before: R : Type u
S : Type v
T : Type w
ι : Type y
a b : R
m n : ℕ
inst✝² : Semiring R
p q r : R[X]
inst✝¹ : Semiring S
f : R →+* S
x : S
inst✝ : Semiring T
⊢ eval₂ f x (X * p) = eval₂ f x p * x
state_after: no goals
tactic: rw [X_mul, eval₂_mul_X]
Theorem: RingQuot.one_quot
File: Mathlib/Algebra/RingQuot.lean

Proof steps:
state_before: R : Type uR
inst✝³ : Semiring R
S : Type uS
inst✝² : CommSemiring S
T : Type uT
A : Type uA
inst✝¹ : Semiring A
inst✝ : Algebra S A
r : R → R → Prop
⊢ { toQuot := Quot.mk (Rel r) 1 } = RingQuot.one r
state_after: no goals
tactic: rw [one_def]
Theorem: PartialHomeomorph.univBall_apply_zero
File: Mathlib/Analysis/NormedSpace/HomeomorphBall.lean

Proof steps:
state_before: E : Type u_1
inst✝³ : SeminormedAddCommGroup E
inst✝² : NormedSpace ℝ E
P : Type u_2
inst✝¹ : PseudoMetricSpace P
inst✝ : NormedAddTorsor E P
c : P
r : ℝ
⊢ ↑(univBall c r) 0 = c
state_after: E : Type u_1
inst✝³ : SeminormedAddCommGroup E
inst✝² : NormedSpace ℝ E
P : Type u_2
inst✝¹ : PseudoMetricSpace P
inst✝ : NormedAddTorsor E P
c : P
r : ℝ
⊢ ↑(if h : 0 < r then univUnitBall.trans' (unitBallBall c r h) ⋯
        else (IsometryEquiv.vaddConst c).toHomeomorph.toPartialHomeomorph)
      0 =
    c
tactic: unfold univBall
state_before: E : Type u_1
inst✝³ : SeminormedAddCommGroup E
inst✝² : NormedSpace ℝ E
P : Type u_2
inst✝¹ : PseudoMetricSpace P
inst✝ : NormedAddTorsor E P
c : P
r : ℝ
⊢ ↑(if h : 0 < r then univUnitBall.trans' (unitBallBall c r h) ⋯
        else (IsometryEquiv.vaddConst c).toHomeomorph.toPartialHomeomorph)
      0 =
    c
state_after: no goals
tactic: split_ifs <;> simp
Theorem: MeasureTheory.L1.SimpleFunc.integrable
File: Mathlib/MeasureTheory/Function/SimpleFuncDenseLp.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
E : Type u_4
F : Type u_5
𝕜 : Type u_6
inst✝¹ : MeasurableSpace α
inst✝ : NormedAddCommGroup E
f✝ : α → E
p : ℝ≥0∞
μ : Measure α
f : ↥(Lp.simpleFunc E 1 μ)
⊢ Integrable (↑(Lp.simpleFunc.toSimpleFunc f)) μ
state_after: α : Type u_1
β : Type u_2
ι : Type u_3
E : Type u_4
F : Type u_5
𝕜 : Type u_6
inst✝¹ : MeasurableSpace α
inst✝ : NormedAddCommGroup E
f✝ : α → E
p : ℝ≥0∞
μ : Measure α
f : ↥(Lp.simpleFunc E 1 μ)
⊢ Memℒp (↑(Lp.simpleFunc.toSimpleFunc f)) 1 μ
tactic: rw [← memℒp_one_iff_integrable]
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
E : Type u_4
F : Type u_5
𝕜 : Type u_6
inst✝¹ : MeasurableSpace α
inst✝ : NormedAddCommGroup E
f✝ : α → E
p : ℝ≥0∞
μ : Measure α
f : ↥(Lp.simpleFunc E 1 μ)
⊢ Memℒp (↑(Lp.simpleFunc.toSimpleFunc f)) 1 μ
state_after: no goals
tactic: exact Lp.simpleFunc.memℒp f
Theorem: infIccOrderIsoIccSup_symm_apply_coe
File: Mathlib/Order/ModularLattice.lean

Proof steps:
state_before: α : Type u_1
inst✝¹ : Lattice α
inst✝ : IsModularLattice α
x✝ y z a b : α
x : ↑(Icc (a ⊓ b) a)
⊢ ↑((fun x => ⟨a ⊓ ↑x, ⋯⟩) ((fun x => ⟨↑x ⊔ b, ⋯⟩) x)) = ↑x
state_after: α : Type u_1
inst✝¹ : Lattice α
inst✝ : IsModularLattice α
x✝ y z a b : α
x : ↑(Icc (a ⊓ b) a)
⊢ a ⊓ (↑x ⊔ b) = ↑x
tactic: change a ⊓ (↑x ⊔ b) = ↑x
state_before: α : Type u_1
inst✝¹ : Lattice α
inst✝ : IsModularLattice α
x✝ y z a b : α
x : ↑(Icc (a ⊓ b) a)
⊢ a ⊓ (↑x ⊔ b) = ↑x
state_after: no goals
tactic: rw [sup_comm, ← inf_sup_assoc_of_le _ x.prop.2, sup_eq_right.2 x.prop.1]
state_before: α : Type u_1
inst✝¹ : Lattice α
inst✝ : IsModularLattice α
x✝ y z a b : α
x : ↑(Icc b (a ⊔ b))
⊢ ↑((fun x => ⟨↑x ⊔ b, ⋯⟩) ((fun x => ⟨a ⊓ ↑x, ⋯⟩) x)) = ↑x
state_after: α : Type u_1
inst✝¹ : Lattice α
inst✝ : IsModularLattice α
x✝ y z a b : α
x : ↑(Icc b (a ⊔ b))
⊢ a ⊓ ↑x ⊔ b = ↑x
tactic: change a ⊓ ↑x ⊔ b = ↑x
state_before: α : Type u_1
inst✝¹ : Lattice α
inst✝ : IsModularLattice α
x✝ y z a b : α
x : ↑(Icc b (a ⊔ b))
⊢ a ⊓ ↑x ⊔ b = ↑x
state_after: no goals
tactic: rw [inf_comm, inf_sup_assoc_of_le _ x.prop.1, inf_eq_left.2 x.prop.2]
state_before: α : Type u_1
inst✝¹ : Lattice α
inst✝ : IsModularLattice α
x✝ y✝ z a b : α
x y : ↑(Icc (a ⊓ b) a)
⊢ { toFun := fun x => ⟨↑x ⊔ b, ⋯⟩, invFun := fun x => ⟨a ⊓ ↑x, ⋯⟩, left_inv := ⋯, right_inv := ⋯ } x ≤
      { toFun := fun x => ⟨↑x ⊔ b, ⋯⟩, invFun := fun x => ⟨a ⊓ ↑x, ⋯⟩, left_inv := ⋯, right_inv := ⋯ } y ↔
    x ≤ y
state_after: α : Type u_1
inst✝¹ : Lattice α
inst✝ : IsModularLattice α
x✝ y✝ z a b : α
x y : ↑(Icc (a ⊓ b) a)
⊢ ↑x ⊔ b ≤ ↑y ⊔ b ↔ x ≤ y
tactic: simp only [Subtype.mk_le_mk, Equiv.coe_fn_mk, and_true_iff, le_sup_right]
state_before: α : Type u_1
inst✝¹ : Lattice α
inst✝ : IsModularLattice α
x✝ y✝ z a b : α
x y : ↑(Icc (a ⊓ b) a)
⊢ ↑x ⊔ b ≤ ↑y ⊔ b ↔ x ≤ y
state_after: α : Type u_1
inst✝¹ : Lattice α
inst✝ : IsModularLattice α
x✝ y✝ z a b : α
x y : ↑(Icc (a ⊓ b) a)
⊢ ↑x ⊔ b ≤ ↑y ⊔ b ↔ ↑x ≤ ↑y
tactic: rw [← Subtype.coe_le_coe]
state_before: α : Type u_1
inst✝¹ : Lattice α
inst✝ : IsModularLattice α
x✝ y✝ z a b : α
x y : ↑(Icc (a ⊓ b) a)
⊢ ↑x ⊔ b ≤ ↑y ⊔ b ↔ ↑x ≤ ↑y
state_after: α : Type u_1
inst✝¹ : Lattice α
inst✝ : IsModularLattice α
x✝ y✝ z a b : α
x y : ↑(Icc (a ⊓ b) a)
h : ↑x ⊔ b ≤ ↑y ⊔ b
⊢ ↑x ≤ ↑y
tactic: refine ⟨fun h => ?_, fun h => sup_le_sup_right h _⟩
state_before: α : Type u_1
inst✝¹ : Lattice α
inst✝ : IsModularLattice α
x✝ y✝ z a b : α
x y : ↑(Icc (a ⊓ b) a)
h : ↑x ⊔ b ≤ ↑y ⊔ b
⊢ ↑x ≤ ↑y
state_after: α : Type u_1
inst✝¹ : Lattice α
inst✝ : IsModularLattice α
x✝ y✝ z a b : α
x y : ↑(Icc (a ⊓ b) a)
h : ↑x ⊔ b ≤ ↑y ⊔ b
⊢ a ⊓ (↑x ⊔ b) ≤ a ⊓ (↑y ⊔ b)
tactic: rw [← sup_eq_right.2 x.prop.1, inf_sup_assoc_of_le _ x.prop.2, sup_comm, ←
      sup_eq_right.2 y.prop.1, inf_sup_assoc_of_le _ y.prop.2, sup_comm b]
state_before: α : Type u_1
inst✝¹ : Lattice α
inst✝ : IsModularLattice α
x✝ y✝ z a b : α
x y : ↑(Icc (a ⊓ b) a)
h : ↑x ⊔ b ≤ ↑y ⊔ b
⊢ a ⊓ (↑x ⊔ b) ≤ a ⊓ (↑y ⊔ b)
state_after: no goals
tactic: exact inf_le_inf_left _ h
Theorem: isUnit_iff_dvd_one
File: Mathlib/Algebra/Divisibility/Units.lean

Proof steps:
state_before: α : Type u_1
inst✝ : CommMonoid α
x : α
x✝ : x ∣ 1
y : α
h : 1 = x * y
⊢ y * x = 1
state_after: no goals
tactic: rw [h, mul_comm]
Theorem: AntilipschitzWith.le_mul_norm_div
File: Mathlib/Analysis/Normed/Group/Uniform.lean

Proof steps:
state_before: 𝓕 : Type u_1
α✝ : Type u_2
E✝ : Type u_3
F : Type u_4
inst✝³ : SeminormedCommGroup E✝
inst✝² : SeminormedCommGroup F
a a₁ a₂ b b₁ b₂ : E✝
r r₁ r₂ : ℝ
α : Type u_5
E : Type u_6
inst✝¹ : SeminormedCommGroup E
inst✝ : PseudoEMetricSpace α
K Kf Kg : ℝ≥0
f✝ g : α → E
s : Set α
x✝ : α
f : E → F
hf : AntilipschitzWith K f
x y : E
⊢ ‖x / y‖ ≤ ↑K * ‖f x / f y‖
state_after: no goals
tactic: simp [← dist_eq_norm_div, hf.le_mul_dist x y]
Theorem: AddAction.stabilizer_image_coe_quotient
File: Mathlib/Algebra/Pointwise/Stabilizer.lean

Proof steps:
state_before: G : Type u_1
inst✝ : CommGroup G
s : Set G
⊢ stabilizer (G ⧸ stabilizer G s) (QuotientGroup.mk '' s) = ⊥
state_after: case h
G : Type u_1
inst✝ : CommGroup G
s : Set G
a : G ⧸ stabilizer G s
⊢ a ∈ stabilizer (G ⧸ stabilizer G s) (QuotientGroup.mk '' s) ↔ a ∈ ⊥
tactic: ext a
state_before: case h
G : Type u_1
inst✝ : CommGroup G
s : Set G
a : G ⧸ stabilizer G s
⊢ a ∈ stabilizer (G ⧸ stabilizer G s) (QuotientGroup.mk '' s) ↔ a ∈ ⊥
state_after: case h.H
G : Type u_1
inst✝ : CommGroup G
s : Set G
a : G
⊢ ↑a ∈ stabilizer (G ⧸ stabilizer G s) (QuotientGroup.mk '' s) ↔ ↑a ∈ ⊥
tactic: induction' a using QuotientGroup.induction_on' with a
state_before: case h.H
G : Type u_1
inst✝ : CommGroup G
s : Set G
a : G
⊢ ↑a ∈ stabilizer (G ⧸ stabilizer G s) (QuotientGroup.mk '' s) ↔ ↑a ∈ ⊥
state_after: case h.H
G : Type u_1
inst✝ : CommGroup G
s : Set G
a : G
⊢ ↑a • QuotientGroup.mk '' s = QuotientGroup.mk '' s ↔ a • s = s
tactic: simp only [mem_stabilizer_iff, Subgroup.mem_bot, QuotientGroup.eq_one_iff]
state_before: case h.H
G : Type u_1
inst✝ : CommGroup G
s : Set G
a : G
⊢ ↑a • QuotientGroup.mk '' s = QuotientGroup.mk '' s ↔ a • s = s
state_after: case h.H
G : Type u_1
inst✝ : CommGroup G
s : Set G
a : G
this : ↑a • QuotientGroup.mk '' s = QuotientGroup.mk '' (a • s)
⊢ ↑a • QuotientGroup.mk '' s = QuotientGroup.mk '' s ↔ a • s = s
tactic: have : q a • q '' s = q '' (a • s) :=
    (image_smul_distrib (QuotientGroup.mk' <| stabilizer G s) _ _).symm
state_before: case h.H
G : Type u_1
inst✝ : CommGroup G
s : Set G
a : G
this : ↑a • QuotientGroup.mk '' s = QuotientGroup.mk '' (a • s)
⊢ ↑a • QuotientGroup.mk '' s = QuotientGroup.mk '' s ↔ a • s = s
state_after: case h.H
G : Type u_1
inst✝ : CommGroup G
s : Set G
a : G
this : ↑a • QuotientGroup.mk '' s = QuotientGroup.mk '' (a • s)
⊢ QuotientGroup.mk '' (a • s) = QuotientGroup.mk '' s ↔ a • s = s
tactic: rw [this]
state_before: case h.H
G : Type u_1
inst✝ : CommGroup G
s : Set G
a : G
this : ↑a • QuotientGroup.mk '' s = QuotientGroup.mk '' (a • s)
⊢ QuotientGroup.mk '' (a • s) = QuotientGroup.mk '' s ↔ a • s = s
state_after: case h.H
G : Type u_1
inst✝ : CommGroup G
s : Set G
a : G
this : ↑a • QuotientGroup.mk '' s = QuotientGroup.mk '' (a • s)
h : QuotientGroup.mk '' (a • s) = QuotientGroup.mk '' s
⊢ a • s = s
tactic: refine ⟨fun h ↦ ?_, fun h ↦ by rw [h]⟩
state_before: case h.H
G : Type u_1
inst✝ : CommGroup G
s : Set G
a : G
this : ↑a • QuotientGroup.mk '' s = QuotientGroup.mk '' (a • s)
h : QuotientGroup.mk '' (a • s) = QuotientGroup.mk '' s
⊢ a • s = s
state_after: no goals
tactic: rwa [QuotientGroup.image_coe_inj, mul_smul_comm, stabilizer_mul_self] at h
Theorem: SetTheory.PGame.add_moveLeft_inr
File: Mathlib/SetTheory/Game/PGame.lean

Proof steps:
state_before: xl xr : Type u
x y : PGame
i : y.LeftMoves
⊢ (x + y).moveLeft (toLeftMovesAdd (Sum.inr i)) = x + y.moveLeft i
state_after: case mk
xl xr : Type u
y : PGame
i : y.LeftMoves
α✝ β✝ : Type u_1
a✝¹ : α✝ → PGame
a✝ : β✝ → PGame
⊢ (mk α✝ β✝ a✝¹ a✝ + y).moveLeft (toLeftMovesAdd (Sum.inr i)) = mk α✝ β✝ a✝¹ a✝ + y.moveLeft i
tactic: cases x
state_before: case mk
xl xr : Type u
y : PGame
i : y.LeftMoves
α✝ β✝ : Type u_1
a✝¹ : α✝ → PGame
a✝ : β✝ → PGame
⊢ (mk α✝ β✝ a✝¹ a✝ + y).moveLeft (toLeftMovesAdd (Sum.inr i)) = mk α✝ β✝ a✝¹ a✝ + y.moveLeft i
state_after: case mk.mk
xl xr : Type u
α✝¹ β✝¹ : Type u_1
a✝³ : α✝¹ → PGame
a✝² : β✝¹ → PGame
α✝ β✝ : Type u_1
a✝¹ : α✝ → PGame
a✝ : β✝ → PGame
i : (mk α✝ β✝ a✝¹ a✝).LeftMoves
⊢ (mk α✝¹ β✝¹ a✝³ a✝² + mk α✝ β✝ a✝¹ a✝).moveLeft (toLeftMovesAdd (Sum.inr i)) =
    mk α✝¹ β✝¹ a✝³ a✝² + (mk α✝ β✝ a✝¹ a✝).moveLeft i
tactic: cases y
state_before: case mk.mk
xl xr : Type u
α✝¹ β✝¹ : Type u_1
a✝³ : α✝¹ → PGame
a✝² : β✝¹ → PGame
α✝ β✝ : Type u_1
a✝¹ : α✝ → PGame
a✝ : β✝ → PGame
i : (mk α✝ β✝ a✝¹ a✝).LeftMoves
⊢ (mk α✝¹ β✝¹ a✝³ a✝² + mk α✝ β✝ a✝¹ a✝).moveLeft (toLeftMovesAdd (Sum.inr i)) =
    mk α✝¹ β✝¹ a✝³ a✝² + (mk α✝ β✝ a✝¹ a✝).moveLeft i
state_after: no goals
tactic: rfl
Theorem: CategoryTheory.Limits.pushout.map_comp
File: Mathlib/CategoryTheory/Limits/Shapes/Pullback/HasPullback.lean

Proof steps:
state_before: C : Type u
inst✝³ : Category.{v, u} C
W X✝ Y✝ Z✝ X Y Z X' Y' Z' X'' Y'' Z'' : C
f : X ⟶ Y
g : X ⟶ Z
f' : X' ⟶ Y'
g' : X' ⟶ Z'
f'' : X'' ⟶ Y''
g'' : X'' ⟶ Z''
i₁ : X ⟶ X'
j₁ : X' ⟶ X''
i₂ : Y ⟶ Y'
j₂ : Y' ⟶ Y''
i₃ : Z ⟶ Z'
j₃ : Z' ⟶ Z''
inst✝² : HasPushout f g
inst✝¹ : HasPushout f' g'
inst✝ : HasPushout f'' g''
e₁ : f ≫ i₂ = i₁ ≫ f'
e₂ : g ≫ i₃ = i₁ ≫ g'
e₃ : f' ≫ j₂ = j₁ ≫ f''
e₄ : g' ≫ j₃ = j₁ ≫ g''
⊢ f ≫ i₂ ≫ j₂ = (i₁ ≫ j₁) ≫ f''
state_after: no goals
tactic: rw [reassoc_of% e₁, e₃, Category.assoc]
state_before: C : Type u
inst✝³ : Category.{v, u} C
W X✝ Y✝ Z✝ X Y Z X' Y' Z' X'' Y'' Z'' : C
f : X ⟶ Y
g : X ⟶ Z
f' : X' ⟶ Y'
g' : X' ⟶ Z'
f'' : X'' ⟶ Y''
g'' : X'' ⟶ Z''
i₁ : X ⟶ X'
j₁ : X' ⟶ X''
i₂ : Y ⟶ Y'
j₂ : Y' ⟶ Y''
i₃ : Z ⟶ Z'
j₃ : Z' ⟶ Z''
inst✝² : HasPushout f g
inst✝¹ : HasPushout f' g'
inst✝ : HasPushout f'' g''
e₁ : f ≫ i₂ = i₁ ≫ f'
e₂ : g ≫ i₃ = i₁ ≫ g'
e₃ : f' ≫ j₂ = j₁ ≫ f''
e₄ : g' ≫ j₃ = j₁ ≫ g''
⊢ g ≫ i₃ ≫ j₃ = (i₁ ≫ j₁) ≫ g''
state_after: no goals
tactic: rw [reassoc_of% e₂, e₄, Category.assoc]
state_before: C : Type u
inst✝³ : Category.{v, u} C
W X✝ Y✝ Z✝ X Y Z X' Y' Z' X'' Y'' Z'' : C
f : X ⟶ Y
g : X ⟶ Z
f' : X' ⟶ Y'
g' : X' ⟶ Z'
f'' : X'' ⟶ Y''
g'' : X'' ⟶ Z''
i₁ : X ⟶ X'
j₁ : X' ⟶ X''
i₂ : Y ⟶ Y'
j₂ : Y' ⟶ Y''
i₃ : Z ⟶ Z'
j₃ : Z' ⟶ Z''
inst✝² : HasPushout f g
inst✝¹ : HasPushout f' g'
inst✝ : HasPushout f'' g''
e₁ : f ≫ i₂ = i₁ ≫ f'
e₂ : g ≫ i₃ = i₁ ≫ g'
e₃ : f' ≫ j₂ = j₁ ≫ f''
e₄ : g' ≫ j₃ = j₁ ≫ g''
⊢ map f g f' g' i₂ i₃ i₁ e₁ e₂ ≫ map f' g' f'' g'' j₂ j₃ j₁ e₃ e₄ = map f g f'' g'' (i₂ ≫ j₂) (i₃ ≫ j₃) (i₁ ≫ j₁) ⋯ ⋯
state_after: no goals
tactic: ext <;> simp
Theorem: Real.tanh_neg
File: Mathlib/Data/Complex/Exponential.lean

Proof steps:
state_before: x y : ℝ
⊢ tanh (-x) = -tanh x
state_after: no goals
tactic: simp [tanh, neg_div]