tasksource/leandojo huggingface dataset:
Theorem: FDerivMeasurableAux.isOpen_b
File: Mathlib/Analysis/Calculus/FDerivMeasurable.lean

tactic: simp only [B]
state_before: 𝕜 : Type u_3
inst✝⁴ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace 𝕜 E
F : Type u_1
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace 𝕜 F
f : E → F
K✝ K : Set (E →L[𝕜] F)
r s ε : ℝ
⊢ IsOpen (B f K r s ε)

tactic: exact isOpen_iUnion fun _ => isOpen_iUnion fun _ => (isOpen_a _ _ _).inter (isOpen_a _ _ _)
state_before: 𝕜 : Type u_3
inst✝⁴ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace 𝕜 E
F : Type u_1
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace 𝕜 F
f : E → F
K✝ K : Set (E →L[𝕜] F)
r s ε : ℝ
⊢ IsOpen (⋃ (L : E →L[𝕜] F) (_ : L ∈ K), A f L r ε ∩ A f L s ε)
Theorem: IsROrC.norm_natCast
File: Mathlib/Data/IsROrC/Basic.lean

tactic: rw [← ofReal_natCast]
state_before: K : Type u_1
E : Type ?u.6572189
inst✝ : IsROrC K
n : ℕ
⊢ ‖↑n‖ = ↑n

tactic: exact norm_of_nonneg (Nat.cast_nonneg n)
state_before: K : Type u_1
E : Type ?u.6572189
inst✝ : IsROrC K
n : ℕ
⊢ ‖↑↑n‖ = ↑n
Theorem: OrderIso.refl_trans
File: Mathlib/Order/Hom/Basic.lean

tactic: ext x
state_before: F : Type ?u.82823
α : Type u_1
β : Type u_2
γ : Type ?u.82832
δ : Type ?u.82835
inst✝² : LE α
inst✝¹ : LE β
inst✝ : LE γ
e : α ≃o β
⊢ trans (refl α) e = e

tactic: rfl
state_before: case h.h
F : Type ?u.82823
α : Type u_1
β : Type u_2
γ : Type ?u.82832
δ : Type ?u.82835
inst✝² : LE α
inst✝¹ : LE β
inst✝ : LE γ
e : α ≃o β
x : α
⊢ ↑(trans (refl α) e) x = ↑e x
Theorem: NNReal.norm_eq
File: Mathlib/Analysis/Normed/Field/Basic.lean

tactic: rw [Real.norm_eq_abs, x.abs_eq]
state_before: α : Type ?u.382178
β : Type ?u.382181
γ : Type ?u.382184
ι : Type ?u.382187
x : ℝ≥0
⊢ ‖↑x‖ = ↑x
Theorem: BoxIntegral.TaggedPrepartition.forall_mem_single
File: Mathlib/Analysis/BoxIntegral/Partition/Tagged.lean

tactic: simp
state_before: ι : Type u_1
I J : Box ι
π π₁ π₂ : TaggedPrepartition I
x : ι → ℝ
r r₁ r₂ : (ι → ℝ) → ↑(Ioi 0)
p : (ι → ℝ) → Box ι → Prop
hJ : J ≤ I
h : x ∈ ↑Box.Icc I
⊢ (∀ (J' : Box ι), J' ∈ single I J hJ x h → p (tag (single I J hJ x h) J') J') ↔ p x J
Theorem: EReal.continuousAt_add_top_coe
File: Mathlib/Topology/Instances/EReal.lean

tactic: simp only [ContinuousAt, tendsto_nhds_top_iff_real, top_add_coe]
state_before: α : Type ?u.18602
inst✝ : TopologicalSpace α
a : ℝ
⊢ ContinuousAt (fun p => p.fst + p.snd) (⊤, ↑a)

tactic: refine fun r ↦ ((lt_mem_nhds (coe_lt_top (r - (a - 1)))).prod_nhds
  (lt_mem_nhds <| EReal.coe_lt_coe_iff.2 <| sub_one_lt _)).mono fun _ h ↦ ?_
state_before: α : Type ?u.18602
inst✝ : TopologicalSpace α
a : ℝ
⊢ ∀ (x : ℝ), ∀ᶠ (a : EReal × EReal) in 𝓝 (⊤, ↑a), ↑x < a.fst + a.snd

tactic: simpa only [← coe_add, sub_add_cancel] using add_lt_add h.1 h.2
state_before: α : Type ?u.18602
inst✝ : TopologicalSpace α
a r : ℝ
x✝ : EReal × EReal
h : ↑(r - (a - 1)) < x✝.fst ∧ ↑(a - 1) < x✝.snd
⊢ ↑r < x✝.fst + x✝.snd
Theorem: Order.succ_eq_iInf
File: Mathlib/Order/SuccPred/Basic.lean

tactic: refine' le_antisymm (le_iInf fun b => le_iInf succ_le_of_lt) _
state_before: α : Type u_1
inst✝¹ : CompleteLattice α
inst✝ : SuccOrder α
a : α
⊢ succ a = ⨅ (b : α) (_ : a < b), b

tactic: obtain rfl | ha := eq_or_ne a ⊤
state_before: α : Type u_1
inst✝¹ : CompleteLattice α
inst✝ : SuccOrder α
a : α
⊢ (⨅ (b : α) (_ : a < b), b) ≤ succ a

tactic: exact iInf₂_le _ (lt_succ_iff_ne_top.2 ha)
state_before: case inr
α : Type u_1
inst✝¹ : CompleteLattice α
inst✝ : SuccOrder α
a : α
ha : a ≠ ⊤
⊢ (⨅ (b : α) (_ : a < b), b) ≤ succ a

tactic: rw [succ_top]
state_before: case inl
α : Type u_1
inst✝¹ : CompleteLattice α
inst✝ : SuccOrder α
⊢ (⨅ (b : α) (_ : ⊤ < b), b) ≤ succ ⊤

tactic: exact le_top
state_before: case inl
α : Type u_1
inst✝¹ : CompleteLattice α
inst✝ : SuccOrder α
⊢ (⨅ (b : α) (_ : ⊤ < b), b) ≤ ⊤
Theorem: Complex.cosh_add
File: Mathlib/Data/Complex/Exponential.lean

tactic: rw [← mul_right_inj' (two_ne_zero' ℂ), two_cosh, exp_add, neg_add, exp_add, eq_comm, mul_add, ←
  mul_assoc, two_cosh, ← mul_assoc, two_sinh, ← mul_right_inj' (two_ne_zero' ℂ), mul_add,
  mul_left_comm, two_cosh, mul_left_comm, two_sinh]
