1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: Equiv.algEquiv_symm_apply
File: Mathlib/Logic/Equiv/TransferInstance.lean

tactic: letI := Equiv.semiring e
state_before: α : Type u
β : Type v
e✝ : α ≃ β
R : Type u_1
inst✝² : CommSemiring R
e : α ≃ β
inst✝¹ : Semiring β
inst✝ : Algebra R β
b : β
⊢ Sort ?u.138265
state_after: α : Type u
β : Type v
e✝ : α ≃ β
R : Type u_1
inst✝² : CommSemiring R
e : α ≃ β
inst✝¹ : Semiring β
inst✝ : Algebra R β
b : β
this : Semiring α := e.semiring
⊢ Sort ?u.138265

tactic: letI := Equiv.algebra R e
state_before: α : Type u
β : Type v
e✝ : α ≃ β
R : Type u_1
inst✝² : CommSemiring R
e : α ≃ β
inst✝¹ : Semiring β
inst✝ : Algebra R β
b : β
this : Semiring α := e.semiring
⊢ Sort ?u.138265
state_after: α : Type u
β : Type v
e✝ : α ≃ β
R : Type u_1
inst✝² : CommSemiring R
e : α ≃ β
inst✝¹ : Semiring β
inst✝ : Algebra R β
b : β
this✝ : Semiring α := e.semiring
this : Algebra R α := Equiv.algebra R e
⊢ Sort ?u.138265

tactic: exact (algEquiv R e).symm b = e.symm b
state_before: α : Type u
β : Type v
e✝ : α ≃ β
R : Type u_1
inst✝² : CommSemiring R
e : α ≃ β
inst✝¹ : Semiring β
inst✝ : Algebra R β
b : β
this✝ : Semiring α := e.semiring
this : Algebra R α := Equiv.algebra R e
⊢ Sort ?u.138265
state_after: no goals
Theorem: BoxIntegral.Prepartition.mem_biUnionIndex
File: Mathlib/Analysis/BoxIntegral/Partition/Basic.lean

tactic: convert (π.mem_biUnion.1 hJ).choose_spec.2 <;> exact dif_pos hJ
state_before: ι : Type u_1
I J J₁ J₂ : Box ι
π π₁ π₂ : Prepartition I
x : ι → ℝ
πi πi₁ πi₂ : (J : Box ι) → Prepartition J
hJ : J ∈ π.biUnion πi
⊢ J ∈ πi (π.biUnionIndex πi J)
state_after: no goals
Theorem: Ordinal.log_mod_opow_log_lt_log_self
File: Mathlib/SetTheory/Ordinal/Exponential.lean

tactic: rcases eq_or_ne (o % (b ^ log b o)) 0 with h | h
state_before: b o : Ordinal.{u_1}
hb : 1 < b
ho : o ≠ 0
hbo : b ≤ o
⊢ log b (o % b ^ log b o) < log b o
state_after: case inl
b o : Ordinal.{u_1}
hb : 1 < b
ho : o ≠ 0
hbo : b ≤ o
h : o % b ^ log b o = 0
⊢ log b (o % b ^ log b o) < log b o

case inr
b o : Ordinal.{u_1}
hb : 1 < b
ho : o ≠ 0
hbo : b ≤ o
h : o % b ^ log b o ≠ 0
⊢ log b (o % b ^ log b o) < log b o

tactic: rw [h, log_zero_right]
state_before: case inl
b o : Ordinal.{u_1}
hb : 1 < b
ho : o ≠ 0
hbo : b ≤ o
h : o % b ^ log b o = 0
⊢ log b (o % b ^ log b o) < log b o
state_after: case inl
b o : Ordinal.{u_1}
hb : 1 < b
ho : o ≠ 0
hbo : b ≤ o
h : o % b ^ log b o = 0
⊢ 0 < log b o

tactic: apply log_pos hb ho hbo
state_before: case inl
b o : Ordinal.{u_1}
hb : 1 < b
ho : o ≠ 0
hbo : b ≤ o
h : o % b ^ log b o = 0
⊢ 0 < log b o
state_after: no goals

tactic: rw [← succ_le_iff, succ_log_def hb h]
state_before: case inr
b o : Ordinal.{u_1}
hb : 1 < b
ho : o ≠ 0
hbo : b ≤ o
h : o % b ^ log b o ≠ 0
⊢ log b (o % b ^ log b o) < log b o
state_after: case inr
b o : Ordinal.{u_1}
hb : 1 < b
ho : o ≠ 0
hbo : b ≤ o
h : o % b ^ log b o ≠ 0
⊢ sInf {o_1 | o % b ^ log b o < b ^ o_1} ≤ log b o

