tasksource/leandojo huggingface dataset:
Theorem: Finset.image₂_subset_iff_left
File: Mathlib/Data/Finset/NAry.lean

tactic: simp_rw [image₂_subset_iff, image_subset_iff]
state_before: α : Type u_2
α' : Type ?u.19045
β : Type u_3
β' : Type ?u.19051
γ : Type u_1
γ' : Type ?u.19057
δ : Type ?u.19060
δ' : Type ?u.19063
ε : Type ?u.19066
ε' : Type ?u.19069
ζ : Type ?u.19072
ζ' : Type ?u.19075
ν : Type ?u.19078
inst✝⁷ : DecidableEq α'
inst✝⁶ : DecidableEq β'
inst✝⁵ : DecidableEq γ
inst✝⁴ : DecidableEq γ'
inst✝³ : DecidableEq δ
inst✝² : DecidableEq δ'
inst✝¹ : DecidableEq ε
inst✝ : DecidableEq ε'
f f' : α → β → γ
g g' : α → β → γ → δ
s s' : Finset α
t t' : Finset β
u u' : Finset γ
a a' : α
b b' : β
c : γ
⊢ image₂ f s t ⊆ u ↔ ∀ (a : α), a ∈ s → image (fun b => f a b) t ⊆ u
Theorem: MeasureTheory.Measure.isFiniteMeasure_map
File: Mathlib/MeasureTheory/Measure/MeasureSpace.lean

tactic: by_cases hf : AEMeasurable f μ
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.617578
δ : Type ?u.617581
ι : Type ?u.617584
R : Type ?u.617587
R' : Type ?u.617590
m0 : MeasurableSpace α
inst✝² : MeasurableSpace β
inst✝¹ : MeasurableSpace γ
μ✝ μ₁ μ₂ μ₃ ν ν' ν₁ ν₂ : Measure α
s s' t : Set α
m : MeasurableSpace α
μ : Measure α
inst✝ : IsFiniteMeasure μ
f : α → β
⊢ IsFiniteMeasure (map f μ)

tactic: constructor
state_before: case pos
α : Type u_1
β : Type u_2
γ : Type ?u.617578
δ : Type ?u.617581
ι : Type ?u.617584
R : Type ?u.617587
R' : Type ?u.617590
m0 : MeasurableSpace α
inst✝² : MeasurableSpace β
inst✝¹ : MeasurableSpace γ
μ✝ μ₁ μ₂ μ₃ ν ν' ν₁ ν₂ : Measure α
s s' t : Set α
m : MeasurableSpace α
μ : Measure α
inst✝ : IsFiniteMeasure μ
f : α → β
hf : AEMeasurable f
⊢ IsFiniteMeasure (map f μ)

tactic: rw [map_apply_of_aemeasurable hf MeasurableSet.univ]
state_before: case pos.measure_univ_lt_top
α : Type u_1
β : Type u_2
γ : Type ?u.617578
δ : Type ?u.617581
ι : Type ?u.617584
R : Type ?u.617587
R' : Type ?u.617590
m0 : MeasurableSpace α
inst✝² : MeasurableSpace β
inst✝¹ : MeasurableSpace γ
μ✝ μ₁ μ₂ μ₃ ν ν' ν₁ ν₂ : Measure α
s s' t : Set α
m : MeasurableSpace α
μ : Measure α
inst✝ : IsFiniteMeasure μ
f : α → β
hf : AEMeasurable f
⊢ ↑↑(map f μ) univ < ⊤