state_before: x y : ℂ
⊢ cosh (x + y) = cosh x * cosh y + sinh x * sinh y

tactic: exact cosh_add_aux
state_before: x y : ℂ
⊢ (exp x + exp (-x)) * (exp y + exp (-y)) + (exp x - exp (-x)) * (exp y - exp (-y)) =
    2 * (exp x * exp y + exp (-x) * exp (-y))
Theorem: Matrix.etaExpand_eq
File: Mathlib/Data/Matrix/Reflection.lean

tactic: simp_rw [etaExpand, FinVec.etaExpand_eq, Matrix.of, Equiv.refl_apply]
state_before: l m✝ n✝ : ℕ
α : Type u_1
β : Type ?u.58966
m n : ℕ
A : Matrix (Fin m) (Fin n) α
⊢ etaExpand A = A
Theorem: IsLocalization.injective
File: Mathlib/RingTheory/Localization/Basic.lean

tactic: rw [injective_iff_map_eq_zero (algebraMap R S)]
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.3022378
inst✝¹ : CommRing P
K : Type ?u.3022384
inst✝ : IsLocalization M S
hM : M ≤ nonZeroDivisors R
⊢ Injective ↑(algebraMap R S)

tactic: intro a ha
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.3022378
inst✝¹ : CommRing P
K : Type ?u.3022384
inst✝ : IsLocalization M S
hM : M ≤ nonZeroDivisors R
⊢ ∀ (a : R), ↑(algebraMap R S) a = 0 → a = 0

tactic: rwa [to_map_eq_zero_iff S hM] at ha
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.3022378
inst✝¹ : CommRing P
K : Type ?u.3022384
inst✝ : IsLocalization M S
hM : M ≤ nonZeroDivisors R
a : R
ha : ↑(algebraMap R S) a = 0
⊢ a = 0
Theorem: hammingDist_triangle_left
File: Mathlib/InformationTheory/Hamming.lean

tactic: rw [hammingDist_comm z]
state_before: α : Type ?u.5285
ι : Type u_1
β : ι → Type u_2
inst✝² : Fintype ι
inst✝¹ : (i : ι) → DecidableEq (β i)
γ : ι → Type ?u.5317
inst✝ : (i : ι) → DecidableEq (γ i)
x y z : (i : ι) → β i
⊢ hammingDist x y ≤ hammingDist z x + hammingDist z y

tactic: exact hammingDist_triangle _ _ _
state_before: α : Type ?u.5285
ι : Type u_1
β : ι → Type u_2
inst✝² : Fintype ι
inst✝¹ : (i : ι) → DecidableEq (β i)
γ : ι → Type ?u.5317
inst✝ : (i : ι) → DecidableEq (γ i)
x y z : (i : ι) → β i
⊢ hammingDist x y ≤ hammingDist x z + hammingDist z y
Theorem: Turing.ToPartrec.Code.fix_eval
File: Mathlib/Computability/TMToPartrec.lean

tactic: simp [eval]
state_before: f : Code
⊢ eval (fix f) =
    PFun.fix fun v =>
      Part.map (fun v => if List.headI v = 0 then Sum.inl (List.tail v) else Sum.inr (List.tail v)) (eval f v)
