tasksource/leandojo huggingface dataset:
Theorem: Real.rpow_logb_eq_abs
File: Mathlib/Analysis/SpecialFunctions/Log/Base.lean

tactic: apply log_injOn_pos
state_before: b x y : ℝ
b_pos : 0 < b
b_ne_one : b ≠ 1
hx : x ≠ 0
⊢ b ^ logb b x = abs x

tactic: simp only [Set.mem_Ioi]
state_before: case a
b x y : ℝ
b_pos : 0 < b
b_ne_one : b ≠ 1
hx : x ≠ 0
⊢ b ^ logb b x ∈ Ioi 0

case a
b x y : ℝ
b_pos : 0 < b
b_ne_one : b ≠ 1
hx : x ≠ 0
⊢ abs x ∈ Ioi 0

case a
b x y : ℝ
b_pos : 0 < b
b_ne_one : b ≠ 1
hx : x ≠ 0
⊢ log (b ^ logb b x) = log (abs x)

tactic: apply rpow_pos_of_pos b_pos
state_before: case a
b x y : ℝ
b_pos : 0 < b
b_ne_one : b ≠ 1
hx : x ≠ 0
⊢ 0 < b ^ logb b x

case a
b x y : ℝ
b_pos : 0 < b
b_ne_one : b ≠ 1
hx : x ≠ 0
⊢ abs x ∈ Ioi 0

case a
b x y : ℝ
b_pos : 0 < b
b_ne_one : b ≠ 1
hx : x ≠ 0
⊢ log (b ^ logb b x) = log (abs x)

tactic: simp only [abs_pos, mem_Ioi, Ne.def, hx, not_false_iff]
state_before: case a
b x y : ℝ
b_pos : 0 < b
b_ne_one : b ≠ 1
hx : x ≠ 0
⊢ abs x ∈ Ioi 0

case a
b x y : ℝ
b_pos : 0 < b
b_ne_one : b ≠ 1
hx : x ≠ 0
⊢ log (b ^ logb b x) = log (abs x)

tactic: rw [log_rpow b_pos, logb, log_abs]
state_before: case a
b x y : ℝ
b_pos : 0 < b
b_ne_one : b ≠ 1
hx : x ≠ 0
⊢ log (b ^ logb b x) = log (abs x)

tactic: field_simp [log_b_ne_zero b_pos b_ne_one]
state_before: case a
b x y : ℝ
b_pos : 0 < b
b_ne_one : b ≠ 1
hx : x ≠ 0
⊢ log x / log b * log b = log x
Theorem: Polynomial.eraseLead_natDegree_lt_or_eraseLead_eq_zero
File: Mathlib/Data/Polynomial/EraseLead.lean

tactic: by_cases h : f.support.card ≤ 1
state_before: R : Type u_1
inst✝ : Semiring R
f✝ f : R[X]
⊢ natDegree (eraseLead f) < natDegree f ∨ eraseLead f = 0

tactic: right
state_before: case pos
R : Type u_1
inst✝ : Semiring R
f✝ f : R[X]
h : card (support f) ≤ 1
⊢ natDegree (eraseLead f) < natDegree f ∨ eraseLead f = 0

tactic: rw [← C_mul_X_pow_eq_self h]
state_before: case pos.h
R : Type u_1
inst✝ : Semiring R
f✝ f : R[X]
h : card (support f) ≤ 1
⊢ eraseLead f = 0

tactic: simp
state_before: case pos.h
R : Type u_1
inst✝ : Semiring R
f✝ f : R[X]
h : card (support f) ≤ 1
⊢ eraseLead (↑C (leadingCoeff f) * X ^ natDegree f) = 0

tactic: left
state_before: case neg
R : Type u_1
inst✝ : Semiring R
f✝ f : R[X]
h : ¬card (support f) ≤ 1
⊢ natDegree (eraseLead f) < natDegree f ∨ eraseLead f = 0

tactic: apply eraseLead_natDegree_lt (lt_of_not_ge h)
state_before: case neg.h
R : Type u_1
inst✝ : Semiring R
f✝ f : R[X]
h : ¬card (support f) ≤ 1
⊢ natDegree (eraseLead f) < natDegree f
Theorem: PrimeSpectrum.zeroLocus_empty_iff_eq_top
File: Mathlib/AlgebraicGeometry/PrimeSpectrum/Basic.lean

tactic: constructor
state_before: R : Type u
S : Type v
inst✝¹ : CommRing R
inst✝ : CommRing S
I : Ideal R
⊢ zeroLocus ↑I = ∅ ↔ I = ⊤

tactic: contrapose!
state_before: case mp
R : Type u
S : Type v
inst✝¹ : CommRing R
inst✝ : CommRing S
I : Ideal R
⊢ zeroLocus ↑I = ∅ → I = ⊤

tactic: intro h
state_before: case mp
R : Type u
S : Type v
inst✝¹ : CommRing R
inst✝ : CommRing S
I : Ideal R
⊢ I ≠ ⊤ → zeroLocus ↑I ≠ ∅