tactic: exact measure_lt_top μ _
state_before: case pos.measure_univ_lt_top
α : Type u_1
β : Type u_2
γ : Type ?u.617578
δ : Type ?u.617581
ι : Type ?u.617584
R : Type ?u.617587
R' : Type ?u.617590
m0 : MeasurableSpace α
inst✝² : MeasurableSpace β
inst✝¹ : MeasurableSpace γ
μ✝ μ₁ μ₂ μ₃ ν ν' ν₁ ν₂ : Measure α
s s' t : Set α
m : MeasurableSpace α
μ : Measure α
inst✝ : IsFiniteMeasure μ
f : α → β
hf : AEMeasurable f
⊢ ↑↑μ (f ⁻¹' univ) < ⊤

tactic: rw [map_of_not_aemeasurable hf]
state_before: case neg
α : Type u_1
β : Type u_2
γ : Type ?u.617578
δ : Type ?u.617581
ι : Type ?u.617584
R : Type ?u.617587
R' : Type ?u.617590
m0 : MeasurableSpace α
inst✝² : MeasurableSpace β
inst✝¹ : MeasurableSpace γ
μ✝ μ₁ μ₂ μ₃ ν ν' ν₁ ν₂ : Measure α
s s' t : Set α
m : MeasurableSpace α
μ : Measure α
inst✝ : IsFiniteMeasure μ
f : α → β
hf : ¬AEMeasurable f
⊢ IsFiniteMeasure (map f μ)

tactic: exact MeasureTheory.isFiniteMeasureZero
state_before: case neg
α : Type u_1
β : Type u_2
γ : Type ?u.617578
δ : Type ?u.617581
ι : Type ?u.617584
R : Type ?u.617587
R' : Type ?u.617590
m0 : MeasurableSpace α
inst✝² : MeasurableSpace β
inst✝¹ : MeasurableSpace γ
μ✝ μ₁ μ₂ μ₃ ν ν' ν₁ ν₂ : Measure α
s s' t : Set α
m : MeasurableSpace α
μ : Measure α
inst✝ : IsFiniteMeasure μ
f : α → β
hf : ¬AEMeasurable f
⊢ IsFiniteMeasure 0
Theorem: Ideal.IsHomogeneous.toIdeal_homogeneousHull_eq_self
File: Mathlib/RingTheory/GradedAlgebra/HomogeneousIdeal.lean

tactic: apply le_antisymm _ (Ideal.le_toIdeal_homogeneousHull _ _)
state_before: ι : Type u_1
σ : Type u_2
R : Type ?u.212520
A : Type u_3
inst✝⁵ : Semiring A
inst✝⁴ : DecidableEq ι
inst✝³ : AddMonoid ι
inst✝² : SetLike σ A
inst✝¹ : AddSubmonoidClass σ A
𝒜 : ι → σ
inst✝ : GradedRing 𝒜
I : Ideal A
h : IsHomogeneous 𝒜 I
⊢ toIdeal (homogeneousHull 𝒜 I) = I

tactic: apply Ideal.span_le.2
state_before: ι : Type u_1
σ : Type u_2
R : Type ?u.212520
A : Type u_3
inst✝⁵ : Semiring A
inst✝⁴ : DecidableEq ι
inst✝³ : AddMonoid ι
inst✝² : SetLike σ A
inst✝¹ : AddSubmonoidClass σ A
𝒜 : ι → σ
inst✝ : GradedRing 𝒜
I : Ideal A
h : IsHomogeneous 𝒜 I
⊢ toIdeal (homogeneousHull 𝒜 I) ≤ I

tactic: rintro _ ⟨i, x, rfl⟩
state_before: ι : Type u_1
σ : Type u_2
R : Type ?u.212520
A : Type u_3
inst✝⁵ : Semiring A
inst✝⁴ : DecidableEq ι
inst✝³ : AddMonoid ι
inst✝² : SetLike σ A
inst✝¹ : AddSubmonoidClass σ A
𝒜 : ι → σ
inst✝ : GradedRing 𝒜
I : Ideal A
h : IsHomogeneous 𝒜 I
⊢ {r | ∃ i x, ↑(↑(↑(decompose 𝒜) ↑x) i) = r} ⊆ ↑I

tactic: exact h _ x.prop
state_before: case intro.intro
ι : Type u_1
σ : Type u_2
R : Type ?u.212520
A : Type u_3
inst✝⁵ : Semiring A
inst✝⁴ : DecidableEq ι
inst✝³ : AddMonoid ι
inst✝² : SetLike σ A
inst✝¹ : AddSubmonoidClass σ A
𝒜 : ι → σ
inst✝ : GradedRing 𝒜
I : Ideal A
h : IsHomogeneous 𝒜 I
i : ι
x : { x // x ∈ I }
⊢ ↑(↑(↑(decompose 𝒜) ↑x) i) ∈ ↑I
Theorem: bounded_convexHull
File: Mathlib/Analysis/Convex/Normed.lean

tactic: simp only [Metric.bounded_iff_ediam_ne_top, convexHull_ediam]
state_before: ι : Type ?u.42300
E : Type u_1
inst✝¹ : SeminormedAddCommGroup E
inst✝ : NormedSpace ℝ E
s✝ t s : Set E
⊢ Metric.Bounded (↑(convexHull ℝ).toOrderHom s) ↔ Metric.Bounded s
Theorem: Module.End_isUnit_apply_inv_apply_of_isUnit
File: Mathlib/Algebra/Algebra/Basic.lean

tactic: simp
state_before: R : Type u
M : Type v
inst✝² : CommSemiring R
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
f : End R M
h : IsUnit f
x : M
⊢ ↑(f * (IsUnit.unit h).inv) x = x
Theorem: MeasureTheory.OuterMeasure.isCaratheodory_sum
File: Mathlib/MeasureTheory/Measure/OuterMeasure.lean

tactic: simp [Nat.not_lt_zero, m.empty]
state_before: α : Type u
m : OuterMeasure α
s✝ s₁ s₂ : Set α
s : ℕ → Set α
h : ∀ (i : ℕ), IsCaratheodory m (s i)
hd : Pairwise (Disjoint on s)
t : Set α
⊢ ∑ i in Finset.range 0, ↑m (t ∩ s i) = ↑m (t ∩ ⋃ (i : ℕ) (_ : i < 0), s i)

tactic: rw [biUnion_lt_succ, Finset.sum_range_succ, Set.union_comm, isCaratheodory_sum h hd,
  m.measure_inter_union _ (h n), add_comm]
state_before: α : Type u
m : OuterMeasure α
s✝ s₁ s₂ : Set α
s : ℕ → Set α
h : ∀ (i : ℕ), IsCaratheodory m (s i)
hd : Pairwise (Disjoint on s)
t : Set α
n : ℕ
⊢ ∑ i in Finset.range (Nat.succ n), ↑m (t ∩ s i) = ↑m (t ∩ ⋃ (i : ℕ) (_ : i < Nat.succ n), s i)

tactic: intro a
state_before: α : Type u
m : OuterMeasure α
s✝ s₁ s₂ : Set α
s : ℕ → Set α
h : ∀ (i : ℕ), IsCaratheodory m (s i)
hd : Pairwise (Disjoint on s)
t : Set α
n : ℕ
⊢ (s n ∩ ⋃ (k : ℕ) (_ : k < n), s k) ⊆ ∅

tactic: simpa using fun (h₁ : a ∈ s n) i (hi : i < n) h₂ => (hd (ne_of_gt hi)).le_bot ⟨h₁, h₂⟩
state_before: α : Type u
m : OuterMeasure α
s✝ s₁ s₂ : Set α
s : ℕ → Set α
h : ∀ (i : ℕ), IsCaratheodory m (s i)
hd : Pairwise (Disjoint on s)
t : Set α
n : ℕ
a : α
⊢ (a ∈ s n ∩ ⋃ (k : ℕ) (_ : k < n), s k) → a ∈ ∅
Theorem: MvPolynomial.natDegree_finSuccEquiv
File: Mathlib/Data/MvPolynomial/Equiv.lean

tactic: by_cases c : f = 0
state_before: R : Type u
S₁ : Type v
S₂ : Type w
S₃ : Type x
σ : Type ?u.1366622
a a' a₁ a₂ : R
e : ℕ
s : σ →₀ ℕ
inst✝ : CommSemiring R
n : ℕ
f : MvPolynomial (Fin (n + 1)) R
⊢ natDegree (↑(finSuccEquiv R n) f) = degreeOf 0 f

tactic: rw [c, (finSuccEquiv R n).map_zero, Polynomial.natDegree_zero, degreeOf_zero]
state_before: case pos
R : Type u
S₁ : Type v
S₂ : Type w
S₃ : Type x
σ : Type ?u.1366622
a a' a₁ a₂ : R
e : ℕ
s : σ →₀ ℕ
inst✝ : CommSemiring R
n : ℕ
f : MvPolynomial (Fin (n + 1)) R
c : f = 0
⊢ natDegree (↑(finSuccEquiv R n) f) = degreeOf 0 f

tactic: rw [Polynomial.natDegree, degree_finSuccEquiv (by simpa only [Ne.def] )]
state_before: case neg
R : Type u
S₁ : Type v
S₂ : Type w
S₃ : Type x
σ : Type ?u.1366622
a a' a₁ a₂ : R
e : ℕ
s : σ →₀ ℕ
inst✝ : CommSemiring R
n : ℕ
f : MvPolynomial (Fin (n + 1)) R
c : ¬f = 0
⊢ natDegree (↑(finSuccEquiv R n) f) = degreeOf 0 f

tactic: erw [WithBot.unbot'_coe]
state_before: case neg
R : Type u
S₁ : Type v
S₂ : Type w
S₃ : Type x
σ : Type ?u.1366622
a a' a₁ a₂ : R
e : ℕ
s : σ →₀ ℕ
inst✝ : CommSemiring R
n : ℕ
f : MvPolynomial (Fin (n + 1)) R
c : ¬f = 0
⊢ WithBot.unbot' 0 ↑(degreeOf 0 f) = degreeOf 0 f

tactic: simp
state_before: case neg
R : Type u
S₁ : Type v
S₂ : Type w
S₃ : Type x
σ : Type ?u.1366622
a a' a₁ a₂ : R
e : ℕ
s : σ →₀ ℕ
inst✝ : CommSemiring R
n : ℕ
f : MvPolynomial (Fin (n + 1)) R
c : ¬f = 0
⊢ ↑(degreeOf 0 f) = degreeOf 0 f

tactic: simpa only [Ne.def]
state_before: R : Type u
S₁ : Type v
S₂ : Type w
S₃ : Type x
σ : Type ?u.1366622
a a' a₁ a₂ : R
e : ℕ
s : σ →₀ ℕ
inst✝ : CommSemiring R
n : ℕ
f : MvPolynomial (Fin (n + 1)) R
c : ¬f = 0
⊢ f ≠ 0
Theorem: Real.exp_neg
File: Mathlib/Data/Complex/Exponential.lean

tactic: simp [exp_neg]
state_before: x y : ℝ
⊢ ↑(exp (-x)) = ↑(exp x)⁻¹
Theorem: EuclideanGeometry.eq_reflection_of_eq_subspace
File: Mathlib/Geometry/Euclidean/Basic.lean

tactic: subst h
state_before: V : Type u_1
P : Type u_2
inst✝⁷ : NormedAddCommGroup V
inst✝⁶ : InnerProductSpace ℝ V
inst✝⁵ : MetricSpace P
inst✝⁴ : NormedAddTorsor V P
s s' : AffineSubspace ℝ P
inst✝³ : Nonempty { x // x ∈ s }
inst✝² : Nonempty { x // x ∈ s' }
inst✝¹ : CompleteSpace { x // x ∈ direction s }
inst✝ : CompleteSpace { x // x ∈ direction s' }
h : s = s'
p : P
⊢ ↑(reflection s) p = ↑(reflection s') p

tactic: rfl
state_before: V : Type u_1
P : Type u_2
inst✝⁷ : NormedAddCommGroup V
inst✝⁶ : InnerProductSpace ℝ V
inst✝⁵ : MetricSpace P
inst✝⁴ : NormedAddTorsor V P
s : AffineSubspace ℝ P
inst✝³ : Nonempty { x // x ∈ s }
inst✝² : CompleteSpace { x // x ∈ direction s }
p : P
inst✝¹ : Nonempty { x // x ∈ s }
inst✝ : CompleteSpace { x // x ∈ direction s }
⊢ ↑(reflection s) p = ↑(reflection s) p
Theorem: Prefunctor.mapPath_comp
File: Mathlib/Combinatorics/Quiver/Path.lean

tactic: dsimp
state_before: V : Type u₁
inst✝¹ : Quiver V
W : Type u₂
inst✝ : Quiver W
F : V ⥤q W
a b : V
p : Path a b
c b✝ : V
q : Path b b✝
e : b✝ ⟶ c
⊢ mapPath F (Path.comp p (Path.cons q e)) = Path.comp (mapPath F p) (mapPath F (Path.cons q e))

tactic: rw [mapPath_comp p q]
state_before: V : Type u₁
inst✝¹ : Quiver V
W : Type u₂
inst✝ : Quiver W
F : V ⥤q W
a b : V
p : Path a b
c b✝ : V
q : Path b b✝
e : b✝ ⟶ c
⊢ Path.cons (mapPath F (Path.comp p q)) (F.map e) = Path.cons (Path.comp (mapPath F p) (mapPath F q)) (F.map e)
Theorem: Polynomial.Monic.natDegree_pow
File: Mathlib/Data/Polynomial/Monic.lean

tactic: induction' n with n hn
state_before: R : Type u
S : Type v
a b : R
m n✝ : ℕ
ι : Type y
inst✝ : Semiring R
p q r : R[X]
hp : Monic p
n : ℕ
⊢ natDegree (p ^ n) = n * natDegree p

tactic: simp
state_before: case zero
R : Type u
S : Type v
a b : R
m n : ℕ
ι : Type y
inst✝ : Semiring R
p q r : R[X]
hp : Monic p
⊢ natDegree (p ^ Nat.zero) = Nat.zero * natDegree p

tactic: rw [pow_succ, hp.natDegree_mul (hp.pow n), hn, Nat.succ_mul, add_comm]
state_before: case succ
R : Type u
S : Type v
a b : R
m n✝ : ℕ
ι : Type y
inst✝ : Semiring R
p q r : R[X]
hp : Monic p
n : ℕ
hn : natDegree (p ^ n) = n * natDegree p
⊢ natDegree (p ^ Nat.succ n) = Nat.succ n * natDegree p
Theorem: CategoryTheory.CommSq.left_adjoint_hasLift_iff
File: Mathlib/CategoryTheory/LiftingProperties/Adjunction.lean

tactic: simp only [HasLift.iff]
state_before: C : Type u_4
D : Type u_1
inst✝¹ : Category C
inst✝ : Category D
G : C ⥤ D
F : D ⥤ C
A B : C
X Y : D
i : A ⟶ B
p : X ⟶ Y
u : A ⟶ F.obj X
v : B ⟶ F.obj Y
sq : CommSq u i (F.map p) v
adj : G ⊣ F
⊢ HasLift (_ : CommSq (↑(Adjunction.homEquiv adj A X).symm u) (G.map i) p (↑(Adjunction.homEquiv adj B Y).symm v)) ↔
    HasLift sq

tactic: exact Equiv.nonempty_congr (sq.leftAdjointLiftStructEquiv adj).symm
state_before: C : Type u_4
D : Type u_1
inst✝¹ : Category C
inst✝ : Category D
G : C ⥤ D
F : D ⥤ C
A B : C
X Y : D
i : A ⟶ B
p : X ⟶ Y
u : A ⟶ F.obj X
v : B ⟶ F.obj Y
sq : CommSq u i (F.map p) v
adj : G ⊣ F
⊢ Nonempty
      (LiftStruct
        (_ : CommSq (↑(Adjunction.homEquiv adj A X).symm u) (G.map i) p (↑(Adjunction.homEquiv adj B Y).symm v))) ↔
    Nonempty (LiftStruct sq)
Theorem: Set.image_const_add_uIcc
File: Mathlib/Data/Set/Pointwise/Interval.lean

tactic: simp [add_comm]
state_before: α : Type u_1
inst✝ : LinearOrderedAddCommGroup α
a b c d : α
⊢ (fun x => a + x) '' [[b, c]] = [[a + b, a + c]]
Theorem: MeasurableEmbedding.comp
File: Mathlib/MeasureTheory/MeasurableSpace.lean

tactic: rwa [image_comp, hg.measurableSet_image, hf.measurableSet_image]
state_before: α : Type u_3
β : Type u_1
γ : Type u_2
δ : Type ?u.379755
δ' : Type ?u.379758
ι : Sort uι
s✝ t u : Set α
mα : MeasurableSpace α
inst✝¹ : MeasurableSpace β
inst✝ : MeasurableSpace γ
f : α → β
g : β → γ
hg : MeasurableEmbedding g
hf : MeasurableEmbedding f
s : Set α
hs : MeasurableSet s
⊢ MeasurableSet (g ∘ f '' s)
Theorem: iterate_succ_toZ
File: Mathlib/Order/SuccPred/LinearLocallyFinite.lean

tactic: rw [toZ_of_ge hi, Int.toNat_coe_nat]
state_before: ι : Type u_1
inst✝³ : LinearOrder ι
inst✝² : SuccOrder ι
inst✝¹ : IsSuccArchimedean ι
inst✝ : PredOrder ι
i0 i✝ i : ι
hi : i0 ≤ i
⊢ (succ^[Int.toNat (toZ i0 i)]) i0 = i

tactic: exact Nat.find_spec (exists_succ_iterate_of_le hi)
state_before: ι : Type u_1
inst✝³ : LinearOrder ι
inst✝² : SuccOrder ι
inst✝¹ : IsSuccArchimedean ι
inst✝ : PredOrder ι
i0 i✝ i : ι
hi : i0 ≤ i
⊢ (succ^[Nat.find (_ : ∃ n, (succ^[n]) i0 = i)]) i0 = i
Theorem: div_div_cancel_left
File: Mathlib/Algebra/Group/Basic.lean

tactic: simp
state_before: α : Type ?u.70321
β : Type ?u.70324
G : Type u_1
inst✝ : CommGroup G
a✝ b✝ c d a b : G
⊢ a / b / a = b⁻¹
Theorem: Function.IsPeriodicPt.iterate_mod_apply
File: Mathlib/Dynamics/PeriodicPts.lean

tactic: conv_rhs => rw [← Nat.mod_add_div m n, iterate_add_apply, (h.mul_const _).eq]
state_before: α : Type u_1
β : Type ?u.3547
f fa : α → α
fb : β → β
x y : α
m✝ n : ℕ
h : IsPeriodicPt f n x
m : ℕ
⊢ (f^[m % n]) x = (f^[m]) x
Theorem: sdiff_symmDiff_left
File: Mathlib/Order/SymmDiff.lean

tactic: simp [sdiff_symmDiff]
state_before: ι : Type ?u.62901
α : Type u_1
β : Type ?u.62907
π : ι → Type ?u.62912
inst✝ : GeneralizedBooleanAlgebra α
a b c d : α
⊢ a \ a ∆ b = a ⊓ b
Theorem: Bitvec.addLsb_div_two
File: Mathlib/Data/Bitvec/Lemmas.lean

tactic: cases b <;>
    simp only [Nat.add_mul_div_left, addLsb, ← two_mul, add_comm, Nat.succ_pos',
      Nat.mul_div_right, gt_iff_lt, zero_add, cond]
state_before: x : ℕ
b : Bool
⊢ addLsb x b / 2 = x

tactic: norm_num
state_before: case true
x : ℕ
⊢ x + 1 / 2 = x
Theorem: List.mem_permutationsAux2'
File: Mathlib/Data/List/Permutation.lean

tactic: rw [show @id (List α) = ([] ++ .) by funext _; rfl]
state_before: α : Type u_1
β : Type ?u.19875
t : α
ts ys l : List α
⊢ l ∈ (permutationsAux2 t ts [] ys id).snd ↔ ∃ l₁ l₂, l₂ ≠ [] ∧ ys = l₁ ++ l₂ ∧ l = l₁ ++ t :: l₂ ++ ts

tactic: apply mem_permutationsAux2
state_before: α : Type u_1
β : Type ?u.19875
t : α
ts ys l : List α
⊢ l ∈ (permutationsAux2 t ts [] ys fun x => [] ++ x).snd ↔ ∃ l₁ l₂, l₂ ≠ [] ∧ ys = l₁ ++ l₂ ∧ l = l₁ ++ t :: l₂ ++ ts

tactic: funext _
state_before: α : Type u_1
β : Type ?u.19875
t : α
ts ys l : List α
⊢ id = fun x => [] ++ x

tactic: rfl
state_before: case h
α : Type u_1
β : Type ?u.19875
t : α
ts ys l x✝ : List α
⊢ id x✝ = [] ++ x✝
Theorem: Valued.cauchy_iff
File: Mathlib/Topology/Algebra/Valuation.lean

tactic: rw [toUniformSpace_eq, AddGroupFilterBasis.cauchy_iff]
state_before: R : Type u
inst✝¹ : Ring R
Γ₀ : Type v
inst✝ : LinearOrderedCommGroupWithZero Γ₀
_i : Valued R Γ₀
F : Filter R
⊢ Cauchy F ↔ Filter.NeBot F ∧ ∀ (γ : Γ₀ˣ), ∃ M, M ∈ F ∧ ∀ (x : R), x ∈ M → ∀ (y : R), y ∈ M → ↑v (y - x) < ↑γ

tactic: apply and_congr Iff.rfl
state_before: R : Type u
inst✝¹ : Ring R
Γ₀ : Type v
inst✝ : LinearOrderedCommGroupWithZero Γ₀
_i : Valued R Γ₀
F : Filter R
⊢ (Filter.NeBot F ∧
      ∀ (U : Set R),
        U ∈ RingFilterBasis.toAddGroupFilterBasis → ∃ M, M ∈ F ∧ ∀ (x : R), x ∈ M → ∀ (y : R), y ∈ M → y - x ∈ U) ↔
    Filter.NeBot F ∧ ∀ (γ : Γ₀ˣ), ∃ M, M ∈ F ∧ ∀ (x : R), x ∈ M → ∀ (y : R), y ∈ M → ↑v (y - x) < ↑γ

tactic: simp_rw [Valued.v.subgroups_basis.mem_addGroupFilterBasis_iff]
state_before: R : Type u
inst✝¹ : Ring R
Γ₀ : Type v
inst✝ : LinearOrderedCommGroupWithZero Γ₀
_i : Valued R Γ₀
F : Filter R
⊢ (∀ (U : Set R),
      U ∈ RingFilterBasis.toAddGroupFilterBasis → ∃ M, M ∈ F ∧ ∀ (x : R), x ∈ M → ∀ (y : R), y ∈ M → y - x ∈ U) ↔
    ∀ (γ : Γ₀ˣ), ∃ M, M ∈ F ∧ ∀ (x : R), x ∈ M → ∀ (y : R), y ∈ M → ↑v (y - x) < ↑γ

tactic: constructor
state_before: R : Type u
inst✝¹ : Ring R
Γ₀ : Type v
inst✝ : LinearOrderedCommGroupWithZero Γ₀
_i : Valued R Γ₀
F : Filter R
⊢ (∀ (U : Set R), (∃ i, U = ↑(ltAddSubgroup v i)) → ∃ M, M ∈ F ∧ ∀ (x : R), x ∈ M → ∀ (y : R), y ∈ M → y - x ∈ U) ↔
    ∀ (γ : Γ₀ˣ), ∃ M, M ∈ F ∧ ∀ (x : R), x ∈ M → ∀ (y : R), y ∈ M → ↑v (y - x) < ↑γ

tactic: intro h γ
state_before: case mp
R : Type u
inst✝¹ : Ring R
Γ₀ : Type v
inst✝ : LinearOrderedCommGroupWithZero Γ₀
_i : Valued R Γ₀
F : Filter R
⊢ (∀ (U : Set R), (∃ i, U = ↑(ltAddSubgroup v i)) → ∃ M, M ∈ F ∧ ∀ (x : R), x ∈ M → ∀ (y : R), y ∈ M → y - x ∈ U) →
    ∀ (γ : Γ₀ˣ), ∃ M, M ∈ F ∧ ∀ (x : R), x ∈ M → ∀ (y : R), y ∈ M → ↑v (y - x) < ↑γ

tactic: exact h _ (Valued.v.subgroups_basis.mem_addGroupFilterBasis _)
state_before: case mp
R : Type u
inst✝¹ : Ring R
Γ₀ : Type v
inst✝ : LinearOrderedCommGroupWithZero Γ₀
_i : Valued R Γ₀
F : Filter R
h : ∀ (U : Set R), (∃ i, U = ↑(ltAddSubgroup v i)) → ∃ M, M ∈ F ∧ ∀ (x : R), x ∈ M → ∀ (y : R), y ∈ M → y - x ∈ U
γ : Γ₀ˣ
⊢ ∃ M, M ∈ F ∧ ∀ (x : R), x ∈ M → ∀ (y : R), y ∈ M → ↑v (y - x) < ↑γ

tactic: rintro h - ⟨γ, rfl⟩
state_before: case mpr
R : Type u
inst✝¹ : Ring R
Γ₀ : Type v
inst✝ : LinearOrderedCommGroupWithZero Γ₀
_i : Valued R Γ₀
F : Filter R
⊢ (∀ (γ : Γ₀ˣ), ∃ M, M ∈ F ∧ ∀ (x : R), x ∈ M → ∀ (y : R), y ∈ M → ↑v (y - x) < ↑γ) →
    ∀ (U : Set R), (∃ i, U = ↑(ltAddSubgroup v i)) → ∃ M, M ∈ F ∧ ∀ (x : R), x ∈ M → ∀ (y : R), y ∈ M → y - x ∈ U

tactic: exact h γ
state_before: case mpr.intro
R : Type u
inst✝¹ : Ring R
Γ₀ : Type v
inst✝ : LinearOrderedCommGroupWithZero Γ₀
_i : Valued R Γ₀
F : Filter R
h : ∀ (γ : Γ₀ˣ), ∃ M, M ∈ F ∧ ∀ (x : R), x ∈ M → ∀ (y : R), y ∈ M → ↑v (y - x) < ↑γ
γ : Γ₀ˣ
⊢ ∃ M, M ∈ F ∧ ∀ (x : R), x ∈ M → ∀ (y : R), y ∈ M → y - x ∈ ↑(ltAddSubgroup v γ)
Theorem: MvPolynomial.exists_degree_lt
File: Mathlib/Data/MvPolynomial/Variables.lean

tactic: contrapose! h
state_before: R : Type u
S : Type v
σ : Type u_1
τ : Type ?u.474475
r : R
e : ℕ
n✝ m : σ
s : σ →₀ ℕ
inst✝¹ : CommSemiring R
p q : MvPolynomial σ R
inst✝ : Fintype σ
f : MvPolynomial σ R
n : ℕ
h : totalDegree f < n * Fintype.card σ
d : σ →₀ ℕ
hd : d ∈ support f
⊢ ∃ i, ↑d i < n

tactic: calc
  n * Fintype.card σ = ∑ _s : σ, n := by
    rw [Finset.sum_const, Nat.nsmul_eq_mul, mul_comm, Finset.card_univ]
  _ ≤ ∑ s, d s := (Finset.sum_le_sum fun s _ => h s)
  _ ≤ d.sum fun _ e => e := by
    rw [Finsupp.sum_fintype]
    intros
    rfl
  _ ≤ f.totalDegree := le_totalDegree hd
state_before: R : Type u
S : Type v
σ : Type u_1
τ : Type ?u.474475
r : R
e : ℕ
n✝ m : σ
s : σ →₀ ℕ
inst✝¹ : CommSemiring R
p q : MvPolynomial σ R
inst✝ : Fintype σ
f : MvPolynomial σ R
n : ℕ
d : σ →₀ ℕ
hd : d ∈ support f
h : ∀ (i : σ), n ≤ ↑d i
⊢ n * Fintype.card σ ≤ totalDegree f

tactic: rw [Finset.sum_const, Nat.nsmul_eq_mul, mul_comm, Finset.card_univ]
state_before: R : Type u
S : Type v
σ : Type u_1
τ : Type ?u.474475
r : R
e : ℕ
n✝ m : σ
s : σ →₀ ℕ
inst✝¹ : CommSemiring R
p q : MvPolynomial σ R
inst✝ : Fintype σ
f : MvPolynomial σ R
n : ℕ
d : σ →₀ ℕ
hd : d ∈ support f
h : ∀ (i : σ), n ≤ ↑d i
⊢ n * Fintype.card σ = ∑ _s : σ, n

tactic: rw [Finsupp.sum_fintype]
state_before: R : Type u
S : Type v
σ : Type u_1
τ : Type ?u.474475
r : R
e : ℕ
n✝ m : σ
s : σ →₀ ℕ
inst✝¹ : CommSemiring R
p q : MvPolynomial σ R
inst✝ : Fintype σ
f : MvPolynomial σ R
n : ℕ
d : σ →₀ ℕ
hd : d ∈ support f
h : ∀ (i : σ), n ≤ ↑d i
⊢ ∑ s : σ, ↑d s ≤ sum d fun x e => e

tactic: intros
state_before: case h
R : Type u
S : Type v
σ : Type u_1
τ : Type ?u.474475
r : R
e : ℕ
n✝ m : σ
s : σ →₀ ℕ
inst✝¹ : CommSemiring R
p q : MvPolynomial σ R
inst✝ : Fintype σ
f : MvPolynomial σ R
n : ℕ
d : σ →₀ ℕ
hd : d ∈ support f
h : ∀ (i : σ), n ≤ ↑d i
⊢ σ → 0 = 0

tactic: rfl
state_before: case h
R : Type u
S : Type v
σ : Type u_1
τ : Type ?u.474475
r : R
e : ℕ
n✝ m : σ
s : σ →₀ ℕ
inst✝¹ : CommSemiring R
p q : MvPolynomial σ R
inst✝ : Fintype σ
f : MvPolynomial σ R
n : ℕ
d : σ →₀ ℕ
hd : d ∈ support f
h : ∀ (i : σ), n ≤ ↑d i
i✝ : σ
⊢ 0 = 0
Theorem: WithTop.sum_lt_top_iff
File: Mathlib/Algebra/BigOperators/Order.lean

tactic: simp only [WithTop.lt_top_iff_ne_top, ne_eq, sum_eq_top_iff, not_exists, not_and]
state_before: ι : Type u_2
α : Type ?u.191723
β : Type ?u.191726
M : Type u_1
N : Type ?u.191732
G : Type ?u.191735
k : Type ?u.191738
R : Type ?u.191741
inst✝¹ : AddCommMonoid M
inst✝ : LT M
s : Finset ι
f : ι → WithTop M
⊢ ∑ i in s, f i < ⊤ ↔ ∀ (i : ι), i ∈ s → f i < ⊤
Theorem: pow_bit1_neg
File: Mathlib/Algebra/GroupPower/Order.lean

tactic: rw [bit1, pow_succ]
state_before: β : Type ?u.235419
A : Type ?u.235422
G : Type ?u.235425
M : Type ?u.235428
R : Type u_1
inst✝ : StrictOrderedRing R
a : R
ha : a < 0
n : ℕ
⊢ a ^ bit1 n < 0

tactic: exact mul_neg_of_neg_of_pos ha (pow_bit0_pos_of_neg ha n)
state_before: β : Type ?u.235419
A : Type ?u.235422
G : Type ?u.235425
M : Type ?u.235428
R : Type u_1
inst✝ : StrictOrderedRing R
a : R
ha : a < 0
n : ℕ
⊢ a * a ^ bit0 n < 0
Theorem: HasDerivWithinAt.clm_comp
File: Mathlib/Analysis/Calculus/Deriv/Mul.lean

tactic: have := (hc.hasFDerivWithinAt.clm_comp hd.hasFDerivWithinAt).hasDerivWithinAt
state_before: 𝕜 : Type u
inst✝⁶ : NontriviallyNormedField 𝕜
F : Type v
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
E : Type w
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace 𝕜 E
f f₀ f₁ g : 𝕜 → F
f' f₀' f₁' g' : F
x : 𝕜
s t : Set 𝕜
L L₁ L₂ : Filter 𝕜
G : Type u_1
inst✝¹ : NormedAddCommGroup G
inst✝ : NormedSpace 𝕜 G
c : 𝕜 → F →L[𝕜] G
c' : F →L[𝕜] G
d : 𝕜 → E →L[𝕜] F
d' : E →L[𝕜] F
u : 𝕜 → F
u' : F
hc : HasDerivWithinAt c c' s x
hd : HasDerivWithinAt d d' s x
⊢ HasDerivWithinAt (fun y => comp (c y) (d y)) (comp c' (d x) + comp (c x) d') s x

tactic: rwa [add_apply, comp_apply, comp_apply, smulRight_apply, smulRight_apply, one_apply, one_smul,
  one_smul, add_comm] at this
state_before: 𝕜 : Type u
inst✝⁶ : NontriviallyNormedField 𝕜
F : Type v
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
E : Type w
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace 𝕜 E
f f₀ f₁ g : 𝕜 → F
f' f₀' f₁' g' : F
x : 𝕜
s t : Set 𝕜
L L₁ L₂ : Filter 𝕜
G : Type u_1
inst✝¹ : NormedAddCommGroup G
inst✝ : NormedSpace 𝕜 G
c : 𝕜 → F →L[𝕜] G
c' : F →L[𝕜] G
d : 𝕜 → E →L[𝕜] F
d' : E →L[𝕜] F
u : 𝕜 → F
u' : F
hc : HasDerivWithinAt c c' s x
hd : HasDerivWithinAt d d' s x
this :
  HasDerivWithinAt (fun y => comp (c y) (d y))
    (↑(comp (↑(compL 𝕜 E F G) (c x)) (smulRight 1 d') +
          comp (↑(ContinuousLinearMap.flip (compL 𝕜 E F G)) (d x)) (smulRight 1 c'))
      1)
    s x
⊢ HasDerivWithinAt (fun y => comp (c y) (d y)) (comp c' (d x) + comp (c x) d') s x
Theorem: WithTop.map_sub
File: Mathlib/Algebra/Order/Sub/WithTop.lean

tactic: simp only [h₀, sub_top, WithTop.map_zero, coe_zero, map_top]
state_before: α : Type u_2
β : Type u_1
inst✝³ : Sub α
inst✝² : Zero α
inst✝¹ : Sub β
inst✝ : Zero β
f : α → β
h : ∀ (x y : α), f (x - y) = f x - f y
h₀ : f 0 = 0
x✝ : WithTop α
⊢ map f (x✝ - ⊤) = map f x✝ - map f ⊤

tactic: simp only [← coe_sub, map_coe, h]
state_before: α : Type u_2
β : Type u_1
inst✝³ : Sub α
inst✝² : Zero α
inst✝¹ : Sub β
inst✝ : Zero β
f : α → β
h : ∀ (x y : α), f (x - y) = f x - f y
h₀ : f 0 = 0
x y : α
⊢ map f (↑x - ↑y) = map f ↑x - map f ↑y