Theorem: List.drop_drop
File: Mathlib/Data/List/Basic.lean

tactic: simp
state_before: ι : Type ?u.216866
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α
n m : ℕ
⊢ drop n (drop m []) = drop (n + m) []

tactic: simp
state_before: ι : Type ?u.216866
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α
n : ℕ
l : List α
⊢ drop n (drop 0 l) = drop (n + 0) l
Theorem: Subalgebra.separatesPoints_monotone
File: Mathlib/Topology/ContinuousFunction/Algebra.lean

tactic: obtain ⟨f, m, w⟩ := h n
state_before: α : Type u_1
inst✝⁹ : TopologicalSpace α
R : Type u_3
inst✝⁸ : CommSemiring R
A : Type u_2
inst✝⁷ : TopologicalSpace A
inst✝⁶ : Semiring A
inst✝⁵ : Algebra R A
inst✝⁴ : TopologicalSemiring A
A₂ : Type ?u.1479689
inst✝³ : TopologicalSpace A₂
inst✝² : Semiring A₂
inst✝¹ : Algebra R A₂
inst✝ : TopologicalSemiring A₂
s s' : Subalgebra R C(α, A)
r : s ≤ s'
h : (fun s => SeparatesPoints s) s
x y : α
n : x ≠ y
⊢ ∃ f, f ∈ (fun f => ↑f) '' ↑s' ∧ f x ≠ f y

tactic: rcases m with ⟨f, ⟨m, rfl⟩⟩
state_before: case intro.intro
α : Type u_1
inst✝⁹ : TopologicalSpace α
R : Type u_3
inst✝⁸ : CommSemiring R
A : Type u_2
inst✝⁷ : TopologicalSpace A
inst✝⁶ : Semiring A
inst✝⁵ : Algebra R A
inst✝⁴ : TopologicalSemiring A
A₂ : Type ?u.1479689
inst✝³ : TopologicalSpace A₂
inst✝² : Semiring A₂
inst✝¹ : Algebra R A₂
inst✝ : TopologicalSemiring A₂
s s' : Subalgebra R C(α, A)
r : s ≤ s'
h : (fun s => SeparatesPoints s) s
x y : α
n : x ≠ y
f : α → A
m : f ∈ (fun f => ↑f) '' ↑s
w : f x ≠ f y
⊢ ∃ f, f ∈ (fun f => ↑f) '' ↑s' ∧ f x ≠ f y

tactic: exact ⟨_, ⟨f, ⟨r m, rfl⟩⟩, w⟩
state_before: case intro.intro.intro.intro
α : Type u_1
inst✝⁹ : TopologicalSpace α
R : Type u_3
inst✝⁸ : CommSemiring R
A : Type u_2
inst✝⁷ : TopologicalSpace A
inst✝⁶ : Semiring A
inst✝⁵ : Algebra R A
inst✝⁴ : TopologicalSemiring A
A₂ : Type ?u.1479689
inst✝³ : TopologicalSpace A₂
inst✝² : Semiring A₂
inst✝¹ : Algebra R A₂
inst✝ : TopologicalSemiring A₂
s s' : Subalgebra R C(α, A)
r : s ≤ s'
h : (fun s => SeparatesPoints s) s
x y : α
n : x ≠ y
f : C(α, A)
m : f ∈ ↑s
w : (fun f => ↑f) f x ≠ (fun f => ↑f) f y
⊢ ∃ f, f ∈ (fun f => ↑f) '' ↑s' ∧ f x ≠ f y
Theorem: QuadraticForm.polar_smul_left
File: Mathlib/LinearAlgebra/QuadraticForm/Basic.lean

tactic: obtain ⟨B, h⟩ := Q.exists_companion
state_before: S : Type ?u.150446
R : Type u_1
R₁ : Type ?u.150452
M : Type u_2
inst✝³ : Ring R
inst✝² : CommRing R₁
inst✝¹ : AddCommGroup M
inst✝ : Module R M
Q : QuadraticForm R M
a : R
x y : M
⊢ polar (↑Q) (a • x) y = a * polar (↑Q) x y