tactic: rcases Ideal.exists_le_maximal I h with ⟨M, hM, hIM⟩
state_before: case mp
R : Type u
S : Type v
inst✝¹ : CommRing R
inst✝ : CommRing S
I : Ideal R
h : I ≠ ⊤
⊢ zeroLocus ↑I ≠ ∅

tactic: exact Set.Nonempty.ne_empty ⟨⟨M, hM.isPrime⟩, hIM⟩
state_before: case mp.intro.intro
R : Type u
S : Type v
inst✝¹ : CommRing R
inst✝ : CommRing S
I : Ideal R
h : I ≠ ⊤
M : Ideal R
hM : Ideal.IsMaximal M
hIM : I ≤ M
⊢ zeroLocus ↑I ≠ ∅

tactic: rintro rfl
state_before: case mpr
R : Type u
S : Type v
inst✝¹ : CommRing R
inst✝ : CommRing S
I : Ideal R
⊢ I = ⊤ → zeroLocus ↑I = ∅

tactic: apply zeroLocus_empty_of_one_mem
state_before: case mpr
R : Type u
S : Type v
inst✝¹ : CommRing R
inst✝ : CommRing S
⊢ zeroLocus ↑⊤ = ∅

tactic: trivial
state_before: case mpr.h
R : Type u
S : Type v
inst✝¹ : CommRing R
inst✝ : CommRing S
⊢ 1 ∈ ↑⊤
Theorem: map_coe_atBot_of_Ioo_subset
File: Mathlib/Topology/Order/Basic.lean

tactic: refine' (map_coe_atTop_of_Ioo_subset (show ofDual ⁻¹' s ⊆ Iio (toDual a) from ha)
  fun b' hb' => _ : _)
