tasksource/leandojo huggingface dataset:
Theorem: List.aestronglyMeasurable_prod'
File: Mathlib/MeasureTheory/Function/StronglyMeasurable/Basic.lean

tactic: induction' l with f l ihl
state_before: α : Type u_1
β : Type ?u.310152
γ : Type ?u.310155
ι : Type ?u.310158
inst✝⁵ : Countable ι
m : MeasurableSpace α
μ : Measure α
inst✝⁴ : TopologicalSpace β
inst✝³ : TopologicalSpace γ
f g : α → β
M : Type u_2
inst✝² : Monoid M
inst✝¹ : TopologicalSpace M
inst✝ : ContinuousMul M
l : List (α → M)
hl : ∀ (f : α → M), f ∈ l → AEStronglyMeasurable f μ
⊢ AEStronglyMeasurable (List.prod l) μ

tactic: rw [List.forall_mem_cons] at hl
state_before: case cons
α : Type u_1
β : Type ?u.310152
γ : Type ?u.310155
ι : Type ?u.310158
inst✝⁵ : Countable ι
m : MeasurableSpace α
μ : Measure α
inst✝⁴ : TopologicalSpace β
inst✝³ : TopologicalSpace γ
f✝ g : α → β
M : Type u_2
inst✝² : Monoid M
inst✝¹ : TopologicalSpace M
inst✝ : ContinuousMul M
l✝ : List (α → M)
hl✝ : ∀ (f : α → M), f ∈ l✝ → AEStronglyMeasurable f μ
f : α → M
l : List (α → M)
ihl : (∀ (f : α → M), f ∈ l → AEStronglyMeasurable f μ) → AEStronglyMeasurable (List.prod l) μ
hl : ∀ (f_1 : α → M), f_1 ∈ f :: l → AEStronglyMeasurable f_1 μ
⊢ AEStronglyMeasurable (List.prod (f :: l)) μ

tactic: rw [List.prod_cons]
state_before: case cons
α : Type u_1
β : Type ?u.310152
γ : Type ?u.310155
ι : Type ?u.310158
inst✝⁵ : Countable ι
m : MeasurableSpace α
μ : Measure α
inst✝⁴ : TopologicalSpace β
inst✝³ : TopologicalSpace γ
f✝ g : α → β
M : Type u_2
inst✝² : Monoid M
inst✝¹ : TopologicalSpace M
inst✝ : ContinuousMul M
l✝ : List (α → M)
hl✝ : ∀ (f : α → M), f ∈ l✝ → AEStronglyMeasurable f μ
f : α → M
l : List (α → M)
ihl : (∀ (f : α → M), f ∈ l → AEStronglyMeasurable f μ) → AEStronglyMeasurable (List.prod l) μ
hl : AEStronglyMeasurable f μ ∧ ∀ (x : α → M), x ∈ l → AEStronglyMeasurable x μ
⊢ AEStronglyMeasurable (List.prod (f :: l)) μ

tactic: exact hl.1.mul (ihl hl.2)
state_before: case cons
α : Type u_1
β : Type ?u.310152
γ : Type ?u.310155
ι : Type ?u.310158
inst✝⁵ : Countable ι
m : MeasurableSpace α
μ : Measure α
inst✝⁴ : TopologicalSpace β
inst✝³ : TopologicalSpace γ
f✝ g : α → β
M : Type u_2
inst✝² : Monoid M
inst✝¹ : TopologicalSpace M
inst✝ : ContinuousMul M
l✝ : List (α → M)
hl✝ : ∀ (f : α → M), f ∈ l✝ → AEStronglyMeasurable f μ
f : α → M
l : List (α → M)
ihl : (∀ (f : α → M), f ∈ l → AEStronglyMeasurable f μ) → AEStronglyMeasurable (List.prod l) μ
hl : AEStronglyMeasurable f μ ∧ ∀ (x : α → M), x ∈ l → AEStronglyMeasurable x μ
⊢ AEStronglyMeasurable (f * List.prod l) μ

tactic: exact aestronglyMeasurable_one
state_before: case nil
α : Type u_1
β : Type ?u.310152
γ : Type ?u.310155
ι : Type ?u.310158
inst✝⁵ : Countable ι
m : MeasurableSpace α
μ : Measure α
inst✝⁴ : TopologicalSpace β
inst✝³ : TopologicalSpace γ
f g : α → β
M : Type u_2
inst✝² : Monoid M
inst✝¹ : TopologicalSpace M
inst✝ : ContinuousMul M
l : List (α → M)
hl✝ : ∀ (f : α → M), f ∈ l → AEStronglyMeasurable f μ
hl : ∀ (f : α → M), f ∈ [] → AEStronglyMeasurable f μ
⊢ AEStronglyMeasurable (List.prod []) μ
Theorem: Submodule.restrictScalars_eq_bot_iff
File: Mathlib/Algebra/Module/Submodule/Lattice.lean