tactic: simp_rw [polar, h, Q.map_smul, BilinForm.smul_left, sub_sub, add_sub_cancel']
state_before: case intro
S : Type ?u.150446
R : Type u_1
R₁ : Type ?u.150452
M : Type u_2
inst✝³ : Ring R
inst✝² : CommRing R₁
inst✝¹ : AddCommGroup M
inst✝ : Module R M
Q : QuadraticForm R M
a : R
x y : M
B : BilinForm R M
h : ∀ (x y : M), ↑Q (x + y) = ↑Q x + ↑Q y + BilinForm.bilin B x y
⊢ polar (↑Q) (a • x) y = a * polar (↑Q) x y
Theorem: CategoryTheory.Limits.biproduct.ι_map
File: Mathlib/CategoryTheory/Limits/Shapes/Biproducts.lean

tactic: rw [biproduct.map_eq_map']
state_before: J : Type w
C : Type u
inst✝³ : Category C
inst✝² : HasZeroMorphisms C
f g : J → C
inst✝¹ : HasBiproduct f
inst✝ : HasBiproduct g
p : (j : J) → f j ⟶ g j
j : J
⊢ ι f j ≫ map p = p j ≫ ι g j

tactic: apply
  Limits.IsColimit.ι_map (biproduct.isColimit f) (biproduct.bicone g).toCocone
  (Discrete.natTrans fun j => p j.as) (Discrete.mk j)
state_before: J : Type w
C : Type u
inst✝³ : Category C
inst✝² : HasZeroMorphisms C
f g : J → C
inst✝¹ : HasBiproduct f
inst✝ : HasBiproduct g
p : (j : J) → f j ⟶ g j
j : J
⊢ ι f j ≫ map' p = p j ≫ ι g j
Theorem: Subgroup.pi_mem_of_mulSingle_mem
File: Mathlib/GroupTheory/Subgroup/Finite.lean

tactic: cases nonempty_fintype η
state_before: G : Type ?u.35743
inst✝⁴ : Group G
A : Type ?u.35749
inst✝³ : AddGroup A
η : Type u_1
f : η → Type u_2
inst✝² : (i : η) → Group (f i)
inst✝¹ : Finite η
inst✝ : DecidableEq η
H : Subgroup ((i : η) → f i)
x : (i : η) → f i
h : ∀ (i : η), Pi.mulSingle i (x i) ∈ H
⊢ x ∈ H

tactic: exact pi_mem_of_mulSingle_mem_aux Finset.univ x (by simp) fun i _ => h i
state_before: case intro
G : Type ?u.35743
inst✝⁴ : Group G
A : Type ?u.35749
inst✝³ : AddGroup A
η : Type u_1
f : η → Type u_2
inst✝² : (i : η) → Group (f i)
inst✝¹ : Finite η
inst✝ : DecidableEq η
H : Subgroup ((i : η) → f i)
x : (i : η) → f i
h : ∀ (i : η), Pi.mulSingle i (x i) ∈ H
val✝ : Fintype η
⊢ x ∈ H

tactic: simp
state_before: G : Type ?u.35743
inst✝⁴ : Group G
A : Type ?u.35749
inst✝³ : AddGroup A
η : Type u_1
f : η → Type u_2
inst✝² : (i : η) → Group (f i)
inst✝¹ : Finite η
inst✝ : DecidableEq η
H : Subgroup ((i : η) → f i)
x : (i : η) → f i
h : ∀ (i : η), Pi.mulSingle i (x i) ∈ H
val✝ : Fintype η
⊢ ∀ (i : η), ¬i ∈ Finset.univ → x i = 1
Theorem: Nat.coprime_pow_left_iff
File: Mathlib/Data/Nat/GCD/Basic.lean

tactic: obtain ⟨n, rfl⟩ := exists_eq_succ_of_ne_zero hn.ne'
state_before: n : ℕ
hn : 0 < n
a b : ℕ
⊢ coprime (a ^ n) b ↔ coprime a b

tactic: rw [pow_succ, Nat.coprime_mul_iff_left]
state_before: case intro
a b n : ℕ
hn : 0 < succ n
⊢ coprime (a ^ succ n) b ↔ coprime a b

tactic: exact ⟨And.right, fun hab => ⟨hab.pow_left _, hab⟩⟩
state_before: case intro
a b n : ℕ
hn : 0 < succ n
⊢ coprime (a ^ n) b ∧ coprime a b ↔ coprime a b
Theorem: Finset.prod_eq_one_iff_of_one_le'
File: Mathlib/Algebra/BigOperators/Order.lean

tactic: classical
  refine Finset.induction_on s
    (fun _ ↦ ⟨fun _ _ h ↦ False.elim (Finset.not_mem_empty _ h), fun _ ↦ rfl⟩) ?_
  intro a s ha ih H
  have : ∀ i ∈ s, 1 ≤ f i := fun _ ↦ H _ ∘ mem_insert_of_mem
  rw [prod_insert ha, mul_eq_one_iff' (H _ <| mem_insert_self _ _) (one_le_prod' this),
    forall_mem_insert, ih this]
state_before: ι : Type u_1
α : Type ?u.27020
β : Type ?u.27023
M : Type ?u.27026
N : Type u_2
G : Type ?u.27032
k : Type ?u.27035
R : Type ?u.27038
inst✝¹ : CommMonoid M
inst✝ : OrderedCommMonoid N
f g : ι → N
s t : Finset ι
⊢ (∀ (i : ι), i ∈ s → 1 ≤ f i) → (∏ i in s, f i = 1 ↔ ∀ (i : ι), i ∈ s → f i = 1)

tactic: refine Finset.induction_on s
  (fun _ ↦ ⟨fun _ _ h ↦ False.elim (Finset.not_mem_empty _ h), fun _ ↦ rfl⟩) ?_
state_before: ι : Type u_1
α : Type ?u.27020
β : Type ?u.27023
M : Type ?u.27026
N : Type u_2
G : Type ?u.27032
k : Type ?u.27035
R : Type ?u.27038
inst✝¹ : CommMonoid M
inst✝ : OrderedCommMonoid N
f g : ι → N
s t : Finset ι
⊢ (∀ (i : ι), i ∈ s → 1 ≤ f i) → (∏ i in s, f i = 1 ↔ ∀ (i : ι), i ∈ s → f i = 1)

tactic: intro a s ha ih H
state_before: ι : Type u_1
α : Type ?u.27020
β : Type ?u.27023
M : Type ?u.27026
N : Type u_2
G : Type ?u.27032
k : Type ?u.27035
R : Type ?u.27038
inst✝¹ : CommMonoid M
inst✝ : OrderedCommMonoid N
f g : ι → N
s t : Finset ι
⊢ ∀ ⦃a : ι⦄ {s : Finset ι},
    ¬a ∈ s →
      ((∀ (i : ι), i ∈ s → 1 ≤ f i) → (∏ i in s, f i = 1 ↔ ∀ (i : ι), i ∈ s → f i = 1)) →
        (∀ (i : ι), i ∈ insert a s → 1 ≤ f i) → (∏ i in insert a s, f i = 1 ↔ ∀ (i : ι), i ∈ insert a s → f i = 1)

tactic: have : ∀ i ∈ s, 1 ≤ f i := fun _ ↦ H _ ∘ mem_insert_of_mem
state_before: ι : Type u_1
α : Type ?u.27020
β : Type ?u.27023
M : Type ?u.27026
N : Type u_2
G : Type ?u.27032
k : Type ?u.27035
R : Type ?u.27038
inst✝¹ : CommMonoid M
inst✝ : OrderedCommMonoid N
f g : ι → N
s✝ t : Finset ι
a : ι
s : Finset ι
ha : ¬a ∈ s
ih : (∀ (i : ι), i ∈ s → 1 ≤ f i) → (∏ i in s, f i = 1 ↔ ∀ (i : ι), i ∈ s → f i = 1)
H : ∀ (i : ι), i ∈ insert a s → 1 ≤ f i
⊢ ∏ i in insert a s, f i = 1 ↔ ∀ (i : ι), i ∈ insert a s → f i = 1

tactic: rw [prod_insert ha, mul_eq_one_iff' (H _ <| mem_insert_self _ _) (one_le_prod' this),
  forall_mem_insert, ih this]
