ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: LinearMap.iterateMapComap_le_succ
File: Mathlib/Algebra/Module/Submodule/IterateMapComap.lean

Proof steps:
state_before: R : Type u_1
N : Type u_2
M : Type u_3
inst✝⁴ : Semiring R
inst✝³ : AddCommMonoid N
inst✝² : Module R N
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
f i : N →ₗ[R] M
K : Submodule R N
h : map f K ≤ map i K
n : ℕ
⊢ f.iterateMapComap i n K ≤ f.iterateMapComap i (n + 1) K
state_after: R : Type u_1
N : Type u_2
M : Type u_3
inst✝⁴ : Semiring R
inst✝³ : AddCommMonoid N
inst✝² : Module R N
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
f i : N →ₗ[R] M
K : Submodule R N
h : map f K ≤ map i K
n : ℕ
⊢ f.iterateMapComap i n K ≤ (fun K => comap f (map i K))^[n + 1] K
tactic: nth_rw 2 [iterateMapComap]
state_before: R : Type u_1
N : Type u_2
M : Type u_3
inst✝⁴ : Semiring R
inst✝³ : AddCommMonoid N
inst✝² : Module R N
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
f i : N →ₗ[R] M
K : Submodule R N
h : map f K ≤ map i K
n : ℕ
⊢ f.iterateMapComap i n K ≤ (fun K => comap f (map i K))^[n + 1] K
state_after: R : Type u_1
N : Type u_2
M : Type u_3
inst✝⁴ : Semiring R
inst✝³ : AddCommMonoid N
inst✝² : Module R N
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
f i : N →ₗ[R] M
K : Submodule R N
h : map f K ≤ map i K
n : ℕ
⊢ map f (f.iterateMapComap i n K) ≤ map i (f.iterateMapComap i n K)
tactic: rw [iterate_succ', Function.comp_apply, ← iterateMapComap, ← map_le_iff_le_comap]
state_before: R : Type u_1
N : Type u_2
M : Type u_3
inst✝⁴ : Semiring R
inst✝³ : AddCommMonoid N
inst✝² : Module R N
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
f i : N →ₗ[R] M
K : Submodule R N
h : map f K ≤ map i K
n : ℕ
⊢ map f (f.iterateMapComap i n K) ≤ map i (f.iterateMapComap i n K)
state_after: no goals
tactic: induction n with
  | zero => exact h
  | succ n ih =>
    simp_rw [iterateMapComap, iterate_succ', Function.comp_apply]
    calc
      _ ≤ (f.iterateMapComap i n K).map i := map_comap_le _ _
      _ ≤ (((f.iterateMapComap i n K).map f).comap f).map i := map_mono (le_comap_map _ _)
      _ ≤ _ := map_mono (comap_mono ih)
Theorem: Basis.mk_eq_rank
File: Mathlib/LinearAlgebra/Dimension/StrongRankCondition.lean

Proof steps:
state_before: R : Type u
M : Type v
inst✝³ : Ring R
inst✝² : AddCommGroup M
inst✝¹ : Module R M
ι : Type w
ι' : Type w'
inst✝ : StrongRankCondition R
v : Basis ι R M
⊢ lift.{v, w} #ι = lift.{w, v} (Module.rank R M)
state_after: R : Type u
M : Type v
inst✝³ : Ring R
inst✝² : AddCommGroup M
inst✝¹ : Module R M
ι : Type w
ι' : Type w'
inst✝ : StrongRankCondition R
v : Basis ι R M
this : Nontrivial R
⊢ lift.{v, w} #ι = lift.{w, v} (Module.rank R M)
tactic: haveI := nontrivial_of_invariantBasisNumber R
state_before: R : Type u
M : Type v
inst✝³ : Ring R
inst✝² : AddCommGroup M
inst✝¹ : Module R M
ι : Type w
ι' : Type w'
inst✝ : StrongRankCondition R
v : Basis ι R M
this : Nontrivial R
⊢ lift.{v, w} #ι = lift.{w, v} (Module.rank R M)
state_after: no goals
tactic: rw [← v.mk_range_eq_rank, Cardinal.mk_range_eq_of_injective v.injective]
Theorem: summable_iff_tsum_vanishing
File: Mathlib/Topology/Algebra/InfiniteSum/Group.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝³ : CommGroup α
inst✝² : UniformSpace α
inst✝¹ : UniformGroup α
f g : β → α
a a₁ a₂ : α
inst✝ : CompleteSpace α
⊢ Multipliable f ↔ ∀ e ∈ 𝓝 1, ∃ s, ∀ (t : Set β), Disjoint t ↑s → ∏' (b : ↑t), f ↑b ∈ e
state_after: no goals
tactic: rw [multipliable_iff_cauchySeq_finset, cauchySeq_finset_iff_tprod_vanishing]
Theorem: SimpleGraph.cliqueFreeOn_univ
File: Mathlib/Combinatorics/SimpleGraph/Clique.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
G H : SimpleGraph α
s s₁ s₂ : Set α
t : Finset α
a b : α
m n : ℕ
⊢ G.CliqueFreeOn Set.univ n ↔ G.CliqueFree n
state_after: no goals
tactic: simp [CliqueFree, CliqueFreeOn]
Theorem: Real.log_div_self_antitoneOn
File: Mathlib/Analysis/SpecialFunctions/Log/Monotone.lean

Proof steps:
state_before: x y : ℝ
⊢ AntitoneOn (fun x => log x / x) {x | rexp 1 ≤ x}
state_after: x y : ℝ
⊢ ∀ ⦃a : ℝ⦄, rexp 1 ≤ a → ∀ ⦃b : ℝ⦄, rexp 1 ≤ b → a ≤ b → log b / b ≤ log a / a
tactic: simp only [AntitoneOn, mem_setOf_eq]
state_before: x y : ℝ
⊢ ∀ ⦃a : ℝ⦄, rexp 1 ≤ a → ∀ ⦃b : ℝ⦄, rexp 1 ≤ b → a ≤ b → log b / b ≤ log a / a
state_after: x✝ y✝ x : ℝ
hex : rexp 1 ≤ x
y : ℝ
hey : rexp 1 ≤ y
hxy : x ≤ y
⊢ log y / y ≤ log x / x
tactic: intro x hex y hey hxy
state_before: x✝ y✝ x : ℝ
hex : rexp 1 ≤ x
y : ℝ
hey : rexp 1 ≤ y
hxy : x ≤ y
⊢ log y / y ≤ log x / x
state_after: x✝ y✝ x : ℝ
hex : rexp 1 ≤ x
y : ℝ
hey : rexp 1 ≤ y
hxy : x ≤ y
x_pos : 0 < x
⊢ log y / y ≤ log x / x
tactic: have x_pos : 0 < x := (exp_pos 1).trans_le hex
state_before: x✝ y✝ x : ℝ
hex : rexp 1 ≤ x
y : ℝ
hey : rexp 1 ≤ y
hxy : x ≤ y
x_pos : 0 < x
⊢ log y / y ≤ log x / x
state_after: x✝ y✝ x : ℝ
hex : rexp 1 ≤ x
y : ℝ
hey : rexp 1 ≤ y
hxy : x ≤ y
x_pos : 0 < x
y_pos : 0 < y
⊢ log y / y ≤ log x / x
tactic: have y_pos : 0 < y := (exp_pos 1).trans_le hey
state_before: x✝ y✝ x : ℝ
hex : rexp 1 ≤ x
y : ℝ
hey : rexp 1 ≤ y
hxy : x ≤ y
x_pos : 0 < x
y_pos : 0 < y
⊢ log y / y ≤ log x / x
state_after: x✝ y✝ x : ℝ
hex : rexp 1 ≤ x
y : ℝ
hey : rexp 1 ≤ y
hxy : x ≤ y
x_pos : 0 < x
y_pos : 0 < y
hlogx : 1 ≤ log x
⊢ log y / y ≤ log x / x
tactic: have hlogx : 1 ≤ log x := by rwa [le_log_iff_exp_le x_pos]
state_before: x✝ y✝ x : ℝ
hex : rexp 1 ≤ x
y : ℝ
hey : rexp 1 ≤ y
hxy : x ≤ y
x_pos : 0 < x
y_pos : 0 < y
hlogx : 1 ≤ log x
⊢ log y / y ≤ log x / x
state_after: x✝ y✝ x : ℝ
hex : rexp 1 ≤ x
y : ℝ
hey : rexp 1 ≤ y
hxy : x ≤ y
x_pos : 0 < x
y_pos : 0 < y
hlogx : 1 ≤ log x
hyx : 0 ≤ y / x - 1
⊢ log y / y ≤ log x / x
tactic: have hyx : 0 ≤ y / x - 1 := by rwa [le_sub_iff_add_le, le_div_iff x_pos, zero_add, one_mul]
state_before: x✝ y✝ x : ℝ
hex : rexp 1 ≤ x
y : ℝ
hey : rexp 1 ≤ y
hxy : x ≤ y
x_pos : 0 < x
y_pos : 0 < y
hlogx : 1 ≤ log x
hyx : 0 ≤ y / x - 1
⊢ log y / y ≤ log x / x
state_after: x✝ y✝ x : ℝ
hex : rexp 1 ≤ x
y : ℝ
hey : rexp 1 ≤ y
hxy : x ≤ y
x_pos : 0 < x
y_pos : 0 < y
hlogx : 1 ≤ log x
hyx : 0 ≤ y / x - 1
⊢ log y - log x ≤ log x / x * y - log x
tactic: rw [div_le_iff y_pos, ← sub_le_sub_iff_right (log x)]
state_before: x✝ y✝ x : ℝ
hex : rexp 1 ≤ x
y : ℝ
hey : rexp 1 ≤ y
hxy : x ≤ y
x_pos : 0 < x
y_pos : 0 < y
hlogx : 1 ≤ log x
hyx : 0 ≤ y / x - 1
⊢ log y - log x ≤ log x / x * y - log x
state_after: no goals
tactic: calc
    log y - log x = log (y / x) := by rw [log_div y_pos.ne' x_pos.ne']
    _ ≤ y / x - 1 := log_le_sub_one_of_pos (div_pos y_pos x_pos)
    _ ≤ log x * (y / x - 1) := le_mul_of_one_le_left hyx hlogx
    _ = log x / x * y - log x := by ring
Theorem: CategoryTheory.Limits.inr_coprodZeroIso_hom
File: Mathlib/CategoryTheory/Limits/Constructions/ZeroObjects.lean

Proof steps:
state_before: C : Type u_1
inst✝² : Category.{u_2, u_1} C
inst✝¹ : HasZeroObject C
inst✝ : HasZeroMorphisms C
X : C
⊢ coprod.inl ≫ (coprodZeroIso X).hom = 𝟙 X
state_after: C : Type u_1
inst✝² : Category.{u_2, u_1} C
inst✝¹ : HasZeroObject C
inst✝ : HasZeroMorphisms C
X : C
⊢ coprod.inl ≫
      (colimit.isoColimitCocone
          { cocone := BinaryCofan.mk (𝟙 X) 0, isColimit := binaryCofanZeroRightIsColimit X }).hom =
    𝟙 X
tactic: dsimp [coprodZeroIso, binaryCofanZeroRight]
state_before: C : Type u_1
inst✝² : Category.{u_2, u_1} C
inst✝¹ : HasZeroObject C
inst✝ : HasZeroMorphisms C
X : C
⊢ coprod.inl ≫
      (colimit.isoColimitCocone
          { cocone := BinaryCofan.mk (𝟙 X) 0, isColimit := binaryCofanZeroRightIsColimit X }).hom =
    𝟙 X
state_after: no goals
tactic: simp
Theorem: compl_le_self
File: Mathlib/Order/BooleanAlgebra.lean

Proof steps:
state_before: α : Type u
β : Type u_1
w x y z : α
inst✝ : BooleanAlgebra α
⊢ xᶜ ≤ x ↔ x = ⊤
state_after: no goals
tactic: simpa using le_compl_self (a := xᶜ)
Theorem: CliffordAlgebraQuaternion.ofQuaternion_star
File: Mathlib/LinearAlgebra/CliffordAlgebra/Equivs.lean

Proof steps:
state_before: R : Type u_1
inst✝ : CommRing R
c₁ c₂ : R
q : ℍ[R,c₁,c₂]
⊢ CliffordAlgebraQuaternion.equiv (ofQuaternion (star q)) = CliffordAlgebraQuaternion.equiv (star (ofQuaternion q))
state_after: no goals
tactic: rw [equiv_apply, equiv_apply, toQuaternion_star, toQuaternion_ofQuaternion,
      toQuaternion_ofQuaternion]
Theorem: Mon_.whiskerLeft_hom
File: Mathlib/CategoryTheory/Monoidal/Mon_.lean

Proof steps:
state_before: C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
X Y : Mon_ C
f : X ⟶ Y
Z : Mon_ C
⊢ (f ▷ Z).hom = f.hom ▷ Z.X
state_after: C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
X Y : Mon_ C
f : X ⟶ Y
Z : Mon_ C
⊢ (f ▷ Z).hom = f.hom ⊗ 𝟙 Z.X
tactic: rw [← tensorHom_id]
state_before: C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
X Y : Mon_ C
f : X ⟶ Y
Z : Mon_ C
⊢ (f ▷ Z).hom = f.hom ⊗ 𝟙 Z.X
state_after: no goals
tactic: rfl
Theorem: ProbabilityTheory.Kernel.compProd_of_not_isSFiniteKernel_right
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 γ
s : Set (β × γ)
κ : Kernel α β
η : Kernel (α × β) γ
h : ¬IsSFiniteKernel η
⊢ κ ⊗ₖ η = 0
state_after: case hnc
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
s : Set (β × γ)
κ : Kernel α β
η : Kernel (α × β) γ
h : ¬IsSFiniteKernel η
⊢ ¬(IsSFiniteKernel κ ∧ IsSFiniteKernel η)
tactic: rw [compProd, dif_neg]
state_before: case hnc
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
s : Set (β × γ)
κ : Kernel α β
η : Kernel (α × β) γ
h : ¬IsSFiniteKernel η
⊢ ¬(IsSFiniteKernel κ ∧ IsSFiniteKernel η)
state_after: no goals
tactic: simp [h]
Theorem: matPolyEquiv_map_smul
File: Mathlib/RingTheory/PolynomialAlgebra.lean

Proof steps:
state_before: R : Type u_1
A : Type u_2
inst✝⁴ : CommSemiring R
inst✝³ : Semiring A
inst✝² : Algebra R A
n : Type w
inst✝¹ : DecidableEq n
inst✝ : Fintype n
p : R[X]
M : Matrix n n R[X]
⊢ matPolyEquiv (p • M) = Polynomial.map (algebraMap R (Matrix n n R)) p * matPolyEquiv M
state_after: no goals
tactic: rw [← one_mul M, ← smul_mul_assoc, _root_.map_mul, matPolyEquiv_smul_one, one_mul]
Theorem: AddCircle.addOrderOf_coe_rat
File: Mathlib/Topology/Instances/AddCircle.lean

Proof steps:
state_before: 𝕜 : Type u_1
B : Type u_2
inst✝² : LinearOrderedField 𝕜
inst✝¹ : TopologicalSpace 𝕜
inst✝ : OrderTopology 𝕜
p q✝ : 𝕜
hp : Fact (0 < p)
q : ℚ
⊢ addOrderOf ↑(↑q * p) = q.den
state_after: 𝕜 : Type u_1
B : Type u_2
inst✝² : LinearOrderedField 𝕜
inst✝¹ : TopologicalSpace 𝕜
inst✝ : OrderTopology 𝕜
p q✝ : 𝕜
hp : Fact (0 < p)
q : ℚ
this : ↑↑q.den ≠ 0
⊢ addOrderOf ↑(↑q * p) = q.den
tactic: have : (↑(q.den : ℤ) : 𝕜) ≠ 0 := by
    norm_cast
    exact q.pos.ne.symm
state_before: 𝕜 : Type u_1
B : Type u_2
inst✝² : LinearOrderedField 𝕜
inst✝¹ : TopologicalSpace 𝕜
inst✝ : OrderTopology 𝕜
p q✝ : 𝕜
hp : Fact (0 < p)
q : ℚ
this : ↑↑q.den ≠ 0
⊢ addOrderOf ↑(↑q * p) = q.den
state_after: no goals
tactic: rw [← q.num_divInt_den, Rat.cast_divInt_of_ne_zero _ this, Int.cast_natCast, Rat.num_divInt_den,
    addOrderOf_div_of_gcd_eq_one' q.pos q.reduced]
Theorem: MeasureTheory.FiniteMeasure.map_apply_of_aemeasurable
File: Mathlib/MeasureTheory/Measure/FiniteMeasure.lean

Proof steps:
state_before: Ω : Type u_1
Ω' : Type u_2
inst✝¹ : MeasurableSpace Ω
inst✝ : MeasurableSpace Ω'
ν : FiniteMeasure Ω
f : Ω → Ω'
f_aemble : AEMeasurable f ↑ν
A : Set Ω'
A_mble : MeasurableSet A
⊢ (ν.map f) A = ν (f ⁻¹' A)
state_after: Ω : Type u_1
Ω' : Type u_2
inst✝¹ : MeasurableSpace Ω
inst✝ : MeasurableSpace Ω'
ν : FiniteMeasure Ω
f : Ω → Ω'
f_aemble : AEMeasurable f ↑ν
A : Set Ω'
A_mble : MeasurableSet A
this : ↑(ν.map f) A = ↑ν (f ⁻¹' A)
⊢ (ν.map f) A = ν (f ⁻¹' A)
tactic: have := ν.map_apply' f_aemble A_mble
state_before: Ω : Type u_1
Ω' : Type u_2
inst✝¹ : MeasurableSpace Ω
inst✝ : MeasurableSpace Ω'
ν : FiniteMeasure Ω
f : Ω → Ω'
f_aemble : AEMeasurable f ↑ν
A : Set Ω'
A_mble : MeasurableSet A
this : ↑(ν.map f) A = ↑ν (f ⁻¹' A)
⊢ (ν.map f) A = ν (f ⁻¹' A)
state_after: no goals
tactic: exact (ENNReal.toNNReal_eq_toNNReal_iff' (measure_ne_top _ _) (measure_ne_top _ _)).mpr this
Theorem: Monotone.seq_le_seq
File: Mathlib/Order/Iterate.lean

Proof steps:
state_before: α : Type u_1
inst✝ : Preorder α
f : α → α
x y : ℕ → α
hf : Monotone f
n : ℕ
h₀ : x 0 ≤ y 0
hx : ∀ (k : ℕ), k < n → x (k + 1) ≤ f (x k)
hy : ∀ (k : ℕ), k < n → f (y k) ≤ y (k + 1)
⊢ x n ≤ y n
state_after: case zero
α : Type u_1
inst✝ : Preorder α
f : α → α
x y : ℕ → α
hf : Monotone f
h₀ : x 0 ≤ y 0
hx : ∀ (k : ℕ), k < 0 → x (k + 1) ≤ f (x k)
hy : ∀ (k : ℕ), k < 0 → f (y k) ≤ y (k + 1)
⊢ x 0 ≤ y 0

case succ
α : Type u_1
inst✝ : Preorder α
f : α → α
x y : ℕ → α
hf : Monotone f
h₀ : x 0 ≤ y 0
n : ℕ
ihn : (∀ (k : ℕ), k < n → x (k + 1) ≤ f (x k)) → (∀ (k : ℕ), k < n → f (y k) ≤ y (k + 1)) → x n ≤ y n
hx : ∀ (k : ℕ), k < n + 1 → x (k + 1) ≤ f (x k)
hy : ∀ (k : ℕ), k < n + 1 → f (y k) ≤ y (k + 1)
⊢ x (n + 1) ≤ y (n + 1)
tactic: induction' n with n ihn
Theorem: IsClosed.mul_right_of_isCompact
File: Mathlib/Topology/Algebra/Group/Basic.lean

Proof steps:
state_before: G : Type w
H : Type x
α : Type u
β : Type v
inst✝² : TopologicalSpace G
inst✝¹ : Group G
inst✝ : TopologicalGroup G
s t : Set G
ht : IsClosed t
hs : IsCompact s
⊢ IsClosed (t * s)
state_after: G : Type w
H : Type x
α : Type u
β : Type v
inst✝² : TopologicalSpace G
inst✝¹ : Group G
inst✝ : TopologicalGroup G
s t : Set G
ht : IsClosed t
hs : IsCompact s
⊢ IsClosed (op '' s • t)
tactic: rw [← image_op_smul]
state_before: G : Type w
H : Type x
α : Type u
β : Type v
inst✝² : TopologicalSpace G
inst✝¹ : Group G
inst✝ : TopologicalGroup G
s t : Set G
ht : IsClosed t
hs : IsCompact s
⊢ IsClosed (op '' s • t)
state_after: no goals
tactic: exact IsClosed.smul_left_of_isCompact ht (hs.image continuous_op)
Theorem: SeparationQuotient.tendsto_lift₂_nhds
File: Mathlib/Topology/Inseparable.lean

Proof steps:
state_before: X : Type u_1
Y : Type u_2
Z : Type u_3
α : Type u_4
ι : Type u_5
π : ι → Type u_6
inst✝³ : TopologicalSpace X
inst✝² : TopologicalSpace Y
inst✝¹ : TopologicalSpace Z
inst✝ : (i : ι) → TopologicalSpace (π i)
x✝ y✝ z : X
s : Set X
f✝ g : X → Y
t : Set (SeparationQuotient X)
f : X → Y → α
hf : ∀ (a : X) (b : Y) (c : X) (d : Y), (a ~ᵢ c) → (b ~ᵢ d) → f a b = f c d
x : X
y : Y
l : Filter α
⊢ Tendsto (uncurry (lift₂ f hf)) (𝓝 (mk x, mk y)) l ↔ Tendsto (uncurry f) (𝓝 (x, y)) l
state_after: X : Type u_1
Y : Type u_2
Z : Type u_3
α : Type u_4
ι : Type u_5
π : ι → Type u_6
inst✝³ : TopologicalSpace X
inst✝² : TopologicalSpace Y
inst✝¹ : TopologicalSpace Z
inst✝ : (i : ι) → TopologicalSpace (π i)
x✝ y✝ z : X
s : Set X
f✝ g : X → Y
t : Set (SeparationQuotient X)
f : X → Y → α
hf : ∀ (a : X) (b : Y) (c : X) (d : Y), (a ~ᵢ c) → (b ~ᵢ d) → f a b = f c d
x : X
y : Y
l : Filter α
⊢ Tendsto (uncurry (lift₂ f hf) ∘ Prod.map mk mk) (𝓝 (x, y)) l ↔ Tendsto (uncurry f) (𝓝 (x, y)) l
tactic: rw [← map_prod_map_mk_nhds, tendsto_map'_iff]
state_before: X : Type u_1
Y : Type u_2
Z : Type u_3
α : Type u_4
ι : Type u_5
π : ι → Type u_6
inst✝³ : TopologicalSpace X
inst✝² : TopologicalSpace Y
inst✝¹ : TopologicalSpace Z
inst✝ : (i : ι) → TopologicalSpace (π i)
x✝ y✝ z : X
s : Set X
f✝ g : X → Y
t : Set (SeparationQuotient X)
f : X → Y → α
hf : ∀ (a : X) (b : Y) (c : X) (d : Y), (a ~ᵢ c) → (b ~ᵢ d) → f a b = f c d
x : X
y : Y
l : Filter α
⊢ Tendsto (uncurry (lift₂ f hf) ∘ Prod.map mk mk) (𝓝 (x, y)) l ↔ Tendsto (uncurry f) (𝓝 (x, y)) l
state_after: no goals
tactic: rfl
Theorem: Isometry.preimage_emetric_closedBall
File: Mathlib/Topology/MetricSpace/Isometry.lean

Proof steps:
state_before: ι : Type u_1
α : Type u
β : Type v
γ : Type w
inst✝² : PseudoEMetricSpace α
inst✝¹ : PseudoEMetricSpace β
inst✝ : PseudoEMetricSpace γ
f : α → β
x✝ y z : α
s : Set α
h : Isometry f
x : α
r : ℝ≥0∞
⊢ f ⁻¹' EMetric.closedBall (f x) r = EMetric.closedBall x r
state_after: case h
ι : Type u_1
α : Type u
β : Type v
γ : Type w
inst✝² : PseudoEMetricSpace α
inst✝¹ : PseudoEMetricSpace β
inst✝ : PseudoEMetricSpace γ
f : α → β
x✝ y✝ z : α
s : Set α
h : Isometry f
x : α
r : ℝ≥0∞
y : α
⊢ y ∈ f ⁻¹' EMetric.closedBall (f x) r ↔ y ∈ EMetric.closedBall x r
tactic: ext y
state_before: case h
ι : Type u_1
α : Type u
β : Type v
γ : Type w
inst✝² : PseudoEMetricSpace α
inst✝¹ : PseudoEMetricSpace β
inst✝ : PseudoEMetricSpace γ
f : α → β
x✝ y✝ z : α
s : Set α
h : Isometry f
x : α
r : ℝ≥0∞
y : α
⊢ y ∈ f ⁻¹' EMetric.closedBall (f x) r ↔ y ∈ EMetric.closedBall x r
state_after: no goals
tactic: simp [h.edist_eq]
Theorem: IsLocalization.coeSubmodule_span_singleton
File: Mathlib/RingTheory/Localization/Submodule.lean

Proof steps:
state_before: R : Type u_1
inst✝³ : CommRing R
M : Submonoid R
S : Type u_2
inst✝² : CommRing S
inst✝¹ : Algebra R S
P : Type u_3
inst✝ : CommRing P
x : R
⊢ coeSubmodule S (Ideal.span {x}) = Submodule.span R {(algebraMap R S) x}
state_after: no goals
tactic: rw [coeSubmodule_span, Set.image_singleton]
Theorem: AlgebraicGeometry.PresheafedSpace.IsOpenImmersion.ofRestrict_invApp
File: Mathlib/Geometry/RingedSpace/OpenImmersion.lean

Proof steps:
state_before: C✝ : Type u
inst✝¹ : Category.{v, u} C✝
X✝ Y✝ : PresheafedSpace C✝
f✝ : X✝ ⟶ Y✝
H : IsOpenImmersion f✝
C : Type u_1
inst✝ : Category.{u_2, u_1} C
X : PresheafedSpace C
Y : TopCat
f : Y ⟶ TopCat.of ↑↑X
h : OpenEmbedding ⇑f
U : Opens ↑↑(X.restrict h)
⊢ invApp (X.ofRestrict h) U = 𝟙 ((X.restrict h).presheaf.obj (op U))
state_after: C✝ : Type u
inst✝¹ : Category.{v, u} C✝
X✝ Y✝ : PresheafedSpace C✝
f✝ : X✝ ⟶ Y✝
H : IsOpenImmersion f✝
C : Type u_1
inst✝ : Category.{u_2, u_1} C
X : PresheafedSpace C
Y : TopCat
f : Y ⟶ TopCat.of ↑↑X
h : OpenEmbedding ⇑f
U : Opens ↑↑(X.restrict h)
⊢ (X.restrict h).presheaf.map (eqToHom ⋯) ≫ inv ((X.ofRestrict h).c.app (op ((opensFunctor (X.ofRestrict h)).obj U))) =
    𝟙 ((X.restrict h).presheaf.obj (op U))
tactic: delta invApp
state_before: C✝ : Type u
inst✝¹ : Category.{v, u} C✝
X✝ Y✝ : PresheafedSpace C✝
f✝ : X✝ ⟶ Y✝
H : IsOpenImmersion f✝
C : Type u_1
inst✝ : Category.{u_2, u_1} C
X : PresheafedSpace C
Y : TopCat
f : Y ⟶ TopCat.of ↑↑X
h : OpenEmbedding ⇑f
U : Opens ↑↑(X.restrict h)
⊢ (X.restrict h).presheaf.map (eqToHom ⋯) ≫ inv ((X.ofRestrict h).c.app (op ((opensFunctor (X.ofRestrict h)).obj U))) =
    𝟙 ((X.restrict h).presheaf.obj (op U))
state_after: C✝ : Type u
inst✝¹ : Category.{v, u} C✝
X✝ Y✝ : PresheafedSpace C✝
f✝ : X✝ ⟶ Y✝
H : IsOpenImmersion f✝
C : Type u_1
inst✝ : Category.{u_2, u_1} C
X : PresheafedSpace C
Y : TopCat
f : Y ⟶ TopCat.of ↑↑X
h : OpenEmbedding ⇑f
U : Opens ↑↑(X.restrict h)
⊢ (X.restrict h).presheaf.map (eqToHom ⋯) = (X.ofRestrict h).c.app (op ((opensFunctor (X.ofRestrict h)).obj U))
tactic: rw [IsIso.comp_inv_eq, Category.id_comp]
state_before: C✝ : Type u
inst✝¹ : Category.{v, u} C✝
X✝ Y✝ : PresheafedSpace C✝
f✝ : X✝ ⟶ Y✝
H : IsOpenImmersion f✝
C : Type u_1
inst✝ : Category.{u_2, u_1} C
X : PresheafedSpace C
Y : TopCat
f : Y ⟶ TopCat.of ↑↑X
h : OpenEmbedding ⇑f
U : Opens ↑↑(X.restrict h)
⊢ (X.restrict h).presheaf.map (eqToHom ⋯) = (X.ofRestrict h).c.app (op ((opensFunctor (X.ofRestrict h)).obj U))
state_after: C✝ : Type u
inst✝¹ : Category.{v, u} C✝
X✝ Y✝ : PresheafedSpace C✝
f✝ : X✝ ⟶ Y✝
H : IsOpenImmersion f✝
C : Type u_1
inst✝ : Category.{u_2, u_1} C
X : PresheafedSpace C
Y : TopCat
f : Y ⟶ TopCat.of ↑↑X
h : OpenEmbedding ⇑f
U : Opens ↑↑(X.restrict h)
⊢ X.presheaf.map (⋯.functor.op.map (eqToHom ⋯)) =
    X.presheaf.map (⋯.adjunction.counit.app (unop (op ((opensFunctor (X.ofRestrict h)).obj U)))).op
tactic: change X.presheaf.map _ = X.presheaf.map _
state_before: C✝ : Type u
inst✝¹ : Category.{v, u} C✝
X✝ Y✝ : PresheafedSpace C✝
f✝ : X✝ ⟶ Y✝
H : IsOpenImmersion f✝
C : Type u_1
inst✝ : Category.{u_2, u_1} C
X : PresheafedSpace C
Y : TopCat
f : Y ⟶ TopCat.of ↑↑X
h : OpenEmbedding ⇑f
U : Opens ↑↑(X.restrict h)
⊢ X.presheaf.map (⋯.functor.op.map (eqToHom ⋯)) =
    X.presheaf.map (⋯.adjunction.counit.app (unop (op ((opensFunctor (X.ofRestrict h)).obj U)))).op
state_after: no goals
tactic: congr 1
Theorem: Nat.Coprime.eq_one_of_dvd
File: .lake/packages/batteries/Batteries/Data/Nat/Gcd.lean

Proof steps:
state_before: k m : Nat
H : k.Coprime m
d : k ∣ m
⊢ k = 1
state_after: no goals
tactic: rw [← H.gcd_eq_one, gcd_eq_left d]
Theorem: Nat.nth_eq_zero_mono
File: Mathlib/Data/Nat/Nth.lean

Proof steps:
state_before: p : ℕ → Prop
h₀ : ¬p 0
a b : ℕ
hab : a ≤ b
ha : nth p a = 0
⊢ nth p b = 0
state_after: p : ℕ → Prop
h₀ : ¬p 0
a b : ℕ
hab : a ≤ b
ha : ∃ (hf : (setOf p).Finite), hf.toFinset.card ≤ a
⊢ ∃ (hf : (setOf p).Finite), hf.toFinset.card ≤ b
tactic: simp only [nth_eq_zero, h₀, false_and_iff, false_or_iff] at ha ⊢
state_before: p : ℕ → Prop
h₀ : ¬p 0
a b : ℕ
hab : a ≤ b
ha : ∃ (hf : (setOf p).Finite), hf.toFinset.card ≤ a
⊢ ∃ (hf : (setOf p).Finite), hf.toFinset.card ≤ b
state_after: no goals
tactic: exact ha.imp fun hf hle => hle.trans hab
Theorem: EuclideanGeometry.dist_center_eq_dist_center_of_mem_sphere'
File: Mathlib/Geometry/Euclidean/Sphere/Basic.lean

Proof steps:
state_before: V : Type u_1
P : Type u_2
inst✝ : MetricSpace P
p₁ p₂ : P
s : Sphere P
hp₁ : p₁ ∈ s
hp₂ : p₂ ∈ s
⊢ dist s.center p₁ = dist s.center p₂
state_after: no goals
tactic: rw [mem_sphere'.1 hp₁, mem_sphere'.1 hp₂]
Theorem: Set.projIcc_eq_left
File: Mathlib/Order/Interval/Set/ProjIcc.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝ : LinearOrder α
a b : α
h✝ : a ≤ b
x : α
h : a < b
⊢ projIcc a b ⋯ x = ⟨a, ⋯⟩ ↔ x ≤ a
state_after: no goals
tactic: simp [projIcc, Subtype.ext_iff, h.not_le]
Theorem: integral_sin_mul_cos_sq
File: Mathlib/Analysis/SpecialFunctions/Integrals.lean

Proof steps:
state_before: a b : ℝ
n : ℕ
⊢ ∫ (x : ℝ) in a..b, sin x * cos x ^ 2 = (cos a ^ 3 - cos b ^ 3) / 3
state_after: a b : ℝ
n : ℕ
this : ∫ (x : ℝ) in a..b, sin x ^ (2 * 0 + 1) * cos x ^ 2 = ∫ (u : ℝ) in cos b..cos a, u ^ 2 * (1 - u ^ 2) ^ 0
⊢ ∫ (x : ℝ) in a..b, sin x * cos x ^ 2 = (cos a ^ 3 - cos b ^ 3) / 3
tactic: have := @integral_sin_pow_odd_mul_cos_pow a b 0 2
state_before: a b : ℝ
n : ℕ
this : ∫ (x : ℝ) in a..b, sin x ^ (2 * 0 + 1) * cos x ^ 2 = ∫ (u : ℝ) in cos b..cos a, u ^ 2 * (1 - u ^ 2) ^ 0
⊢ ∫ (x : ℝ) in a..b, sin x * cos x ^ 2 = (cos a ^ 3 - cos b ^ 3) / 3
state_after: a b : ℝ
n : ℕ
this : ∫ (x : ℝ) in a..b, sin x * cos x ^ 2 = (cos a ^ 3 - cos b ^ 3) / 3
⊢ ∫ (x : ℝ) in a..b, sin x * cos x ^ 2 = (cos a ^ 3 - cos b ^ 3) / 3
tactic: norm_num at this
state_before: a b : ℝ
n : ℕ
this : ∫ (x : ℝ) in a..b, sin x * cos x ^ 2 = (cos a ^ 3 - cos b ^ 3) / 3
⊢ ∫ (x : ℝ) in a..b, sin x * cos x ^ 2 = (cos a ^ 3 - cos b ^ 3) / 3
state_after: no goals
tactic: exact this
Theorem: Mathlib.Meta.NormNum.isInt_ediv
File: Mathlib/Tactic/NormNum/DivMod.lean

Proof steps:
state_before: a b q m a' : ℤ
b' r : ℕ
ha : IsInt a a'
hb : IsNat b b'
hm : q * ↑b' = m
h : ↑r + m = a'
h₂ : r.blt b' = true
⊢ a / b = ↑q
state_after: case mk.mk
a q m : ℤ
b' r : ℕ
hm : q * ↑b' = m
h₂ : r.blt b' = true
h : ↑r + m = a
⊢ a / ↑b' = ↑q
tactic: obtain ⟨⟨rfl⟩, ⟨rfl⟩⟩ := ha, hb
state_before: case mk.mk
a q m : ℤ
b' r : ℕ
hm : q * ↑b' = m
h₂ : r.blt b' = true
h : ↑r + m = a
⊢ a / ↑b' = ↑q
state_after: case mk.mk
a q m : ℤ
b' r : ℕ
hm : q * ↑b' = m
h : ↑r + m = a
h₂ : r < b'
⊢ a / ↑b' = ↑q
tactic: simp only [Nat.blt_eq] at h₂
state_before: case mk.mk
a q m : ℤ
b' r : ℕ
hm : q * ↑b' = m
h : ↑r + m = a
h₂ : r < b'
⊢ a / ↑b' = ↑q
state_after: case mk.mk
a q m : ℤ
b' r : ℕ
hm : q * ↑b' = m
h : ↑r + m = a
h₂ : r < b'
⊢ (↑r + q * ↑b') / ↑b' = q
tactic: simp only [← h, ← hm, Int.cast_id]
state_before: case mk.mk
a q m : ℤ
b' r : ℕ
hm : q * ↑b' = m
h : ↑r + m = a
h₂ : r < b'
⊢ (↑r + q * ↑b') / ↑b' = q
state_after: case mk.mk
a q m : ℤ
b' r : ℕ
hm : q * ↑b' = m
h : ↑r + m = a
h₂ : r < b'
⊢ ↑r / ↑b' + q = q
tactic: rw [Int.add_mul_ediv_right _ _ (Int.ofNat_ne_zero.2 ((Nat.zero_le ..).trans_lt h₂).ne')]
state_before: case mk.mk
a q m : ℤ
b' r : ℕ
hm : q * ↑b' = m
h : ↑r + m = a
h₂ : r < b'
⊢ ↑r / ↑b' + q = q
state_after: no goals
tactic: rw [Int.ediv_eq_zero_of_lt, zero_add] <;> [simp; simpa using h₂]