tactic: simp [SetLike.ext_iff]
state_before: R : Type u_1
S : Type u_3
M : Type u_2
inst✝⁶ : Semiring R
inst✝⁵ : Semiring S
inst✝⁴ : AddCommMonoid M
inst✝³ : Module R M
inst✝² : Module S M
inst✝¹ : SMul S R
inst✝ : IsScalarTower S R M
p✝ q p : Submodule R M
⊢ restrictScalars S p = ⊥ ↔ p = ⊥
Theorem: Filter.HasBasis.lift
File: Mathlib/Order/Filter/Lift.lean

tactic: refine' ⟨fun t => (hf.mem_lift_iff hg gm).trans _⟩
state_before: α : Type u_2
β✝ : Type ?u.3743
γ : Type u_4
ι✝ : Sort ?u.3749
f✝ f₁ f₂ : Filter α
g✝ g₁ g₂ : Set α → Filter β✝
ι : Type u_1
p : ι → Prop
s : ι → Set α
f : Filter α
hf : HasBasis f p s
β : ι → Type u_3
pg : (i : ι) → β i → Prop
sg : (i : ι) → β i → Set γ
g : Set α → Filter γ
hg : ∀ (i : ι), HasBasis (g (s i)) (pg i) (sg i)
gm : Monotone g
⊢ HasBasis (Filter.lift f g) (fun i => p i.fst ∧ pg i.fst i.snd) fun i => sg i.fst i.snd

tactic: simp [Sigma.exists, and_assoc, exists_and_left]
state_before: α : Type u_2
β✝ : Type ?u.3743
γ : Type u_4
ι✝ : Sort ?u.3749
f✝ f₁ f₂ : Filter α
g✝ g₁ g₂ : Set α → Filter β✝
ι : Type u_1
p : ι → Prop
s : ι → Set α
f : Filter α
hf : HasBasis f p s
β : ι → Type u_3
pg : (i : ι) → β i → Prop
sg : (i : ι) → β i → Set γ
g : Set α → Filter γ
hg : ∀ (i : ι), HasBasis (g (s i)) (pg i) (sg i)
gm : Monotone g
t : Set γ
⊢ (∃ i, p i ∧ ∃ x, pg i x ∧ sg i x ⊆ t) ↔ ∃ i, (p i.fst ∧ pg i.fst i.snd) ∧ sg i.fst i.snd ⊆ t
Theorem: Polynomial.roots_C_mul_X_pow
File: Mathlib/Data/Polynomial/RingDivision.lean

tactic: rw [roots_C_mul _ ha, roots_X_pow]
state_before: R : Type u
S : Type v
T : Type w
a b : R
n✝ : ℕ
inst✝¹ : CommRing R
inst✝ : IsDomain R
p q : R[X]
ha : a ≠ 0
n : ℕ
⊢ roots (↑C a * X ^ n) = n • {0}
Theorem: CategoryTheory.MonoidalCategory.leftUnitor_conjugation
File: Mathlib/CategoryTheory/Monoidal/Category.lean

tactic: rw [← leftUnitor_naturality_assoc, Iso.hom_inv_id, Category.comp_id]
state_before: C✝ : Type u
𝒞 : Category C✝
inst✝² : MonoidalCategory C✝
C : Type u
inst✝¹ : Category C
inst✝ : MonoidalCategory C
U V W X✝ Y✝ Z X Y : C
f : X ⟶ Y
⊢ 𝟙 (𝟙_ C) ⊗ f = (λ_ X).hom ≫ f ≫ (λ_ Y).inv
Theorem: MeasureTheory.norm_indicatorConstLp
File: Mathlib/MeasureTheory/Function/LpSpace.lean

tactic: rw [Lp.norm_def, snorm_congr_ae indicatorConstLp_coeFn,
  snorm_indicator_const hs hp_ne_zero hp_ne_top, ENNReal.toReal_mul, ENNReal.toReal_rpow,
  ENNReal.coe_toReal, coe_nnnorm]