state_before: ι : Type u_1
α : Type ?u.27020
β : Type ?u.27023
M : Type ?u.27026
N : Type u_2
G : Type ?u.27032
k : Type ?u.27035
R : Type ?u.27038
inst✝¹ : CommMonoid M
inst✝ : OrderedCommMonoid N
f g : ι → N
s✝ t : Finset ι
a : ι
s : Finset ι
ha : ¬a ∈ s
ih : (∀ (i : ι), i ∈ s → 1 ≤ f i) → (∏ i in s, f i = 1 ↔ ∀ (i : ι), i ∈ s → f i = 1)
H : ∀ (i : ι), i ∈ insert a s → 1 ≤ f i
this : ∀ (i : ι), i ∈ s → 1 ≤ f i
⊢ ∏ i in insert a s, f i = 1 ↔ ∀ (i : ι), i ∈ insert a s → f i = 1
Theorem: Set.image_image2_antidistrib_right
File: Mathlib/Data/Set/NAry.lean

tactic: rw [image_id']
state_before: α : Type u_3
α' : Type u_5
β : Type u_4
β' : Type ?u.48235
γ : Type u_2
γ' : Type ?u.48241
δ : Type u_1
δ' : Type ?u.48247
ε : Type ?u.48250
ε' : Type ?u.48253
ζ : Type ?u.48256
ζ' : Type ?u.48259
ν : Type ?u.48262
f f'✝ : α → β → γ
g✝ g'✝ : α → β → γ → δ
s s' : Set α
t t' : Set β
u u' : Set γ
v : Set δ
a a' : α
b b' : β
c c' : γ
d d' : δ
g : γ → δ
f' : β → α' → δ
g' : α → α'
h_antidistrib : ∀ (a : α) (b : β), g (f a b) = f' b (g' a)
⊢ image2 f' ((fun b => b) '' t) ((fun a => g' a) '' s) = image2 f' t (g' '' s)
Theorem: Ideal.map_le_comap_of_inv_on
File: Mathlib/RingTheory/Ideal/Operations.lean