tactic: apply csInf_le'
state_before: case inr
b o : Ordinal.{u_1}
hb : 1 < b
ho : o ≠ 0
hbo : b ≤ o
h : o % b ^ log b o ≠ 0
⊢ sInf {o_1 | o % b ^ log b o < b ^ o_1} ≤ log b o
state_after: case inr.h
b o : Ordinal.{u_1}
hb : 1 < b
ho : o ≠ 0
hbo : b ≤ o
h : o % b ^ log b o ≠ 0
⊢ log b o ∈ {o_1 | o % b ^ log b o < b ^ o_1}

tactic: apply mod_lt
state_before: case inr.h
b o : Ordinal.{u_1}
hb : 1 < b
ho : o ≠ 0
hbo : b ≤ o
h : o % b ^ log b o ≠ 0
⊢ log b o ∈ {o_1 | o % b ^ log b o < b ^ o_1}
state_after: case inr.h.h
b o : Ordinal.{u_1}
hb : 1 < b
ho : o ≠ 0
hbo : b ≤ o
h : o % b ^ log b o ≠ 0
⊢ b ^ log b o ≠ 0

tactic: rw [← Ordinal.pos_iff_ne_zero]
state_before: case inr.h.h
b o : Ordinal.{u_1}
hb : 1 < b
ho : o ≠ 0
hbo : b ≤ o
h : o % b ^ log b o ≠ 0
⊢ b ^ log b o ≠ 0
state_after: case inr.h.h
b o : Ordinal.{u_1}
hb : 1 < b
ho : o ≠ 0
hbo : b ≤ o
h : o % b ^ log b o ≠ 0
⊢ 0 < b ^ log b o

tactic: exact opow_pos _ (zero_lt_one.trans hb)
state_before: case inr.h.h
b o : Ordinal.{u_1}
hb : 1 < b
ho : o ≠ 0
hbo : b ≤ o
h : o % b ^ log b o ≠ 0
⊢ 0 < b ^ log b o
state_after: no goals
Theorem: Equiv.Perm.fixed_point_card_lt_of_ne_one
File: Mathlib/GroupTheory/Perm/Support.lean