state_before: α : Type u_2
E : Type u_1
F : Type ?u.687847
G : Type ?u.687850
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedAddCommGroup G
s : Set α
hs : MeasurableSet s
hμs : ↑↑μ s ≠ ⊤
c : E
hp_ne_zero : p ≠ 0
hp_ne_top : p ≠ ⊤
⊢ ‖indicatorConstLp p hs hμs c‖ = ‖c‖ * ENNReal.toReal (↑↑μ s) ^ (1 / ENNReal.toReal p)
Theorem: edist_pi_le_iff
File: Mathlib/Topology/MetricSpace/EMetricSpace.lean

tactic: simp only [Finset.mem_univ, forall_const]
state_before: α : Type u
β : Type v
X : Type ?u.171036
inst✝² : PseudoEMetricSpace α
π : β → Type u_1
inst✝¹ : Fintype β
inst✝ : (b : β) → EDist (π b)
f g : (b : β) → π b
d : ℝ≥0∞
⊢ (∀ (b : β), b ∈ Finset.univ → edist (f b) (g b) ≤ d) ↔ ∀ (b : β), edist (f b) (g b) ≤ d
Theorem: LocalizedModule.liftOn_mk
File: Mathlib/Algebra/Module/LocalizedModule.lean

tactic: convert Quotient.liftOn_mk f wd ⟨m, s⟩
state_before: R : Type u
inst✝² : CommSemiring R
S : Submonoid R
M : Type v
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
α : Type u_1
f : M × { x // x ∈ S } → α
wd : ∀ (p p' : M × { x // x ∈ S }), p ≈ p' → f p = f p'
m : M
s : { x // x ∈ S }
⊢ liftOn (mk m s) f wd = f (m, s)
Theorem: List.dropWhile_nthLe_zero_not
File: Mathlib/Data/List/Basic.lean

tactic: induction' l with hd tl IH
state_before: ι : Type ?u.385620
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α
p : α → Bool
l : List α
hl : 0 < length (dropWhile p l)
⊢ ¬p (nthLe (dropWhile p l) 0 hl) = true

tactic: cases hl
state_before: case nil
ι : Type ?u.385620
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α
p : α → Bool
l : List α
hl✝ : 0 < length (dropWhile p l)
hl : 0 < length (dropWhile p [])
⊢ ¬p (nthLe (dropWhile p []) 0 hl) = true

tactic: simp only [dropWhile]
state_before: case cons
ι : Type ?u.385620
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α
p : α → Bool
l : List α
hl✝ : 0 < length (dropWhile p l)
hd : α
tl : List α
IH : ∀ (hl : 0 < length (dropWhile p tl)), ¬p (nthLe (dropWhile p tl) 0 hl) = true
hl : 0 < length (dropWhile p (hd :: tl))
⊢ ¬p (nthLe (dropWhile p (hd :: tl)) 0 hl) = true

tactic: by_cases hp : p hd
state_before: case cons
ι : Type ?u.385620
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α
p : α → Bool
l : List α
hl✝ : 0 < length (dropWhile p l)
hd : α
tl : List α
IH : ∀ (hl : 0 < length (dropWhile p tl)), ¬p (nthLe (dropWhile p tl) 0 hl) = true
hl : 0 < length (dropWhile p (hd :: tl))
⊢ ¬p
        (nthLe
          (match p hd with
          | true => dropWhile p tl
          | false => hd :: tl)
          0
          (_ :
            0 <
              length
                (match p hd with
                | true => dropWhile p tl
                | false => hd :: tl))) =
      true

tactic: simp [hp, IH]
state_before: case pos
ι : Type ?u.385620
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α
p : α → Bool
l : List α
hl✝ : 0 < length (dropWhile p l)
hd : α
tl : List α
IH : ∀ (hl : 0 < length (dropWhile p tl)), ¬p (nthLe (dropWhile p tl) 0 hl) = true
hl : 0 < length (dropWhile p (hd :: tl))
hp : p hd = true
⊢ ¬p
        (nthLe
          (match p hd with
          | true => dropWhile p tl
          | false => hd :: tl)
          0
          (_ :
            0 <
              length
                (match p hd with
                | true => dropWhile p tl
                | false => hd :: tl))) =
      true

tactic: simp [hp, nthLe_cons]
state_before: case neg
ι : Type ?u.385620
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α
p : α → Bool
l : List α
hl✝ : 0 < length (dropWhile p l)
hd : α
tl : List α
IH : ∀ (hl : 0 < length (dropWhile p tl)), ¬p (nthLe (dropWhile p tl) 0 hl) = true
hl : 0 < length (dropWhile p (hd :: tl))
hp : ¬p hd = true
⊢ ¬p
        (nthLe
          (match p hd with
          | true => dropWhile p tl
          | false => hd :: tl)
          0
          (_ :
            0 <
              length
                (match p hd with
                | true => dropWhile p tl
                | false => hd :: tl))) =
      true
Theorem: MeasureTheory.Lp.eq_zero_iff_ae_eq_zero
File: Mathlib/MeasureTheory/Function/LpSpace.lean

tactic: constructor
state_before: α : Type u_1
E : Type u_2
F : Type ?u.414402
G : Type ?u.414405
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedAddCommGroup G
f : { x // x ∈ Lp E p }
⊢ f = 0 ↔ ↑↑f =ᵐ[μ] 0

tactic: intro h
state_before: case mp
α : Type u_1
E : Type u_2
F : Type ?u.414402
G : Type ?u.414405
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedAddCommGroup G
f : { x // x ∈ Lp E p }
⊢ f = 0 → ↑↑f =ᵐ[μ] 0

tactic: rw [h]
state_before: case mp
α : Type u_1
E : Type u_2
F : Type ?u.414402
G : Type ?u.414405
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedAddCommGroup G
f : { x // x ∈ Lp E p }
h : f = 0
⊢ ↑↑f =ᵐ[μ] 0

tactic: exact AEEqFun.coeFn_const _ _
state_before: case mp
α : Type u_1
E : Type u_2
F : Type ?u.414402
G : Type ?u.414405
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedAddCommGroup G
f : { x // x ∈ Lp E p }
h : f = 0
⊢ ↑↑0 =ᵐ[μ] 0

tactic: intro h
state_before: case mpr
α : Type u_1
E : Type u_2
F : Type ?u.414402
G : Type ?u.414405
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedAddCommGroup G
f : { x // x ∈ Lp E p }
⊢ ↑↑f =ᵐ[μ] 0 → f = 0

tactic: ext1
state_before: case mpr
α : Type u_1
E : Type u_2
F : Type ?u.414402
G : Type ?u.414405
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedAddCommGroup G
f : { x // x ∈ Lp E p }
h : ↑↑f =ᵐ[μ] 0
⊢ f = 0

tactic: filter_upwards [h, AEEqFun.coeFn_const α (0 : E)] with _ ha h'a
state_before: case mpr.h
α : Type u_1
E : Type u_2
F : Type ?u.414402
G : Type ?u.414405
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedAddCommGroup G
f : { x // x ∈ Lp E p }
h : ↑↑f =ᵐ[μ] 0
⊢ ↑↑f =ᵐ[μ] ↑↑0

tactic: rw [ha]
state_before: case h
α : Type u_1
E : Type u_2
F : Type ?u.414402
G : Type ?u.414405
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedAddCommGroup G
f : { x // x ∈ Lp E p }
h : ↑↑f =ᵐ[μ] 0
a✝ : α
ha : ↑↑f a✝ = OfNat.ofNat 0 a✝
h'a : ↑(AEEqFun.const α 0) a✝ = Function.const α 0 a✝
⊢ ↑↑f a✝ = ↑↑0 a✝

tactic: exact h'a.symm
state_before: case h
α : Type u_1
E : Type u_2
F : Type ?u.414402
G : Type ?u.414405
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedAddCommGroup G
f : { x // x ∈ Lp E p }
h : ↑↑f =ᵐ[μ] 0
a✝ : α
ha : ↑↑f a✝ = OfNat.ofNat 0 a✝
h'a : ↑(AEEqFun.const α 0) a✝ = Function.const α 0 a✝
⊢ OfNat.ofNat 0 a✝ = ↑↑0 a✝
Theorem: Trivialization.Prod.continuous_inv_fun
File: Mathlib/Topology/FiberBundle/Constructions.lean

tactic: rw [(Prod.inducing_diag E₁ E₂).continuousOn_iff]
state_before: B : Type u_3
inst✝⁶ : TopologicalSpace B
F₁ : Type u_2
inst✝⁵ : TopologicalSpace F₁
E₁ : B → Type u_5
inst✝⁴ : TopologicalSpace (TotalSpace E₁)
F₂ : Type u_1
inst✝³ : TopologicalSpace F₂
E₂ : B → Type u_4
inst✝² : TopologicalSpace (TotalSpace E₂)
e₁ : Trivialization F₁ TotalSpace.proj
e₂ : Trivialization F₂ TotalSpace.proj
inst✝¹ : (x : B) → Zero (E₁ x)
inst✝ : (x : B) → Zero (E₂ x)
⊢ ContinuousOn (invFun' e₁ e₂) ((e₁.baseSet ∩ e₂.baseSet) ×ˢ univ)

tactic: have H₁ : Continuous fun p : B × F₁ × F₂ ↦ ((p.1, p.2.1), (p.1, p.2.2)) :=
  (continuous_id.prod_map continuous_fst).prod_mk (continuous_id.prod_map continuous_snd)
state_before: B : Type u_3
inst✝⁶ : TopologicalSpace B
F₁ : Type u_2
inst✝⁵ : TopologicalSpace F₁
E₁ : B → Type u_5
inst✝⁴ : TopologicalSpace (TotalSpace E₁)
F₂ : Type u_1
inst✝³ : TopologicalSpace F₂
E₂ : B → Type u_4
inst✝² : TopologicalSpace (TotalSpace E₂)
e₁ : Trivialization F₁ TotalSpace.proj
e₂ : Trivialization F₂ TotalSpace.proj
inst✝¹ : (x : B) → Zero (E₁ x)
inst✝ : (x : B) → Zero (E₂ x)
⊢ ContinuousOn ((fun p => ({ fst := p.fst, snd := p.snd.fst }, { fst := p.fst, snd := p.snd.snd })) ∘ invFun' e₁ e₂)
    ((e₁.baseSet ∩ e₂.baseSet) ×ˢ univ)

tactic: refine' (e₁.continuousOn_symm.prod_map e₂.continuousOn_symm).comp H₁.continuousOn _
state_before: B : Type u_3
inst✝⁶ : TopologicalSpace B
F₁ : Type u_2
inst✝⁵ : TopologicalSpace F₁
E₁ : B → Type u_5
inst✝⁴ : TopologicalSpace (TotalSpace E₁)
F₂ : Type u_1
inst✝³ : TopologicalSpace F₂
E₂ : B → Type u_4
inst✝² : TopologicalSpace (TotalSpace E₂)
e₁ : Trivialization F₁ TotalSpace.proj
e₂ : Trivialization F₂ TotalSpace.proj
inst✝¹ : (x : B) → Zero (E₁ x)
inst✝ : (x : B) → Zero (E₂ x)
H₁ : Continuous fun p => ((p.fst, p.snd.fst), p.fst, p.snd.snd)
⊢ ContinuousOn ((fun p => ({ fst := p.fst, snd := p.snd.fst }, { fst := p.fst, snd := p.snd.snd })) ∘ invFun' e₁ e₂)
    ((e₁.baseSet ∩ e₂.baseSet) ×ˢ univ)

tactic: exact fun x h ↦ ⟨⟨h.1.1, mem_univ _⟩, ⟨h.1.2, mem_univ _⟩⟩
state_before: B : Type u_3
inst✝⁶ : TopologicalSpace B
F₁ : Type u_2
inst✝⁵ : TopologicalSpace F₁
E₁ : B → Type u_5
inst✝⁴ : TopologicalSpace (TotalSpace E₁)
F₂ : Type u_1
inst✝³ : TopologicalSpace F₂
E₂ : B → Type u_4
inst✝² : TopologicalSpace (TotalSpace E₂)
e₁ : Trivialization F₁ TotalSpace.proj
e₂ : Trivialization F₂ TotalSpace.proj
inst✝¹ : (x : B) → Zero (E₁ x)
inst✝ : (x : B) → Zero (E₂ x)
H₁ : Continuous fun p => ((p.fst, p.snd.fst), p.fst, p.snd.snd)
⊢ MapsTo (fun p => ((p.fst, p.snd.fst), p.fst, p.snd.snd)) ((e₁.baseSet ∩ e₂.baseSet) ×ˢ univ)
    ((e₁.baseSet ×ˢ univ) ×ˢ e₂.baseSet ×ˢ univ)
Theorem: PadicSeq.norm_eq_of_equiv
File: Mathlib/NumberTheory/Padics/PadicNumbers.lean

tactic: by_contra h
state_before: p : ℕ
hp : Fact (Nat.Prime p)
f g : PadicSeq p
hf : ¬f ≈ 0
hg : ¬g ≈ 0
hfg : f ≈ g
⊢ padicNorm p (↑f (stationaryPoint hf)) = padicNorm p (↑g (stationaryPoint hg))

tactic: cases'
  Decidable.em
    (padicNorm p (g (stationaryPoint hg)) < padicNorm p (f (stationaryPoint hf))) with
  hlt hnlt
state_before: p : ℕ
hp : Fact (Nat.Prime p)
f g : PadicSeq p
hf : ¬f ≈ 0
hg : ¬g ≈ 0
hfg : f ≈ g
h : ¬padicNorm p (↑f (stationaryPoint hf)) = padicNorm p (↑g (stationaryPoint hg))
⊢ False

tactic: exact norm_eq_of_equiv_aux hf hg hfg h hlt
state_before: case inl
p : ℕ
hp : Fact (Nat.Prime p)
f g : PadicSeq p
hf : ¬f ≈ 0
hg : ¬g ≈ 0
hfg : f ≈ g
h : ¬padicNorm p (↑f (stationaryPoint hf)) = padicNorm p (↑g (stationaryPoint hg))
hlt : padicNorm p (↑g (stationaryPoint hg)) < padicNorm p (↑f (stationaryPoint hf))
⊢ False

tactic: apply norm_eq_of_equiv_aux hg hf (Setoid.symm hfg) (Ne.symm h)
state_before: case inr
p : ℕ
hp : Fact (Nat.Prime p)
f g : PadicSeq p
hf : ¬f ≈ 0
hg : ¬g ≈ 0
hfg : f ≈ g
h : ¬padicNorm p (↑f (stationaryPoint hf)) = padicNorm p (↑g (stationaryPoint hg))
hnlt : ¬padicNorm p (↑g (stationaryPoint hg)) < padicNorm p (↑f (stationaryPoint hf))
⊢ False

tactic: apply lt_of_le_of_ne
state_before: case inr
p : ℕ
hp : Fact (Nat.Prime p)
f g : PadicSeq p
hf : ¬f ≈ 0
hg : ¬g ≈ 0
hfg : f ≈ g
h : ¬padicNorm p (↑f (stationaryPoint hf)) = padicNorm p (↑g (stationaryPoint hg))
hnlt : ¬padicNorm p (↑g (stationaryPoint hg)) < padicNorm p (↑f (stationaryPoint hf))
⊢ padicNorm p (↑f (stationaryPoint hf)) < padicNorm p (↑g (stationaryPoint hg))

tactic: apply le_of_not_gt hnlt
state_before: case inr.a
p : ℕ
hp : Fact (Nat.Prime p)
f g : PadicSeq p
hf : ¬f ≈ 0
hg : ¬g ≈ 0
hfg : f ≈ g
h : ¬padicNorm p (↑f (stationaryPoint hf)) = padicNorm p (↑g (stationaryPoint hg))
hnlt : ¬padicNorm p (↑g (stationaryPoint hg)) < padicNorm p (↑f (stationaryPoint hf))
⊢ padicNorm p (↑f (stationaryPoint hf)) ≤ padicNorm p (↑g (stationaryPoint hg))

case inr.a
p : ℕ
hp : Fact (Nat.Prime p)
f g : PadicSeq p
hf : ¬f ≈ 0
hg : ¬g ≈ 0
hfg : f ≈ g
h : ¬padicNorm p (↑f (stationaryPoint hf)) = padicNorm p (↑g (stationaryPoint hg))
hnlt : ¬padicNorm p (↑g (stationaryPoint hg)) < padicNorm p (↑f (stationaryPoint hf))
⊢ padicNorm p (↑f (stationaryPoint hf)) ≠ padicNorm p (↑g (stationaryPoint hg))

tactic: apply h
state_before: case inr.a
p : ℕ
hp : Fact (Nat.Prime p)
f g : PadicSeq p
hf : ¬f ≈ 0
hg : ¬g ≈ 0
hfg : f ≈ g
h : ¬padicNorm p (↑f (stationaryPoint hf)) = padicNorm p (↑g (stationaryPoint hg))
hnlt : ¬padicNorm p (↑g (stationaryPoint hg)) < padicNorm p (↑f (stationaryPoint hf))
⊢ padicNorm p (↑f (stationaryPoint hf)) ≠ padicNorm p (↑g (stationaryPoint hg))
Theorem: Polynomial.tendsto_div_exp_atTop
File: Mathlib/Analysis/SpecialFunctions/PolynomialExp.lean

tactic: induction p using Polynomial.induction_on' with
| h_monomial n c => simpa [exp_neg, div_eq_mul_inv, mul_assoc]
  using tendsto_const_nhds.mul (tendsto_pow_mul_exp_neg_atTop_nhds_0 n)
| h_add p q hp hq => simpa [add_div] using hp.add hq
state_before: p : ℝ[X]
⊢ Tendsto (fun x => eval x p / exp x) atTop (𝓝 0)

tactic: simpa [exp_neg, div_eq_mul_inv, mul_assoc]
using tendsto_const_nhds.mul (tendsto_pow_mul_exp_neg_atTop_nhds_0 n)
state_before: case h_monomial
n : ℕ
c : ℝ
⊢ Tendsto (fun x => eval x (↑(monomial n) c) / exp x) atTop (𝓝 0)

tactic: simpa [add_div] using hp.add hq
state_before: case h_add
p q : ℝ[X]
hp : Tendsto (fun x => eval x p / exp x) atTop (𝓝 0)
hq : Tendsto (fun x => eval x q / exp x) atTop (𝓝 0)
⊢ Tendsto (fun x => eval x (p + q) / exp x) atTop (𝓝 0)
Theorem: Nat.sub_mul_mod
File: Std/Data/Nat/Lemmas.lean

tactic: match k with
| 0 => rw [Nat.mul_zero, Nat.sub_zero]
| succ k =>
  have h₂ : n * k ≤ x := Nat.le_trans (le_add_right _ n) h₁
  have h₄ : x - n * k ≥ n := by
    apply Nat.le_of_add_le_add_right (b := n * k)
    rw [Nat.sub_add_cancel h₂]
    simp [mul_succ, Nat.add_comm] at h₁; simp [h₁]
  rw [mul_succ, ← Nat.sub_sub, ← mod_eq_sub_mod h₄, sub_mul_mod h₂]
state_before: x k n : Nat
h₁ : n * k ≤ x
⊢ (x - n * k) % n = x % n

tactic: rw [Nat.mul_zero, Nat.sub_zero]
state_before: x k n : Nat
h₁ : n * 0 ≤ x
⊢ (x - n * 0) % n = x % n

tactic: have h₂ : n * k ≤ x := Nat.le_trans (le_add_right _ n) h₁
state_before: x k✝ n k : Nat
h₁ : n * succ k ≤ x
⊢ (x - n * succ k) % n = x % n

tactic: have h₄ : x - n * k ≥ n := by
  apply Nat.le_of_add_le_add_right (b := n * k)
  rw [Nat.sub_add_cancel h₂]
  simp [mul_succ, Nat.add_comm] at h₁; simp [h₁]
state_before: x k✝ n k : Nat
h₁ : n * succ k ≤ x
h₂ : n * k ≤ x
⊢ (x - n * succ k) % n = x % n

tactic: rw [mul_succ, ← Nat.sub_sub, ← mod_eq_sub_mod h₄, sub_mul_mod h₂]
state_before: x k✝ n k : Nat
h₁ : n * succ k ≤ x
h₂ : n * k ≤ x
h₄ : x - n * k ≥ n
⊢ (x - n * succ k) % n = x % n

tactic: apply Nat.le_of_add_le_add_right (b := n * k)
state_before: x k✝ n k : Nat
h₁ : n * succ k ≤ x
h₂ : n * k ≤ x
⊢ x - n * k ≥ n

tactic: rw [Nat.sub_add_cancel h₂]
state_before: x k✝ n k : Nat
h₁ : n * succ k ≤ x
h₂ : n * k ≤ x
⊢ n + n * k ≤ x - n * k + n * k

tactic: simp [mul_succ, Nat.add_comm] at h₁
state_before: x k✝ n k : Nat
h₁ : n * succ k ≤ x
h₂ : n * k ≤ x
⊢ n + n * k ≤ x

tactic: simp [h₁]
state_before: x k✝ n k : Nat
h₂ : n * k ≤ x
h₁ : n + n * k ≤ x
⊢ n + n * k ≤ x
Theorem: MeasureTheory.integrable_inv_smul_measure
File: Mathlib/MeasureTheory/Function/L1Space.lean

tactic: simpa using h₂
state_before: α : Type u_2
β : Type u_1
γ : Type ?u.850036
δ : Type ?u.850039
m : MeasurableSpace α
μ ν : Measure α
inst✝² : MeasurableSpace δ
inst✝¹ : NormedAddCommGroup β
inst✝ : NormedAddCommGroup γ
f : α → β
c : ℝ≥0∞
h₁ : c ≠ 0
h₂ : c ≠ ⊤
⊢ c⁻¹ ≠ 0

tactic: simpa using h₁
state_before: α : Type u_2
β : Type u_1
γ : Type ?u.850036
δ : Type ?u.850039
m : MeasurableSpace α
μ ν : Measure α
inst✝² : MeasurableSpace δ
inst✝¹ : NormedAddCommGroup β
inst✝ : NormedAddCommGroup γ
f : α → β
c : ℝ≥0∞
h₁ : c ≠ 0
h₂ : c ≠ ⊤
⊢ c⁻¹ ≠ ⊤
Theorem: HomologicalComplex.Hom.isoOfComponents_app
File: Mathlib/Algebra/Homology/HomologicalComplex.lean

tactic: ext
state_before: ι : Type u_1
V : Type u
inst✝¹ : Category V
inst✝ : HasZeroMorphisms V
c : ComplexShape ι
C C₁ C₂ C₃ : HomologicalComplex V c
f : (i : ι) → X C₁ i ≅ X C₂ i
hf : ∀ (i j : ι), ComplexShape.Rel c i j → (f i).hom ≫ d C₂ i j = d C₁ i j ≫ (f j).hom
i : ι
⊢ isoApp (isoOfComponents f) i = f i

tactic: simp
state_before: case w
ι : Type u_1
V : Type u
inst✝¹ : Category V
inst✝ : HasZeroMorphisms V
c : ComplexShape ι
C C₁ C₂ C₃ : HomologicalComplex V c
f : (i : ι) → X C₁ i ≅ X C₂ i
hf : ∀ (i j : ι), ComplexShape.Rel c i j → (f i).hom ≫ d C₂ i j = d C₁ i j ≫ (f j).hom
i : ι
⊢ (isoApp (isoOfComponents f) i).hom = (f i).hom
Theorem: Projectivization.Subspace.mem_span
File: Mathlib/LinearAlgebra/ProjectiveSpace/Subspace.lean

tactic: simp_rw [← span_le_subspace_iff]
state_before: K : Type u_2
V : Type u_1
inst✝² : Field K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
S : Set (ℙ K V)
u : ℙ K V
⊢ u ∈ span S ↔ ∀ (W : Subspace K V), S ⊆ ↑W → u ∈ W

tactic: exact ⟨fun hu W hW => hW hu, fun W => W (span S) (le_refl _)⟩
state_before: K : Type u_2
V : Type u_1
inst✝² : Field K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
S : Set (ℙ K V)
u : ℙ K V
⊢ u ∈ span S ↔ ∀ (W : Subspace K V), span S ≤ W → u ∈ W
Theorem: IsCompact.closedBall_mul
File: Mathlib/Analysis/Normed/Group/Pointwise.lean

tactic: rw [mul_comm, hs.mul_closedBall hδ]
state_before: E : Type u_1
inst✝ : SeminormedCommGroup E
ε δ : ℝ
s t : Set E
x✝ y : E
hs : IsCompact s
hδ : 0 ≤ δ
x : E
⊢ closedBall x δ * s = x • cthickening δ s
Theorem: AffineSubspace.sOppSide_smul_vsub_vadd_left
File: Mathlib/Analysis/Convex/Side.lean

tactic: refine' ⟨wOppSide_smul_vsub_vadd_left x hp₁ hp₂ ht.le, fun h => hx _, hx⟩
state_before: R : Type u_1
V : Type u_2
V' : Type ?u.383102
P : Type u_3
P' : Type ?u.383108
inst✝⁶ : LinearOrderedField R
inst✝⁵ : AddCommGroup V
inst✝⁴ : Module R V
inst✝³ : AddTorsor V P
inst✝² : AddCommGroup V'
inst✝¹ : Module R V'
inst✝ : AddTorsor V' P'
s : AffineSubspace R P
x p₁ p₂ : P
hx : ¬x ∈ s
hp₁ : p₁ ∈ s
hp₂ : p₂ ∈ s
t : R
ht : t < 0
⊢ SOppSide s (t • (x -ᵥ p₁) +ᵥ p₂) x

tactic: rwa [vadd_mem_iff_mem_direction _ hp₂, s.direction.smul_mem_iff ht.ne,
  vsub_right_mem_direction_iff_mem hp₁] at h
state_before: R : Type u_1
V : Type u_2
V' : Type ?u.383102
P : Type u_3
P' : Type ?u.383108
inst✝⁶ : LinearOrderedField R
inst✝⁵ : AddCommGroup V
inst✝⁴ : Module R V
inst✝³ : AddTorsor V P
inst✝² : AddCommGroup V'
inst✝¹ : Module R V'
inst✝ : AddTorsor V' P'
s : AffineSubspace R P
x p₁ p₂ : P
hx : ¬x ∈ s
hp₁ : p₁ ∈ s
hp₂ : p₂ ∈ s
t : R
ht : t < 0
h : t • (x -ᵥ p₁) +ᵥ p₂ ∈ s
⊢ x ∈ s