tactic: refine' Ideal.span_le.2 _
state_before: R : Type u
S : Type v
F : Type u_2
inst✝¹ : Semiring R
inst✝ : Semiring S
rc : RingHomClass F R S
f : F
I✝ J : Ideal R
K L : Ideal S
G : Type u_1
rcg : RingHomClass G S R
g : G
I : Ideal R
hf : Set.LeftInvOn ↑g ↑f ↑I
⊢ map f I ≤ comap g I

tactic: rintro x ⟨x, hx, rfl⟩
state_before: R : Type u
S : Type v
F : Type u_2
inst✝¹ : Semiring R
inst✝ : Semiring S
rc : RingHomClass F R S
f : F
I✝ J : Ideal R
K L : Ideal S
G : Type u_1
rcg : RingHomClass G S R
g : G
I : Ideal R
hf : Set.LeftInvOn ↑g ↑f ↑I
⊢ ↑f '' ↑I ⊆ ↑(comap g I)

tactic: rw [SetLike.mem_coe, mem_comap, hf hx]
state_before: case intro.intro
R : Type u
S : Type v
F : Type u_2
inst✝¹ : Semiring R
inst✝ : Semiring S
rc : RingHomClass F R S
f : F
I✝ J : Ideal R
K L : Ideal S
G : Type u_1
rcg : RingHomClass G S R
g : G
I : Ideal R
hf : Set.LeftInvOn ↑g ↑f ↑I
x : R
hx : x ∈ ↑I
⊢ ↑f x ∈ ↑(comap g I)

tactic: exact hx
state_before: case intro.intro
R : Type u
S : Type v
F : Type u_2
inst✝¹ : Semiring R
inst✝ : Semiring S
rc : RingHomClass F R S
f : F
I✝ J : Ideal R
K L : Ideal S
G : Type u_1
rcg : RingHomClass G S R
g : G
I : Ideal R
hf : Set.LeftInvOn ↑g ↑f ↑I
x : R
hx : x ∈ ↑I
⊢ x ∈ I
Theorem: eq_of_norm_div_le_zero
File: Mathlib/Analysis/Normed/Group/Basic.lean

tactic: rwa [← div_eq_one, ← norm_le_zero_iff'']
state_before: 𝓕 : Type ?u.1227402
𝕜 : Type ?u.1227405
α : Type ?u.1227408
ι : Type ?u.1227411
κ : Type ?u.1227414
E : Type u_1
F : Type ?u.1227420
G : Type ?u.1227423
inst✝¹ : NormedGroup E
inst✝ : NormedGroup F
a b : E
h : ‖a / b‖ ≤ 0
⊢ a = b
Theorem: MeasureTheory.Measure.haar.prehaar_pos
File: Mathlib/MeasureTheory/Measure/Haar/Basic.lean