tactic: rw [Nat.lt_sub_iff_add_lt, ← Nat.lt_sub_iff_add_lt', ← Finset.card_compl, Finset.compl_filter]
state_before: α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
σ : Perm α
h : σ ≠ 1
⊢ (filter (fun x => σ x = x) univ).card < Fintype.card α - 1
state_after: α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
σ : Perm α
h : σ ≠ 1
⊢ 1 < (filter (fun x => ¬σ x = x) univ).card

tactic: exact one_lt_card_support_of_ne_one h
state_before: α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
σ : Perm α
h : σ ≠ 1
⊢ 1 < (filter (fun x => ¬σ x = x) univ).card
state_after: no goals
Theorem: DMatrix.ext_iff
File: Mathlib/Data/Matrix/DMatrix.lean

tactic: simp [h]
state_before: l : Type u_1
m : Type u_2
n : Type u_3
o : Type u_4
α : m → n → Type v
M N : DMatrix m n α
h : M = N
⊢ ∀ (i : m) (j : n), M i j = N i j
state_after: no goals
Theorem: ContinuousAt.finset_sup'
File: Mathlib/Topology/Order/Lattice.lean

tactic: simpa only [← Finset.sup'_apply] using finset_sup'_apply hne hs
state_before: L : Type u_1
X : Type u_2
inst✝³ : TopologicalSpace L
inst✝² : TopologicalSpace X
ι : Type u_3
inst✝¹ : SemilatticeSup L
inst✝ : ContinuousSup L
s : Finset ι
f : ι → X → L
t : Set X
x : X
hne : s.Nonempty
hs : ∀ i ∈ s, ContinuousAt (f i) x
⊢ ContinuousAt (s.sup' hne f) x
state_after: no goals
Theorem: Real.logb_pos_iff
File: Mathlib/Analysis/SpecialFunctions/Log/Base.lean

tactic: rw [← @logb_one b]
state_before: b x y : ℝ
hb : 1 < b
hx : 0 < x
⊢ 0 < logb b x ↔ 1 < x
state_after: b x y : ℝ
hb : 1 < b
hx : 0 < x
⊢ logb b 1 < logb b x ↔ 1 < x

tactic: rw [logb_lt_logb_iff hb zero_lt_one hx]
state_before: b x y : ℝ
hb : 1 < b
hx : 0 < x
⊢ logb b 1 < logb b x ↔ 1 < x
state_after: no goals
Theorem: MvPolynomial.expand_comp_bind₁
File: Mathlib/Algebra/MvPolynomial/Expand.lean

tactic: apply algHom_ext
state_before: σ : Type u_1
τ : Type u_2
R : Type u_3
S : Type u_4
inst✝¹ : CommSemiring R
inst✝ : CommSemiring S
p : ℕ
f : σ → MvPolynomial τ R
⊢ (expand p).comp (bind₁ f) = bind₁ fun i => (expand p) (f i)
state_after: case hf
σ : Type u_1
τ : Type u_2
R : Type u_3
S : Type u_4
inst✝¹ : CommSemiring R
inst✝ : CommSemiring S
p : ℕ
f : σ → MvPolynomial τ R
⊢ ∀ (i : σ), ((expand p).comp (bind₁ f)) (X i) = (bind₁ fun i => (expand p) (f i)) (X i)

tactic: intro i
state_before: case hf
σ : Type u_1
τ : Type u_2
R : Type u_3
S : Type u_4
inst✝¹ : CommSemiring R
inst✝ : CommSemiring S
p : ℕ
f : σ → MvPolynomial τ R
⊢ ∀ (i : σ), ((expand p).comp (bind₁ f)) (X i) = (bind₁ fun i => (expand p) (f i)) (X i)
state_after: case hf
σ : Type u_1
τ : Type u_2
R : Type u_3
S : Type u_4
inst✝¹ : CommSemiring R
inst✝ : CommSemiring S
p : ℕ
f : σ → MvPolynomial τ R
i : σ
⊢ ((expand p).comp (bind₁ f)) (X i) = (bind₁ fun i => (expand p) (f i)) (X i)

tactic: simp only [AlgHom.comp_apply, bind₁_X_right]
state_before: case hf
σ : Type u_1
τ : Type u_2
R : Type u_3
S : Type u_4
inst✝¹ : CommSemiring R
inst✝ : CommSemiring S
p : ℕ
f : σ → MvPolynomial τ R
i : σ
⊢ ((expand p).comp (bind₁ f)) (X i) = (bind₁ fun i => (expand p) (f i)) (X i)
state_after: no goals
Theorem: Finset.Colex.singleton_lt_singleton
File: Mathlib/Combinatorics/Colex.lean

tactic: simp [toColex_lt_singleton]
state_before: α : Type u_1
β : Type u_2
inst✝¹ : PartialOrder α
inst✝ : PartialOrder β
f : α → β
𝒜 𝒜₁ 𝒜₂ : Finset (Finset α)
s t u : Finset α
a b : α
⊢ { ofColex := {a} } < { ofColex := {b} } ↔ a < b
state_after: no goals
Theorem: Nat.periodic_coprime
File: Mathlib/Data/Nat/Periodic.lean

tactic: simp only [coprime_add_self_right, forall_const, iff_self_iff, eq_iff_iff, Periodic]
state_before: a : ℕ
⊢ Periodic a.Coprime a
state_after: no goals
Theorem: Nat.ascFactorial_le_pow_add
File: Mathlib/Data/Nat/Factorial/Basic.lean

tactic: rw [ascFactorial_zero, Nat.pow_zero]
state_before: n : ℕ
⊢ (n + 1).ascFactorial 0 ≤ (n + 0) ^ 0
state_after: no goals

tactic: rw [ascFactorial_succ, Nat.pow_succ, Nat.mul_comm, ← Nat.add_assoc, Nat.add_right_comm n 1 k]
state_before: n k : ℕ
⊢ (n + 1).ascFactorial (k + 1) ≤ (n + (k + 1)) ^ (k + 1)
state_after: n k : ℕ
⊢ (n + 1).ascFactorial k * (n + k + 1) ≤ (n + k + 1) ^ k * (n + k + 1)

tactic: exact Nat.mul_le_mul_right _
  (Nat.le_trans (ascFactorial_le_pow_add _ k) (Nat.pow_le_pow_left (le_succ _) _))
state_before: n k : ℕ
⊢ (n + 1).ascFactorial k * (n + k + 1) ≤ (n + k + 1) ^ k * (n + k + 1)
state_after: no goals
Theorem: Polynomial.aeval_map_algebraMap
File: Mathlib/RingTheory/Polynomial/Tower.lean

tactic: rw [aeval_def, aeval_def, eval₂_map, IsScalarTower.algebraMap_eq R A B]
state_before: R : Type u_1
A : Type u_2
B : Type u_3
inst✝⁶ : CommSemiring R
inst✝⁵ : CommSemiring A
inst✝⁴ : Semiring B
inst✝³ : Algebra R A
inst✝² : Algebra A B
inst✝¹ : Algebra R B
inst✝ : IsScalarTower R A B
x : B
p : R[X]
⊢ (aeval x) (map (algebraMap R A) p) = (aeval x) p
state_after: no goals
Theorem: ProbabilityTheory.compProd_toKernel
File: Mathlib/Probability/Kernel/Disintegration/CdfToKernel.lean

tactic: ext a s hs
state_before: α : Type u_1
β : Type u_2
mα : MeasurableSpace α
mβ : MeasurableSpace β
κ : ↥(kernel α (β × ℝ))
ν : ↥(kernel α β)
f : α × β → StieltjesFunction
inst✝¹ : IsFiniteKernel κ
inst✝ : IsSFiniteKernel ν
hf : IsCondKernelCDF f κ ν
⊢ ν ⊗ₖ IsCondKernelCDF.toKernel f hf = κ
state_after: case h.h
α : Type u_1
β : Type u_2
mα : MeasurableSpace α
mβ : MeasurableSpace β
κ : ↥(kernel α (β × ℝ))
ν : ↥(kernel α β)
f : α × β → StieltjesFunction
inst✝¹ : IsFiniteKernel κ
inst✝ : IsSFiniteKernel ν
hf : IsCondKernelCDF f κ ν
a : α
s : Set (β × ℝ)
hs : MeasurableSet s
⊢ ((ν ⊗ₖ IsCondKernelCDF.toKernel f hf) a) s = (κ a) s

tactic: rw [kernel.compProd_apply _ _ _ hs, lintegral_toKernel_mem hf a hs]
state_before: case h.h
α : Type u_1
β : Type u_2
mα : MeasurableSpace α
mβ : MeasurableSpace β
κ : ↥(kernel α (β × ℝ))
ν : ↥(kernel α β)
f : α × β → StieltjesFunction
inst✝¹ : IsFiniteKernel κ
inst✝ : IsSFiniteKernel ν
hf : IsCondKernelCDF f κ ν
a : α
s : Set (β × ℝ)
hs : MeasurableSet s
⊢ ((ν ⊗ₖ IsCondKernelCDF.toKernel f hf) a) s = (κ a) s
state_after: no goals
Theorem: List.prod_pos
File: Mathlib/Algebra/Order/BigOperators/Ring/List.lean

tactic: induction' l with a l ih
state_before: R : Type u_1
inst✝ : StrictOrderedSemiring R
l : List R
h : ∀ a ∈ l, 0 < a
⊢ 0 < l.prod
state_after: case nil
R : Type u_1
inst✝ : StrictOrderedSemiring R
h : ∀ a ∈ [], 0 < a
⊢ 0 < [].prod

case cons
R : Type u_1
inst✝ : StrictOrderedSemiring R
a : R
l : List R
ih : (∀ a ∈ l, 0 < a) → 0 < l.prod
h : ∀ a_1 ∈ a :: l, 0 < a_1
⊢ 0 < (a :: l).prod

tactic: simp
state_before: case nil
R : Type u_1
inst✝ : StrictOrderedSemiring R
h : ∀ a ∈ [], 0 < a
⊢ 0 < [].prod
state_after: no goals

tactic: rw [prod_cons]
state_before: case cons
R : Type u_1
inst✝ : StrictOrderedSemiring R
a : R
l : List R
ih : (∀ a ∈ l, 0 < a) → 0 < l.prod
h : ∀ a_1 ∈ a :: l, 0 < a_1
⊢ 0 < (a :: l).prod
state_after: case cons
R : Type u_1
inst✝ : StrictOrderedSemiring R
a : R
l : List R
ih : (∀ a ∈ l, 0 < a) → 0 < l.prod
h : ∀ a_1 ∈ a :: l, 0 < a_1
⊢ 0 < a * l.prod

tactic: exact mul_pos (h _ <| mem_cons_self _ _) (ih fun a ha => h a <| mem_cons_of_mem _ ha)
state_before: case cons
R : Type u_1
inst✝ : StrictOrderedSemiring R
a : R
l : List R
ih : (∀ a ∈ l, 0 < a) → 0 < l.prod
h : ∀ a_1 ∈ a :: l, 0 < a_1
⊢ 0 < a * l.prod
state_after: no goals
Theorem: supClosed_univ
File: Mathlib/Order/SupClosed.lean

tactic: simp [SupClosed]
state_before: F : Type u_1
α : Type u_2
β : Type u_3
inst✝¹ : SemilatticeSup α
inst✝ : SemilatticeSup β
ι : Sort u_4
S : Set (Set α)
f : ι → Set α
s t : Set α
a : α
⊢ SupClosed univ
state_after: no goals
Theorem: continuous_zpow
File: Mathlib/Topology/Algebra/Group/Basic.lean

tactic: simpa using continuous_pow n
state_before: G : Type w
H : Type x
α : Type u
β : Type v
inst✝³ : TopologicalSpace G
inst✝² : Group G
inst✝¹ : TopologicalGroup G
inst✝ : TopologicalSpace α
f : α → G
s : Set α
x : α
n : ℕ
⊢ Continuous fun a => a ^ Int.ofNat n
state_after: no goals

tactic: simpa using (continuous_pow (n + 1)).inv
state_before: G : Type w
H : Type x
α : Type u
β : Type v
inst✝³ : TopologicalSpace G
inst✝² : Group G
inst✝¹ : TopologicalGroup G
inst✝ : TopologicalSpace α
f : α → G
s : Set α
x : α
n : ℕ
⊢ Continuous fun a => a ^ Int.negSucc n
state_after: no goals
Theorem: Batteries.RBSet.isEmpty_iff_toList_eq_nil
File: .lake/packages/batteries/Batteries/Data/RBMap/Lemmas.lean

tactic: obtain ⟨⟨⟩, _⟩ := t <;> simp [toList, isEmpty]
state_before: α : Type u_1
cmp : α → α → Ordering
t : RBSet α cmp
⊢ t.isEmpty = true ↔ t.toList = []
state_after: no goals
Theorem: HomotopyCategory.Pretriangulated.rotate_distinguished_triangle'
File: Mathlib/Algebra/Homology/HomotopyCategory/Pretriangulated.lean

tactic: obtain ⟨K, L, φ, ⟨e⟩⟩ := hT
state_before: C : Type u_1
inst✝³ : Category.{u_2, u_1} C
inst✝² : Preadditive C
inst✝¹ : HasZeroObject C
inst✝ : HasBinaryBiproducts C
K L : CochainComplex C ℤ
φ : K ⟶ L
T : Triangle (HomotopyCategory C (ComplexShape.up ℤ))
hT : T ∈ distinguishedTriangles C
⊢ T.rotate ∈ distinguishedTriangles C
state_after: case intro.intro.intro.intro
C : Type u_1
inst✝³ : Category.{u_2, u_1} C
inst✝² : Preadditive C
inst✝¹ : HasZeroObject C
inst✝ : HasBinaryBiproducts C
K✝ L✝ : CochainComplex C ℤ
φ✝ : K✝ ⟶ L✝
T : Triangle (HomotopyCategory C (ComplexShape.up ℤ))
K L : CochainComplex C ℤ
φ : K ⟶ L
e : T ≅ CochainComplex.mappingCone.triangleh φ
⊢ T.rotate ∈ distinguishedTriangles C

tactic: exact ⟨_, _, _, ⟨(rotate _).mapIso e ≪≫ CochainComplex.mappingCone.rotateTrianglehIso φ⟩⟩
state_before: case intro.intro.intro.intro
C : Type u_1
inst✝³ : Category.{u_2, u_1} C
inst✝² : Preadditive C
inst✝¹ : HasZeroObject C
inst✝ : HasBinaryBiproducts C
K✝ L✝ : CochainComplex C ℤ
φ✝ : K✝ ⟶ L✝
T : Triangle (HomotopyCategory C (ComplexShape.up ℤ))
K L : CochainComplex C ℤ
φ : K ⟶ L
e : T ≅ CochainComplex.mappingCone.triangleh φ
⊢ T.rotate ∈ distinguishedTriangles C
state_after: no goals
Theorem: Ordnode.node4L_size
File: Mathlib/Data/Ordmap/Ordset.lean

tactic: cases m <;> simp [node4L, node3L, node'] <;> [abel; (simp [size, hm.1]; abel)]
state_before: α : Type u_1
l : Ordnode α
x : α
m : Ordnode α
y : α
r : Ordnode α
hm : m.Sized
⊢ (l.node4L x m y r).size = l.size + m.size + r.size + 2
state_after: no goals

tactic: simp [size, hm.1]
state_before: case node
α : Type u_1
l : Ordnode α
x y : α
r : Ordnode α
size✝ : ℕ
l✝ : Ordnode α
x✝ : α
r✝ : Ordnode α
hm : (node size✝ l✝ x✝ r✝).Sized
⊢ l.size + l✝.size + 1 + (r✝.size + r.size + 1) = l.size + size✝ + r.size + 1
state_after: case node
α : Type u_1
l : Ordnode α
x y : α
r : Ordnode α
size✝ : ℕ
l✝ : Ordnode α
x✝ : α
r✝ : Ordnode α
hm : (node size✝ l✝ x✝ r✝).Sized
⊢ ((match l with
          | nil => 0
          | node sz l x r => sz) +
          match l✝ with
          | nil => 0
          | node sz l x r => sz) +
        1 +
      (((match r✝ with
          | nil => 0
          | node sz l x r => sz) +
          match r with
          | nil => 0
          | node sz l x r => sz) +
        1) =
    ((match l with
          | nil => 0
          | node sz l x r => sz) +
          (((match l✝ with
              | nil => 0
              | node sz l x r => sz) +
              match r✝ with
              | nil => 0
              | node sz l x r => sz) +
            1) +
        match r with
        | nil => 0
        | node sz l x r => sz) +
      1

tactic: abel
state_before: case node
α : Type u_1
l : Ordnode α
x y : α
r : Ordnode α
size✝ : ℕ
l✝ : Ordnode α
x✝ : α
r✝ : Ordnode α
hm : (node size✝ l✝ x✝ r✝).Sized
⊢ ((match l with
          | nil => 0
          | node sz l x r => sz) +
          match l✝ with
          | nil => 0
          | node sz l x r => sz) +
        1 +
      (((match r✝ with
          | nil => 0
          | node sz l x r => sz) +
          match r with
          | nil => 0
          | node sz l x r => sz) +
        1) =
    ((match l with
          | nil => 0
          | node sz l x r => sz) +
          (((match l✝ with
              | nil => 0
              | node sz l x r => sz) +
              match r✝ with
              | nil => 0
              | node sz l x r => sz) +
            1) +
        match r with
        | nil => 0
        | node sz l x r => sz) +
      1
state_after: no goals
Theorem: lipschitzWith_iff_norm_div_le
File: Mathlib/Analysis/Normed/Group/Uniform.lean

tactic: simp only [lipschitzWith_iff_dist_le_mul, dist_eq_norm_div]
state_before: 𝓕 : Type u_1
α : Type u_2
E : Type u_3
F : Type u_4
inst✝² : SeminormedGroup E
inst✝¹ : SeminormedGroup F
s : Set E
a a₁ a₂ b b₁ b₂ : E
r r₁ r₂ : ℝ
inst✝ : FunLike 𝓕 E F
f : E → F
C : ℝ≥0
⊢ LipschitzWith C f ↔ ∀ (x y : E), ‖f x / f y‖ ≤ ↑C * ‖x / y‖
state_after: no goals
Theorem: Real.volume_pi_Ico_toReal
File: Mathlib/MeasureTheory/Measure/Lebesgue/Basic.lean

tactic: simp only [volume_pi_Ico, ENNReal.toReal_prod, ENNReal.toReal_ofReal (sub_nonneg.2 (h _))]
state_before: ι : Type u_1
inst✝ : Fintype ι
a b : ι → ℝ
h : a ≤ b
⊢ (volume (univ.pi fun i => Ico (a i) (b i))).toReal = ∏ i : ι, (b i - a i)
state_after: no goals
Theorem: Set.Countable.exists_eq_range
File: Mathlib/Data/Set/Countable.lean

tactic: rcases hc.exists_surjective hs with ⟨f, hf⟩
state_before: α : Type u
β : Type v
γ : Type w
ι : Sort x
s : Set α
hc : s.Countable
hs : s.Nonempty
⊢ ∃ f, s = range f
state_after: case intro
α : Type u
β : Type v
γ : Type w
ι : Sort x
s : Set α
hc : s.Countable
hs : s.Nonempty
f : ℕ → ↑s
hf : Surjective f
⊢ ∃ f, s = range f

tactic: refine ⟨(↑) ∘ f, ?_⟩
state_before: case intro
α : Type u
β : Type v
γ : Type w
ι : Sort x
s : Set α
hc : s.Countable
hs : s.Nonempty
f : ℕ → ↑s
hf : Surjective f
⊢ ∃ f, s = range f
state_after: case intro
α : Type u
β : Type v
γ : Type w
ι : Sort x
s : Set α
hc : s.Countable
hs : s.Nonempty
f : ℕ → ↑s
hf : Surjective f
⊢ s = range (Subtype.val ∘ f)

tactic: rw [hf.range_comp, Subtype.range_coe]
state_before: case intro
α : Type u
β : Type v
γ : Type w
ι : Sort x
s : Set α
hc : s.Countable
hs : s.Nonempty
f : ℕ → ↑s
hf : Surjective f
⊢ s = range (Subtype.val ∘ f)
state_after: no goals
Theorem: EisensteinSeries.summand_bound
File: Mathlib/NumberTheory/ModularForms/EisensteinSeries/UniformConvergence.lean

tactic: by_cases hx : x = 0
state_before: z : ℍ
k : ℝ
hk : 0 ≤ k
x : Fin 2 → ℤ
⊢ Complex.abs (↑(x 0) * ↑z + ↑(x 1)) ^ (-k) ≤ r z ^ (-k) * ‖x‖ ^ (-k)
state_after: case pos
z : ℍ
k : ℝ
hk : 0 ≤ k
x : Fin 2 → ℤ
hx : x = 0
⊢ Complex.abs (↑(x 0) * ↑z + ↑(x 1)) ^ (-k) ≤ r z ^ (-k) * ‖x‖ ^ (-k)

case neg
z : ℍ
k : ℝ
hk : 0 ≤ k
x : Fin 2 → ℤ
hx : ¬x = 0
⊢ Complex.abs (↑(x 0) * ↑z + ↑(x 1)) ^ (-k) ≤ r z ^ (-k) * ‖x‖ ^ (-k)

tactic: simp only [hx, Pi.zero_apply, Int.cast_zero, zero_mul, add_zero, ← norm_eq_abs, norm_zero]
state_before: case pos
z : ℍ
k : ℝ
hk : 0 ≤ k
x : Fin 2 → ℤ
hx : x = 0
⊢ Complex.abs (↑(x 0) * ↑z + ↑(x 1)) ^ (-k) ≤ r z ^ (-k) * ‖x‖ ^ (-k)
state_after: case pos
z : ℍ
k : ℝ
hk : 0 ≤ k
x : Fin 2 → ℤ
hx : x = 0
⊢ 0 ^ (-k) ≤ r z ^ (-k) * 0 ^ (-k)

tactic: by_cases h : -k = 0
state_before: case pos
z : ℍ
k : ℝ
hk : 0 ≤ k
x : Fin 2 → ℤ
hx : x = 0
⊢ 0 ^ (-k) ≤ r z ^ (-k) * 0 ^ (-k)
state_after: case pos
z : ℍ
k : ℝ
hk : 0 ≤ k
x : Fin 2 → ℤ
hx : x = 0
h : -k = 0
⊢ 0 ^ (-k) ≤ r z ^ (-k) * 0 ^ (-k)

case neg
z : ℍ
k : ℝ
hk : 0 ≤ k
x : Fin 2 → ℤ
hx : x = 0
h : ¬-k = 0
⊢ 0 ^ (-k) ≤ r z ^ (-k) * 0 ^ (-k)

tactic: rw [h, Real.rpow_zero, Real.rpow_zero, one_mul]
state_before: case pos
z : ℍ
k : ℝ
hk : 0 ≤ k
x : Fin 2 → ℤ
hx : x = 0
h : -k = 0
⊢ 0 ^ (-k) ≤ r z ^ (-k) * 0 ^ (-k)
state_after: no goals

tactic: rw [Real.zero_rpow h, mul_zero]
state_before: case neg
z : ℍ
k : ℝ
hk : 0 ≤ k
x : Fin 2 → ℤ
hx : x = 0
h : ¬-k = 0
⊢ 0 ^ (-k) ≤ r z ^ (-k) * 0 ^ (-k)
state_after: no goals

tactic: rw [← Real.mul_rpow (r_pos _).le (norm_nonneg _)]
state_before: case neg
z : ℍ
k : ℝ
hk : 0 ≤ k
x : Fin 2 → ℤ
hx : ¬x = 0
⊢ Complex.abs (↑(x 0) * ↑z + ↑(x 1)) ^ (-k) ≤ r z ^ (-k) * ‖x‖ ^ (-k)
state_after: case neg
z : ℍ
k : ℝ
hk : 0 ≤ k
x : Fin 2 → ℤ
hx : ¬x = 0
⊢ Complex.abs (↑(x 0) * ↑z + ↑(x 1)) ^ (-k) ≤ (r z * ‖x‖) ^ (-k)

tactic: exact Real.rpow_le_rpow_of_nonpos (mul_pos (r_pos _) (norm_pos_iff.mpr hx)) (r_mul_max_le z hx)
  (neg_nonpos.mpr hk)
state_before: case neg
z : ℍ
k : ℝ
hk : 0 ≤ k
x : Fin 2 → ℤ
hx : ¬x = 0
⊢ Complex.abs (↑(x 0) * ↑z + ↑(x 1)) ^ (-k) ≤ (r z * ‖x‖) ^ (-k)
state_after: no goals
Theorem: ContinuousMultilinearMap.mkPiRing_eq_iff
File: Mathlib/Topology/Algebra/Module/Multilinear/Basic.lean

tactic: rw [← toMultilinearMap_injective.eq_iff]
state_before: R : Type u
ι : Type v
n : ℕ
M✝ : Fin n.succ → Type w
M₁ : ι → Type w₁
M₁' : ι → Type w₁'
M₂ : Type w₂
M₃ : Type w₃
M₄ : Type w₄
M : Type u_1
inst✝⁷ : Fintype ι
inst✝⁶ : CommRing R
inst✝⁵ : AddCommMonoid M
inst✝⁴ : Module R M
inst✝³ : TopologicalSpace R
inst✝² : TopologicalSpace M
inst✝¹ : ContinuousMul R
inst✝ : ContinuousSMul R M
z₁ z₂ : M
⊢ ContinuousMultilinearMap.mkPiRing R ι z₁ = ContinuousMultilinearMap.mkPiRing R ι z₂ ↔ z₁ = z₂
state_after: R : Type u
ι : Type v
n : ℕ
M✝ : Fin n.succ → Type w
M₁ : ι → Type w₁
M₁' : ι → Type w₁'
M₂ : Type w₂
M₃ : Type w₃
M₄ : Type w₄
M : Type u_1
inst✝⁷ : Fintype ι
inst✝⁶ : CommRing R
inst✝⁵ : AddCommMonoid M
inst✝⁴ : Module R M
inst✝³ : TopologicalSpace R
inst✝² : TopologicalSpace M
inst✝¹ : ContinuousMul R
inst✝ : ContinuousSMul R M
z₁ z₂ : M
⊢ (ContinuousMultilinearMap.mkPiRing R ι z₁).toMultilinearMap =
      (ContinuousMultilinearMap.mkPiRing R ι z₂).toMultilinearMap ↔
    z₁ = z₂

tactic: exact MultilinearMap.mkPiRing_eq_iff
state_before: R : Type u
ι : Type v
n : ℕ
M✝ : Fin n.succ → Type w
M₁ : ι → Type w₁
M₁' : ι → Type w₁'
M₂ : Type w₂
M₃ : Type w₃
M₄ : Type w₄
M : Type u_1
inst✝⁷ : Fintype ι
inst✝⁶ : CommRing R
inst✝⁵ : AddCommMonoid M
inst✝⁴ : Module R M
inst✝³ : TopologicalSpace R
inst✝² : TopologicalSpace M
inst✝¹ : ContinuousMul R
inst✝ : ContinuousSMul R M
z₁ z₂ : M
⊢ (ContinuousMultilinearMap.mkPiRing R ι z₁).toMultilinearMap =
      (ContinuousMultilinearMap.mkPiRing R ι z₂).toMultilinearMap ↔
    z₁ = z₂
state_after: no goals
Theorem: Batteries.RBNode.reverse_reverse
File: .lake/packages/batteries/Batteries/Data/RBMap/WF.lean

tactic: induction t <;> simp [*]
state_before: α : Type u_1
t : RBNode α
⊢ t.reverse.reverse = t
state_after: no goals
Theorem: Matroid.dual_coindep_iff
File: Mathlib/Data/Matroid/Dual.lean

tactic: rw [Coindep, dual_dual]
state_before: α : Type u_1
M : Matroid α
I B X : Set α
⊢ M✶.Coindep X ↔ M.Indep X
state_after: no goals
Theorem: LinearMap.polyCharpoly_coeff_nilRankAux_ne_zero
File: Mathlib/Algebra/Module/LinearMap/Polynomial.lean

tactic: apply Polynomial.trailingCoeff_nonzero_iff_nonzero.mpr
state_before: R : Type u_1
L : Type u_2
M : Type u_3
n : Type u_4
ι : Type u_5
ι' : Type u_6
ιM : Type u_7
inst✝¹² : CommRing R
inst✝¹¹ : AddCommGroup L
inst✝¹⁰ : Module R L
inst✝⁹ : AddCommGroup M
inst✝⁸ : Module R M
φ : L →ₗ[R] Module.End R M
inst✝⁷ : Fintype ι
inst✝⁶ : Fintype ι'
inst✝⁵ : Fintype ιM
inst✝⁴ : DecidableEq ι
inst✝³ : DecidableEq ι'
inst✝² : Module.Free R M
inst✝¹ : Module.Finite R M
b : Basis ι R L
inst✝ : Nontrivial R
⊢ (φ.polyCharpoly b).coeff (φ.nilRankAux b) ≠ 0
state_after: R : Type u_1
L : Type u_2
M : Type u_3
n : Type u_4
ι : Type u_5
ι' : Type u_6
ιM : Type u_7
inst✝¹² : CommRing R
inst✝¹¹ : AddCommGroup L
inst✝¹⁰ : Module R L
inst✝⁹ : AddCommGroup M
inst✝⁸ : Module R M
φ : L →ₗ[R] Module.End R M
inst✝⁷ : Fintype ι
inst✝⁶ : Fintype ι'
inst✝⁵ : Fintype ιM
inst✝⁴ : DecidableEq ι
inst✝³ : DecidableEq ι'
inst✝² : Module.Free R M
inst✝¹ : Module.Finite R M
b : Basis ι R L
inst✝ : Nontrivial R
⊢ φ.polyCharpoly b ≠ 0

tactic: apply polyCharpoly_ne_zero
state_before: R : Type u_1
L : Type u_2
M : Type u_3
n : Type u_4
ι : Type u_5
ι' : Type u_6
ιM : Type u_7
inst✝¹² : CommRing R
inst✝¹¹ : AddCommGroup L
inst✝¹⁰ : Module R L
inst✝⁹ : AddCommGroup M
inst✝⁸ : Module R M
φ : L →ₗ[R] Module.End R M
inst✝⁷ : Fintype ι
inst✝⁶ : Fintype ι'
inst✝⁵ : Fintype ιM
inst✝⁴ : DecidableEq ι
inst✝³ : DecidableEq ι'
inst✝² : Module.Free R M
inst✝¹ : Module.Finite R M
b : Basis ι R L
inst✝ : Nontrivial R
⊢ φ.polyCharpoly b ≠ 0
state_after: no goals