state_before: α : Type u
β : Type v
γ : Type w
inst✝³ : TopologicalSpace α
inst✝² : LinearOrder α
inst✝¹ : OrderTopology α
inst✝ : DenselyOrdered α
a b : α
s : Set α
ha : s ⊆ Ioi a
hs : ∀ (b' : α), b' > a → ∃ b, b > a ∧ Ioo a b ⊆ s
⊢ map Subtype.val atBot = 𝓝[Ioi a] a

tactic: simpa only [OrderDual.exists, dual_Ioo] using hs b' hb'
state_before: α : Type u
β : Type v
γ : Type w
inst✝³ : TopologicalSpace α
inst✝² : LinearOrder α
inst✝¹ : OrderTopology α
inst✝ : DenselyOrdered α
a b : α
s : Set α
ha : s ⊆ Ioi a
hs : ∀ (b' : α), b' > a → ∃ b, b > a ∧ Ioo a b ⊆ s
b' : αᵒᵈ
hb' : b' < ↑toDual a
⊢ ∃ a_1, a_1 < ↑toDual a ∧ Ioo a_1 (↑toDual a) ⊆ ↑ofDual ⁻¹' s
Theorem: Filter.tendsto_mul_const_atBot_iff
File: Mathlib/Order/Filter/AtTopBot.lean

tactic: simp only [mul_comm _ r, tendsto_const_mul_atBot_iff]
state_before: ι : Type ?u.238911
ι' : Type ?u.238914
α : Type u_2
β : Type u_1
γ : Type ?u.238923
inst✝¹ : LinearOrderedField α
l : Filter β
f : β → α
r : α
inst✝ : NeBot l
⊢ Tendsto (fun x => f x * r) l atBot ↔ 0 < r ∧ Tendsto f l atBot ∨ r < 0 ∧ Tendsto f l atTop
Theorem: CategoryTheory.Limits.image.preComp_comp
File: Mathlib/CategoryTheory/Limits/Shapes/Images.lean

tactic: apply (cancel_mono (image.ι h)).1
state_before: C : Type u
inst✝⁴ : Category C
X Y : C
f : X ⟶ Y
Z : C
g : Y ⟶ Z
W : C
h : Z ⟶ W
inst✝³ : HasImage (g ≫ h)
inst✝² : HasImage (f ≫ g ≫ h)
inst✝¹ : HasImage h
inst✝ : HasImage ((f ≫ g) ≫ h)
⊢ preComp f (g ≫ h) ≫ preComp g h = eqToHom (_ : f ≫ g ≫ h = (f ≫ g) ≫ h) ≫ preComp (f ≫ g) h

tactic: dsimp [image.preComp, image.eqToHom]
state_before: C : Type u
inst✝⁴ : Category C
X Y : C
f : X ⟶ Y
Z : C
g : Y ⟶ Z
W : C
h : Z ⟶ W
inst✝³ : HasImage (g ≫ h)
inst✝² : HasImage (f ≫ g ≫ h)
inst✝¹ : HasImage h
inst✝ : HasImage ((f ≫ g) ≫ h)
⊢ (preComp f (g ≫ h) ≫ preComp g h) ≫ ι h = (eqToHom (_ : f ≫ g ≫ h = (f ≫ g) ≫ h) ≫ preComp (f ≫ g) h) ≫ ι h

tactic: repeat (rw [Category.assoc,image.lift_fac])
state_before: C : Type u
inst✝⁴ : Category C
X Y : C
f : X ⟶ Y
Z : C
g : Y ⟶ Z
W : C
h : Z ⟶ W
inst✝³ : HasImage (g ≫ h)
inst✝² : HasImage (f ≫ g ≫ h)
inst✝¹ : HasImage h
inst✝ : HasImage ((f ≫ g) ≫ h)
⊢ (lift (MonoFactorisation.mk (image (g ≫ h)) (ι (g ≫ h)) (f ≫ factorThruImage (g ≫ h))) ≫
        lift (MonoFactorisation.mk (image h) (ι h) (g ≫ factorThruImage h))) ≫
      ι h =
    (lift (MonoFactorisation.mk (image ((f ≫ g) ≫ h)) (ι ((f ≫ g) ≫ h)) (factorThruImage ((f ≫ g) ≫ h))) ≫
        lift (MonoFactorisation.mk (image h) (ι h) ((f ≫ g) ≫ factorThruImage h))) ≫
      ι h

tactic: rw [image.lift_fac,image.lift_fac]
state_before: C : Type u
inst✝⁴ : Category C
X Y : C
f : X ⟶ Y
Z : C
g : Y ⟶ Z
W : C
h : Z ⟶ W
inst✝³ : HasImage (g ≫ h)
inst✝² : HasImage (f ≫ g ≫ h)
inst✝¹ : HasImage h
inst✝ : HasImage ((f ≫ g) ≫ h)
⊢ ι (f ≫ g ≫ h) =
    lift (MonoFactorisation.mk (image ((f ≫ g) ≫ h)) (ι ((f ≫ g) ≫ h)) (factorThruImage ((f ≫ g) ≫ h))) ≫
      lift (MonoFactorisation.mk (image h) (ι h) ((f ≫ g) ≫ factorThruImage h)) ≫ ι h

tactic: (rw [Category.assoc,image.lift_fac])
state_before: C : Type u
inst✝⁴ : Category C
X Y : C
f : X ⟶ Y
Z : C
g : Y ⟶ Z
W : C
h : Z ⟶ W
inst✝³ : HasImage (g ≫ h)
inst✝² : HasImage (f ≫ g ≫ h)
inst✝¹ : HasImage h
inst✝ : HasImage ((f ≫ g) ≫ h)
⊢ ι (f ≫ g ≫ h) =
    lift (MonoFactorisation.mk (image ((f ≫ g) ≫ h)) (ι ((f ≫ g) ≫ h)) (factorThruImage ((f ≫ g) ≫ h))) ≫
      lift (MonoFactorisation.mk (image h) (ι h) ((f ≫ g) ≫ factorThruImage h)) ≫ ι h

tactic: rw [Category.assoc,image.lift_fac]
state_before: C : Type u
inst✝⁴ : Category C
X Y : C
f : X ⟶ Y
Z : C
g : Y ⟶ Z
W : C
h : Z ⟶ W
inst✝³ : HasImage (g ≫ h)
inst✝² : HasImage (f ≫ g ≫ h)
inst✝¹ : HasImage h
inst✝ : HasImage ((f ≫ g) ≫ h)
⊢ ι (f ≫ g ≫ h) =
    lift (MonoFactorisation.mk (image ((f ≫ g) ≫ h)) (ι ((f ≫ g) ≫ h)) (factorThruImage ((f ≫ g) ≫ h))) ≫
      lift (MonoFactorisation.mk (image h) (ι h) ((f ≫ g) ≫ factorThruImage h)) ≫ ι h
Theorem: exists_mem_frontier_infDist_compl_eq_dist
File: Mathlib/Analysis/NormedSpace/FiniteDimension.lean

tactic: rcases Metric.exists_mem_closure_infDist_eq_dist (nonempty_compl.2 hs) x with ⟨y, hys, hyd⟩
state_before: E : Type u_1
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℝ E
inst✝ : FiniteDimensional ℝ E
x : E
s : Set E
hx : x ∈ s
hs : s ≠ univ
⊢ ∃ y, y ∈ frontier s ∧ Metric.infDist x (sᶜ) = dist x y

tactic: rw [closure_compl] at hys
state_before: case intro.intro
E : Type u_1
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℝ E
inst✝ : FiniteDimensional ℝ E
x : E
s : Set E
hx : x ∈ s
hs : s ≠ univ
y : E
hys : y ∈ closure (sᶜ)
hyd : Metric.infDist x (sᶜ) = dist x y
⊢ ∃ y, y ∈ frontier s ∧ Metric.infDist x (sᶜ) = dist x y

tactic: refine'
  ⟨y,
    ⟨Metric.closedBall_infDist_compl_subset_closure hx <| Metric.mem_closedBall.2 <| ge_of_eq _,
      hys⟩,
    hyd⟩
state_before: case intro.intro
E : Type u_1
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℝ E
inst✝ : FiniteDimensional ℝ E
x : E
s : Set E
hx : x ∈ s
hs : s ≠ univ
y : E
hys : y ∈ interior sᶜ
hyd : Metric.infDist x (sᶜ) = dist x y
⊢ ∃ y, y ∈ frontier s ∧ Metric.infDist x (sᶜ) = dist x y

tactic: rwa [dist_comm]
state_before: case intro.intro
E : Type u_1
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℝ E
inst✝ : FiniteDimensional ℝ E
x : E
s : Set E
hx : x ∈ s
hs : s ≠ univ
y : E
hys : y ∈ interior sᶜ
hyd : Metric.infDist x (sᶜ) = dist x y
⊢ Metric.infDist x (sᶜ) = dist y x
Theorem: update_le_self_iff
File: Mathlib/Order/Basic.lean

tactic: simp [update_le_iff]
state_before: ι : Type u_1
α : Type u
β : Type v
γ : Type w
π : ι → Type u_2
r : α → α → Prop
inst✝¹ : DecidableEq ι
inst✝ : (i : ι) → Preorder (π i)
x y : (i : ι) → π i
i : ι
a b : π i
⊢ update x i a ≤ x ↔ a ≤ x i
Theorem: FractionalIdeal.inv_anti_mono
File: Mathlib/RingTheory/DedekindDomain/Ideal.lean

tactic: intro x
state_before: R : Type ?u.15693
A : Type ?u.15696
K : Type u_1
inst✝⁷ : CommRing R
inst✝⁶ : CommRing A
inst✝⁵ : Field K
inst✝⁴ : IsDomain A
R₁ : Type u_2
inst✝³ : CommRing R₁
inst✝² : IsDomain R₁
inst✝¹ : Algebra R₁ K
inst✝ : IsFractionRing R₁ K
I J : FractionalIdeal R₁⁰ K
hI : I ≠ 0
hJ : J ≠ 0
hIJ : I ≤ J
⊢ J⁻¹ ≤ I⁻¹

tactic: simp only [val_eq_coe, mem_coe, mem_inv_iff hJ, mem_inv_iff hI]
state_before: R : Type ?u.15693
A : Type ?u.15696
K : Type u_1
inst✝⁷ : CommRing R
inst✝⁶ : CommRing A
inst✝⁵ : Field K
inst✝⁴ : IsDomain A
R₁ : Type u_2
inst✝³ : CommRing R₁
inst✝² : IsDomain R₁
inst✝¹ : Algebra R₁ K
inst✝ : IsFractionRing R₁ K
I J : FractionalIdeal R₁⁰ K
hI : I ≠ 0
hJ : J ≠ 0
hIJ : I ≤ J
x : K
⊢ x ∈ (fun a => ↑a) J⁻¹ → x ∈ (fun a => ↑a) I⁻¹

tactic: exact fun h y hy => h y (hIJ hy)
state_before: R : Type ?u.15693
A : Type ?u.15696
K : Type u_1
inst✝⁷ : CommRing R
inst✝⁶ : CommRing A
inst✝⁵ : Field K
inst✝⁴ : IsDomain A
R₁ : Type u_2
inst✝³ : CommRing R₁
inst✝² : IsDomain R₁
inst✝¹ : Algebra R₁ K
inst✝ : IsFractionRing R₁ K
I J : FractionalIdeal R₁⁰ K
hI : I ≠ 0
hJ : J ≠ 0
hIJ : I ≤ J
x : K
⊢ (∀ (y : K), y ∈ J → x * y ∈ 1) → ∀ (y : K), y ∈ I → x * y ∈ 1
Theorem: Set.nonempty_iInter
File: Mathlib/Data/Set/Lattice.lean

tactic: simp [nonempty_iff_ne_empty, iInter_eq_empty_iff]
state_before: α : Type u_1
β : Type ?u.135153
γ : Type ?u.135156
ι : Sort u_2
ι' : Sort ?u.135162
ι₂ : Sort ?u.135165
κ : ι → Sort ?u.135170
κ₁ : ι → Sort ?u.135175
κ₂ : ι → Sort ?u.135180
κ' : ι' → Sort ?u.135185
f : ι → Set α
⊢ Set.Nonempty (⋂ (i : ι), f i) ↔ ∃ x, ∀ (i : ι), x ∈ f i
Theorem: MeasureTheory.SignedMeasure.totalVariation_zero
File: Mathlib/MeasureTheory/Decomposition/Jordan.lean

tactic: simp [totalVariation, toJordanDecomposition_zero]
state_before: α : Type u_1
β : Type ?u.86752
inst✝ : MeasurableSpace α
⊢ totalVariation 0 = 0
Theorem: convexOn_of_deriv2_nonneg
File: Mathlib/Analysis/Calculus/MeanValue.lean

tactic: rwa [interior_interior]
state_before: E : Type ?u.455453
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace ℝ E
F : Type ?u.455549
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℝ F
D : Set ℝ
hD : Convex ℝ D
f : ℝ → ℝ
hf : ContinuousOn f D
hf' : DifferentiableOn ℝ f (interior D)
hf'' : DifferentiableOn ℝ (deriv f) (interior D)
hf''_nonneg : ∀ (x : ℝ), x ∈ interior D → 0 ≤ (deriv^[2]) f x
⊢ DifferentiableOn ℝ (deriv f) (interior (interior D))

tactic: rwa [interior_interior]
state_before: E : Type ?u.455453
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace ℝ E
F : Type ?u.455549
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℝ F
D : Set ℝ
hD : Convex ℝ D
f : ℝ → ℝ
hf : ContinuousOn f D
hf' : DifferentiableOn ℝ f (interior D)
hf'' : DifferentiableOn ℝ (deriv f) (interior D)
hf''_nonneg : ∀ (x : ℝ), x ∈ interior D → 0 ≤ (deriv^[2]) f x
⊢ ∀ (x : ℝ), x ∈ interior (interior D) → 0 ≤ deriv (deriv f) x
Theorem: MeasureTheory.OuterMeasure.comap_boundedBy
File: Mathlib/MeasureTheory/Measure/OuterMeasure.lean

tactic: refine' (comap_ofFunction _ _).trans _
state_before: α : Type u_2
m : Set α → ℝ≥0∞
β : Type u_1
f : β → α
h : (Monotone fun s => m ↑s) ∨ Surjective f
⊢ ↑(comap f) (boundedBy m) = boundedBy fun s => m (f '' s)

tactic: refine' h.imp (fun H s t hst => iSup_le fun hs => _) id
state_before: case refine'_1
α : Type u_2
m : Set α → ℝ≥0∞
β : Type u_1
f : β → α
h : (Monotone fun s => m ↑s) ∨ Surjective f
⊢ (Monotone fun s => ⨆ (_ : Set.Nonempty s), m s) ∨ Surjective f

tactic: have ht : t.Nonempty := hs.mono hst
state_before: case refine'_1
α : Type u_2
m : Set α → ℝ≥0∞
β : Type u_1
f : β → α
h : (Monotone fun s => m ↑s) ∨ Surjective f
H : Monotone fun s => m ↑s
s t : Set α
hst : s ≤ t
hs : Set.Nonempty s
⊢ m s ≤ (fun s => ⨆ (_ : Set.Nonempty s), m s) t

tactic: exact (@H ⟨s, hs⟩ ⟨t, ht⟩ hst).trans (le_iSup (fun _ : t.Nonempty => m t) ht)
state_before: case refine'_1
α : Type u_2
m : Set α → ℝ≥0∞
β : Type u_1
f : β → α
h : (Monotone fun s => m ↑s) ∨ Surjective f
H : Monotone fun s => m ↑s
s t : Set α
hst : s ≤ t
hs : Set.Nonempty s
ht : Set.Nonempty t
⊢ m s ≤ (fun s => ⨆ (_ : Set.Nonempty s), m s) t

tactic: dsimp only [boundedBy]
state_before: case refine'_2
α : Type u_2
m : Set α → ℝ≥0∞
β : Type u_1
f : β → α
h : (Monotone fun s => m ↑s) ∨ Surjective f
⊢ OuterMeasure.ofFunction (fun s => ⨆ (_ : Set.Nonempty (f '' s)), m (f '' s))
      (_ : (fun s => ⨆ (_ : Set.Nonempty (f '' s)), m (f '' s)) ∅ = 0) =
    boundedBy fun s => m (f '' s)

tactic: congr with s : 1
state_before: case refine'_2
α : Type u_2
m : Set α → ℝ≥0∞
β : Type u_1
f : β → α
h : (Monotone fun s => m ↑s) ∨ Surjective f
⊢ OuterMeasure.ofFunction (fun s => ⨆ (_ : Set.Nonempty (f '' s)), m (f '' s))
      (_ : (⨆ (_ : Set.Nonempty (f '' ∅)), m (f '' ∅)) = 0) =
    OuterMeasure.ofFunction (fun s => ⨆ (_ : Set.Nonempty s), m (f '' s)) (_ : (⨆ (_ : Set.Nonempty ∅), m (f '' ∅)) = 0)

tactic: rw [nonempty_image_iff]
state_before: case refine'_2.e_m.h
α : Type u_2
m : Set α → ℝ≥0∞
β : Type u_1
f : β → α
h : (Monotone fun s => m ↑s) ∨ Surjective f
s : Set β
⊢ (⨆ (_ : Set.Nonempty (f '' s)), m (f '' s)) = ⨆ (_ : Set.Nonempty s), m (f '' s)
Theorem: CompleteLattice.setIndependent_iff
File: Mathlib/Order/SupIndep.lean

tactic: simp_rw [Independent, SetIndependent, SetCoe.forall, sSup_eq_iSup]
state_before: α✝ : Type ?u.27201
β : Type ?u.27204
ι : Type ?u.27207
ι' : Type ?u.27210
inst✝¹ : CompleteLattice α✝
s✝ : Set α✝
hs : SetIndependent s✝
α : Type u_1
inst✝ : CompleteLattice α
s : Set α
⊢ SetIndependent s ↔ Independent Subtype.val

tactic: refine' forall₂_congr fun a ha => _
state_before: α✝ : Type ?u.27201
β : Type ?u.27204
ι : Type ?u.27207
ι' : Type ?u.27210
inst✝¹ : CompleteLattice α✝
s✝ : Set α✝
hs : SetIndependent s✝
α : Type u_1
inst✝ : CompleteLattice α
s : Set α
⊢ (∀ ⦃a : α⦄, a ∈ s → Disjoint a (⨆ (a_2 : α) (_ : a_2 ∈ s \ {a}), a_2)) ↔
    ∀ (x : α) (h : x ∈ s), Disjoint x (⨆ (j : { x // x ∈ s }) (_ : j ≠ { val := x, property := h }), ↑j)

tactic: simp [iSup_subtype, iSup_and]
state_before: α✝ : Type ?u.27201
β : Type ?u.27204
ι : Type ?u.27207
ι' : Type ?u.27210
inst✝¹ : CompleteLattice α✝
s✝ : Set α✝
hs : SetIndependent s✝
α : Type u_1
inst✝ : CompleteLattice α
s : Set α
a : α
ha : a ∈ s
⊢ Disjoint a (⨆ (a_1 : α) (_ : a_1 ∈ s \ {a}), a_1) ↔
    Disjoint a (⨆ (j : { x // x ∈ s }) (_ : j ≠ { val := a, property := ha }), ↑j)
Theorem: Finsupp.nonzero_iff_exists
File: Mathlib/Data/Finsupp/Defs.lean

tactic: simp [← Finsupp.support_eq_empty, Finset.eq_empty_iff_forall_not_mem]
state_before: α : Type u_1
β : Type ?u.17001
γ : Type ?u.17004
ι : Type ?u.17007
M : Type u_2
M' : Type ?u.17013
N : Type ?u.17016
P : Type ?u.17019
G : Type ?u.17022
H : Type ?u.17025
R : Type ?u.17028
S : Type ?u.17031
inst✝ : Zero M
f : α →₀ M
⊢ f ≠ 0 ↔ ∃ a, ↑f a ≠ 0
Theorem: MeasureTheory.OuterMeasure.boundedBy_caratheodory
File: Mathlib/MeasureTheory/Measure/OuterMeasure.lean

tactic: apply ofFunction_caratheodory
state_before: α : Type u_1
m : Set α → ℝ≥0∞
s : Set α
hs : ∀ (t : Set α), m (t ∩ s) + m (t \ s) ≤ m t
⊢ MeasurableSet s

tactic: intro t
state_before: case hs
α : Type u_1
m : Set α → ℝ≥0∞
s : Set α
hs : ∀ (t : Set α), m (t ∩ s) + m (t \ s) ≤ m t
⊢ ∀ (t : Set α),
    ((⨆ (_ : Set.Nonempty (t ∩ s)), m (t ∩ s)) + ⨆ (_ : Set.Nonempty (t \ s)), m (t \ s)) ≤ ⨆ (_ : Set.Nonempty t), m t

tactic: cases' t.eq_empty_or_nonempty with h h
state_before: case hs
α : Type u_1
m : Set α → ℝ≥0∞
s : Set α
hs : ∀ (t : Set α), m (t ∩ s) + m (t \ s) ≤ m t
t : Set α
⊢ ((⨆ (_ : Set.Nonempty (t ∩ s)), m (t ∩ s)) + ⨆ (_ : Set.Nonempty (t \ s)), m (t \ s)) ≤ ⨆ (_ : Set.Nonempty t), m t

tactic: simp [h, Set.not_nonempty_empty]
state_before: case hs.inl
α : Type u_1
m : Set α → ℝ≥0∞
s : Set α
hs : ∀ (t : Set α), m (t ∩ s) + m (t \ s) ≤ m t
t : Set α
h : t = ∅
⊢ ((⨆ (_ : Set.Nonempty (t ∩ s)), m (t ∩ s)) + ⨆ (_ : Set.Nonempty (t \ s)), m (t \ s)) ≤ ⨆ (_ : Set.Nonempty t), m t

tactic: convert le_trans _ (hs t)
state_before: case hs.inr
α : Type u_1
m : Set α → ℝ≥0∞
s : Set α
hs : ∀ (t : Set α), m (t ∩ s) + m (t \ s) ≤ m t
t : Set α
h : Set.Nonempty t
⊢ ((⨆ (_ : Set.Nonempty (t ∩ s)), m (t ∩ s)) + ⨆ (_ : Set.Nonempty (t \ s)), m (t \ s)) ≤ ⨆ (_ : Set.Nonempty t), m t

tactic: exact add_le_add iSup_const_le iSup_const_le
state_before: case hs.inr.convert_2
α : Type u_1
m : Set α → ℝ≥0∞
s : Set α
hs : ∀ (t : Set α), m (t ∩ s) + m (t \ s) ≤ m t
t : Set α
h : Set.Nonempty t
⊢ ((⨆ (_ : Set.Nonempty (t ∩ s)), m (t ∩ s)) + ⨆ (_ : Set.Nonempty (t \ s)), m (t \ s)) ≤ m (t ∩ s) + m (t \ s)

tactic: simp [h]
state_before: case h.e'_4
α : Type u_1
m : Set α → ℝ≥0∞
s : Set α
hs : ∀ (t : Set α), m (t ∩ s) + m (t \ s) ≤ m t
t : Set α
h : Set.Nonempty t
⊢ (⨆ (_ : Set.Nonempty t), m t) = m t
Theorem: Matrix.det_eq_of_eq_det_one_mul
File: Mathlib/LinearAlgebra/Matrix/Determinant.lean

tactic: rw [hC, one_mul]
state_before: m : Type ?u.1669131
n : Type u_1
inst✝⁴ : DecidableEq n
inst✝³ : Fintype n
inst✝² : DecidableEq m
inst✝¹ : Fintype m
R : Type v
inst✝ : CommRing R
A B C : Matrix n n R
hC : det C = 1
hA : A = C ⬝ B
⊢ det C * det B = det B
Theorem: intervalIntegral.integral_comp_sub_left
File: Mathlib/MeasureTheory/Integral/IntervalIntegral.lean

tactic: simpa only [one_mul, one_smul, inv_one] using integral_comp_sub_mul f one_ne_zero d
state_before: ι : Type ?u.14958229
𝕜 : Type ?u.14958232
E : Type u_1
F : Type ?u.14958238
A : Type ?u.14958241
inst✝² : NormedAddCommGroup E
inst✝¹ : CompleteSpace E
inst✝ : NormedSpace ℝ E
a b c d✝ : ℝ
f : ℝ → E
d : ℝ
⊢ (∫ (x : ℝ) in a..b, f (d - x)) = ∫ (x : ℝ) in d - b..d - a, f x
Theorem: MvPolynomial.eval₂Hom_comp_bind₂
File: Mathlib/Data/MvPolynomial/Monad.lean

tactic: ext : 2 <;> simp
state_before: σ : Type u_4
τ : Type ?u.1084014
R : Type u_3
S : Type u_1
T : Type u_2
inst✝² : CommSemiring R
inst✝¹ : CommSemiring S
inst✝ : CommSemiring T
f✝ : σ → MvPolynomial τ R
f : S →+* T
g : σ → T
h : R →+* MvPolynomial σ S
⊢ RingHom.comp (eval₂Hom f g) (bind₂ h) = eval₂Hom (RingHom.comp (eval₂Hom f g) h) g
Theorem: Set.preimage_mul_const_Ioc
File: Mathlib/Data/Set/Pointwise/Interval.lean

tactic: simp [← Ioi_inter_Iic, h]
state_before: α : Type u_1
inst✝ : LinearOrderedField α
a✝ a b c : α
h : 0 < c
⊢ (fun x => x * c) ⁻¹' Ioc a b = Ioc (a / c) (b / c)
Theorem: LinearPMap.ext_iff
File: Mathlib/LinearAlgebra/LinearPMap.lean

tactic: congr
state_before: R : Type u_1
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type ?u.27327
inst✝¹ : AddCommGroup G
inst✝ : Module R G
f g : E →ₗ.[R] F
EQ : f = g
x y : { x // x ∈ f.domain }
h : ↑x = ↑y
⊢ ↑f x = ↑f y

tactic: exact_mod_cast h
state_before: case e_a
R : Type u_1
inst✝⁶ : Ring R
E : Type u_2
inst✝⁵ : AddCommGroup E
inst✝⁴ : Module R E
F : Type u_3
inst✝³ : AddCommGroup F
inst✝² : Module R F
G : Type ?u.27327
inst✝¹ : AddCommGroup G
inst✝ : Module R G
f g : E →ₗ.[R] F
EQ : f = g
x y : { x // x ∈ f.domain }
h : ↑x = ↑y
⊢ x = y
Theorem: Polynomial.ext_iff_natDegree_le
File: Mathlib/Data/Polynomial/Degree/Definitions.lean

tactic: refine' Iff.trans Polynomial.ext_iff _
state_before: R : Type u
S : Type v
a b c d : R
n✝ m : ℕ
inst✝ : Semiring R
p✝ q✝ r p q : R[X]
n : ℕ
hp : natDegree p ≤ n
hq : natDegree q ≤ n
⊢ p = q ↔ ∀ (i : ℕ), i ≤ n → coeff p i = coeff q i

tactic: refine' forall_congr' fun i => ⟨fun h _ => h, fun h => _⟩
state_before: R : Type u
S : Type v
a b c d : R
n✝ m : ℕ
inst✝ : Semiring R
p✝ q✝ r p q : R[X]
n : ℕ
hp : natDegree p ≤ n
hq : natDegree q ≤ n
⊢ (∀ (n : ℕ), coeff p n = coeff q n) ↔ ∀ (i : ℕ), i ≤ n → coeff p i = coeff q i

tactic: refine' (le_or_lt i n).elim h fun k => _
state_before: R : Type u
S : Type v
a b c d : R
n✝ m : ℕ
inst✝ : Semiring R
p✝ q✝ r p q : R[X]
n : ℕ
hp : natDegree p ≤ n
hq : natDegree q ≤ n
i : ℕ
h : i ≤ n → coeff p i = coeff q i
⊢ coeff p i = coeff q i

tactic: refine'
  (coeff_eq_zero_of_natDegree_lt (hp.trans_lt k)).trans
    (coeff_eq_zero_of_natDegree_lt (hq.trans_lt k)).symm
state_before: R : Type u
S : Type v
a b c d : R
n✝ m : ℕ
inst✝ : Semiring R
p✝ q✝ r p q : R[X]
n : ℕ
hp : natDegree p ≤ n
hq : natDegree q ≤ n
i : ℕ
h : i ≤ n → coeff p i = coeff q i
k : n < i
⊢ coeff p i = coeff q i
Theorem: Matrix.inv_smul'
File: Mathlib/LinearAlgebra/Matrix/NonsingularInverse.lean

tactic: simp [h, smul_smul]
state_before: l : Type ?u.293786
m : Type u
n : Type u'
α : Type v
inst✝² : Fintype n
inst✝¹ : DecidableEq n
inst✝ : CommRing α
A B : Matrix n n α
k : αˣ
h : IsUnit (det A)
⊢ (k⁻¹ • A⁻¹) ⬝ (k • A) = 1
Theorem: LocalEquiv.EqOnSource.trans'
File: Mathlib/Logic/Equiv/LocalEquiv.lean

tactic: constructor
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type ?u.56904
e✝ : LocalEquiv α β
e'✝ : LocalEquiv β γ
e e' : LocalEquiv α β
f f' : LocalEquiv β γ
he : e ≈ e'
hf : f ≈ f'
⊢ LocalEquiv.trans e f ≈ LocalEquiv.trans e' f'

tactic: rw [trans_source'', trans_source'', ← target_eq he, ← hf.1]
state_before: case left
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type ?u.56904
e✝ : LocalEquiv α β
e'✝ : LocalEquiv β γ
e e' : LocalEquiv α β
f f' : LocalEquiv β γ
he : e ≈ e'
hf : f ≈ f'
⊢ (LocalEquiv.trans e f).source = (LocalEquiv.trans e' f').source

tactic: exact (he.symm'.eqOn.mono <| inter_subset_left _ _).image_eq
state_before: case left
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type ?u.56904
e✝ : LocalEquiv α β
e'✝ : LocalEquiv β γ
e e' : LocalEquiv α β
f f' : LocalEquiv β γ
he : e ≈ e'
hf : f ≈ f'
⊢ ↑(LocalEquiv.symm e) '' (e.target ∩ f.source) = ↑(LocalEquiv.symm e') '' (e.target ∩ f.source)

tactic: intro x hx
state_before: case right
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type ?u.56904
e✝ : LocalEquiv α β
e'✝ : LocalEquiv β γ
e e' : LocalEquiv α β
f f' : LocalEquiv β γ
he : e ≈ e'
hf : f ≈ f'
⊢ EqOn (↑(LocalEquiv.trans e f)) (↑(LocalEquiv.trans e' f')) (LocalEquiv.trans e f).source

tactic: rw [trans_source] at hx
state_before: case right
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type ?u.56904
e✝ : LocalEquiv α β
e'✝ : LocalEquiv β γ
e e' : LocalEquiv α β
f f' : LocalEquiv β γ
he : e ≈ e'
hf : f ≈ f'
x : α
hx : x ∈ (LocalEquiv.trans e f).source
⊢ ↑(LocalEquiv.trans e f) x = ↑(LocalEquiv.trans e' f') x

tactic: simp [Function.comp_apply, LocalEquiv.coe_trans, (he.2 hx.1).symm, hf.2 hx.2]
state_before: case right
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type ?u.56904
e✝ : LocalEquiv α β
e'✝ : LocalEquiv β γ
e e' : LocalEquiv α β
f f' : LocalEquiv β γ
he : e ≈ e'
hf : f ≈ f'
x : α
hx : x ∈ e.source ∩ ↑e ⁻¹' f.source
⊢ ↑(LocalEquiv.trans e f) x = ↑(LocalEquiv.trans e' f') x