tactic: apply div_pos <;> norm_cast
state_before: G : Type u_1
inst✝² : Group G
inst✝¹ : TopologicalSpace G
inst✝ : TopologicalGroup G
K₀ : PositiveCompacts G
U : Set G
hU : Set.Nonempty (interior U)
K : Set G
h1K : IsCompact K
h2K : Set.Nonempty (interior K)
⊢ 0 < prehaar (↑K₀) U { carrier := K, isCompact' := h1K }

tactic: apply index_pos ⟨⟨K, h1K⟩, h2K⟩ hU
state_before: case ha
G : Type u_1
inst✝² : Group G
inst✝¹ : TopologicalSpace G
inst✝ : TopologicalGroup G
K₀ : PositiveCompacts G
U : Set G
hU : Set.Nonempty (interior U)
K : Set G
h1K : IsCompact K
h2K : Set.Nonempty (interior K)
⊢ 0 < index (↑{ carrier := K, isCompact' := h1K }) U

case hb
G : Type u_1
inst✝² : Group G
inst✝¹ : TopologicalSpace G
inst✝ : TopologicalGroup G
K₀ : PositiveCompacts G
U : Set G
hU : Set.Nonempty (interior U)
K : Set G
h1K : IsCompact K
h2K : Set.Nonempty (interior K)
⊢ 0 < index (↑K₀) U

tactic: exact index_pos K₀ hU
state_before: case hb
G : Type u_1
inst✝² : Group G
inst✝¹ : TopologicalSpace G
inst✝ : TopologicalGroup G
K₀ : PositiveCompacts G
U : Set G
hU : Set.Nonempty (interior U)
K : Set G
h1K : IsCompact K
h2K : Set.Nonempty (interior K)
⊢ 0 < index (↑K₀) U
Theorem: Set.PairwiseDisjoint.exists_mem_filter_basis
File: Mathlib/Order/Filter/Bases.lean

tactic: rcases hd.exists_mem_filter hS with ⟨t, htl, hd⟩
state_before: α : Type u_2
β : Type ?u.54235
γ : Type ?u.54238
ι✝ : Sort ?u.54241
ι' : Sort ?u.54244
l✝ l' : Filter α
p✝ : ι✝ → Prop
s✝ : ι✝ → Set α
t : Set α
i : ι✝
p' : ι' → Prop
s' : ι' → Set α
i' : ι'
I : Type u_1
l : I → Filter α
ι : I → Sort u_3
p : (i : I) → ι i → Prop
s : (i : I) → ι i → Set α
S : Set I
hd : PairwiseDisjoint S l
hS : Set.Finite S
h : ∀ (i : I), HasBasis (l i) (p i) (s i)
⊢ ∃ ind, (∀ (i : I), p i (ind i)) ∧ PairwiseDisjoint S fun i => s i (ind i)

tactic: choose ind hp ht using fun i => (h i).mem_iff.1 (htl i)
state_before: case intro.intro
α : Type u_2
β : Type ?u.54235
γ : Type ?u.54238
ι✝ : Sort ?u.54241
ι' : Sort ?u.54244
l✝ l' : Filter α
p✝ : ι✝ → Prop
s✝ : ι✝ → Set α
t✝ : Set α
i : ι✝
p' : ι' → Prop
s' : ι' → Set α
i' : ι'
I : Type u_1
l : I → Filter α
ι : I → Sort u_3
p : (i : I) → ι i → Prop
s : (i : I) → ι i → Set α
S : Set I
hd✝ : PairwiseDisjoint S l
hS : Set.Finite S
h : ∀ (i : I), HasBasis (l i) (p i) (s i)
t : I → Set α
htl : ∀ (i : I), t i ∈ l i
hd : PairwiseDisjoint S t
⊢ ∃ ind, (∀ (i : I), p i (ind i)) ∧ PairwiseDisjoint S fun i => s i (ind i)

tactic: exact ⟨ind, hp, hd.mono ht⟩
state_before: case intro.intro
α : Type u_2
β : Type ?u.54235
γ : Type ?u.54238
ι✝ : Sort ?u.54241
ι' : Sort ?u.54244
l✝ l' : Filter α
p✝ : ι✝ → Prop
s✝ : ι✝ → Set α
t✝ : Set α
i : ι✝
p' : ι' → Prop
s' : ι' → Set α
i' : ι'
I : Type u_1
l : I → Filter α
ι : I → Sort u_3
p : (i : I) → ι i → Prop
s : (i : I) → ι i → Set α
S : Set I
hd✝ : PairwiseDisjoint S l
hS : Set.Finite S
h : ∀ (i : I), HasBasis (l i) (p i) (s i)
t : I → Set α
htl : ∀ (i : I), t i ∈ l i
hd : PairwiseDisjoint S t
ind : (i : I) → ι i
hp : ∀ (i : I), p i (ind i)
ht : ∀ (i : I), s i (ind i) ⊆ t i
⊢ ∃ ind, (∀ (i : I), p i (ind i)) ∧ PairwiseDisjoint S fun i => s i (ind i)
Theorem: Int.fdiv_eq_ediv
File: Std/Data/Int/DivMod.lean

tactic: simp
state_before: a✝ : Nat
x✝ : 0 ≤ 0
⊢ fdiv -[a✝+1] 0 = -[a✝+1] / 0
Theorem: Sum.getLeft_eq_none_iff
File: Mathlib/Data/Sum/Basic.lean

tactic: cases x <;> simp only [getLeft, isRight, eq_self_iff_true]
state_before: α : Type u
α' : Type w
β : Type v
β' : Type x
γ : Type ?u.4555
δ : Type ?u.4558
x y : α ⊕ β
⊢ getLeft x = none ↔ isRight x = true
Theorem: List.formPerm_pow_apply_head
File: Mathlib/GroupTheory/Perm/List.lean

tactic: convert formPerm_pow_apply_nthLe _ h n 0 (Nat.succ_pos _)
state_before: α : Type u_1
β : Type ?u.785495
inst✝ : DecidableEq α
l✝ : List α
x✝ x : α
l : List α
h : Nodup (x :: l)
n : ℕ
⊢ ↑(formPerm (x :: l) ^ n) x = nthLe (x :: l) (n % length (x :: l)) (_ : n % length (x :: l) < length (x :: l))

tactic: simp
state_before: case h.e'_3.h.e'_3.h.e'_5
α : Type u_1
β : Type ?u.785495
inst✝ : DecidableEq α
l✝ : List α
x✝ x : α
l : List α
h : Nodup (x :: l)
n : ℕ
⊢ n = 0 + n
Theorem: Polynomial.div_C_mul
File: Mathlib/Data/Polynomial/FieldDivision.lean

tactic: by_cases ha : a = 0
state_before: R : Type u
S : Type v
k : Type y
A : Type z
a b : R
n : ℕ
inst✝ : Field R
p q : R[X]
⊢ p / (↑C a * q) = ↑C a⁻¹ * (p / q)

tactic: simp only [div_def, leadingCoeff_mul, mul_inv, leadingCoeff_C, C.map_mul, mul_assoc]
state_before: case neg
R : Type u
S : Type v
k : Type y
A : Type z
a b : R
n : ℕ
inst✝ : Field R
p q : R[X]
ha : ¬a = 0
⊢ p / (↑C a * q) = ↑C a⁻¹ * (p / q)

tactic: congr 3
state_before: case neg
R : Type u
S : Type v
k : Type y
A : Type z
a b : R
n : ℕ
inst✝ : Field R
p q : R[X]
ha : ¬a = 0
⊢ ↑C a⁻¹ * (↑C (leadingCoeff q)⁻¹ * (p /ₘ (↑C a * (q * (↑C a⁻¹ * ↑C (leadingCoeff q)⁻¹))))) =
    ↑C a⁻¹ * (↑C (leadingCoeff q)⁻¹ * (p /ₘ (q * ↑C (leadingCoeff q)⁻¹)))

tactic: rw [mul_left_comm q, ← mul_assoc, ← C.map_mul, mul_inv_cancel ha, C.map_one, one_mul]
state_before: case neg.e_a.e_a.e_q
R : Type u
S : Type v
k : Type y
A : Type z
a b : R
n : ℕ
inst✝ : Field R
p q : R[X]
ha : ¬a = 0
⊢ ↑C a * (q * (↑C a⁻¹ * ↑C (leadingCoeff q)⁻¹)) = q * ↑C (leadingCoeff q)⁻¹

tactic: simp [ha]
state_before: case pos
R : Type u
S : Type v
k : Type y
A : Type z
a b : R
n : ℕ
inst✝ : Field R
p q : R[X]
ha : a = 0
⊢ p / (↑C a * q) = ↑C a⁻¹ * (p / q)
Theorem: measurableSet_inl_image
File: Mathlib/MeasureTheory/MeasurableSpace.lean

tactic: simp [measurableSet_sum_iff, Sum.inl_injective.preimage_image]
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.376105
δ : Type ?u.376108
δ' : Type ?u.376111
ι : Sort uι
s✝ t u : Set α
m : MeasurableSpace α
mβ : MeasurableSpace β
s : Set α
⊢ MeasurableSet (Sum.inl '' s) ↔ MeasurableSet s
Theorem: one_sub_mul
File: Mathlib/Algebra/Ring/Defs.lean

tactic: rw [sub_mul, one_mul]
state_before: α : Type u
β : Type v
γ : Type w
R : Type x
inst✝ : NonAssocRing α
a b : α
⊢ (1 - a) * b = b - a * b
Theorem: multiplicity.squarefree_iff_multiplicity_le_one
File: Mathlib/Algebra/Squarefree.lean

tactic: refine' forall_congr' fun a => _
state_before: R : Type u_1
inst✝¹ : CommMonoid R
inst✝ : DecidableRel Dvd.dvd
r : R
⊢ Squarefree r ↔ ∀ (x : R), multiplicity x r ≤ 1 ∨ IsUnit x

tactic: rw [← sq, pow_dvd_iff_le_multiplicity, or_iff_not_imp_left, not_le, imp_congr _ Iff.rfl]
state_before: R : Type u_1
inst✝¹ : CommMonoid R
inst✝ : DecidableRel Dvd.dvd
r a : R
⊢ a * a ∣ r → IsUnit a ↔ multiplicity a r ≤ 1 ∨ IsUnit a

tactic: rw [←one_add_one_eq_two]
state_before: R : Type u_1
inst✝¹ : CommMonoid R
inst✝ : DecidableRel Dvd.dvd
r a : R
⊢ ↑2 ≤ multiplicity a r ↔ 1 < multiplicity a r

tactic: simpa using PartENat.add_one_le_iff_lt (PartENat.natCast_ne_top 1)
state_before: R : Type u_1
inst✝¹ : CommMonoid R
inst✝ : DecidableRel Dvd.dvd
r a : R
⊢ ↑(1 + 1) ≤ multiplicity a r ↔ 1 < multiplicity a r
Theorem: Complex.conj_bit1
File: Mathlib/Data/Complex/Basic.lean

tactic: simp [bit0]
state_before: z : ℂ
⊢ (↑(starRingEnd ℂ) (bit1 z)).re = (bit1 (↑(starRingEnd ℂ) z)).re ∧
    (↑(starRingEnd ℂ) (bit1 z)).im = (bit1 (↑(starRingEnd ℂ) z)).im
Theorem: Module.eval_apply_eq_zero_iff
File: Mathlib/LinearAlgebra/Dual.lean

tactic: simpa only using SetLike.ext_iff.mp (eval_ker K V) v
state_before: K : Type u₁
V : Type u₂
inst✝² : Field K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
v : V
⊢ ↑(eval K V) v = 0 ↔ v = 0