tasksource/leandojo huggingface dataset:
Theorem: iteratedDerivWithin_eq_iterate
File: Mathlib/Analysis/Calculus/IteratedDeriv.lean

tactic: induction' n with n IH generalizing x
state_before: 𝕜 : Type u_1
inst✝⁴ : NontriviallyNormedField 𝕜
F : Type u_2
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
E : Type ?u.85634
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
n : ℕ
f : 𝕜 → F
s : Set 𝕜
x✝ x : 𝕜
hs : UniqueDiffOn 𝕜 s
hx : x ∈ s
⊢ iteratedDerivWithin n f s x = ((fun g => derivWithin g s)^[n]) f x

tactic: simp
state_before: case zero
𝕜 : Type u_1
inst✝⁴ : NontriviallyNormedField 𝕜
F : Type u_2
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
E : Type ?u.85634
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
n : ℕ
f : 𝕜 → F
s : Set 𝕜
x✝¹ x✝ : 𝕜
hs : UniqueDiffOn 𝕜 s
hx✝ : x✝ ∈ s
x : 𝕜
hx : x ∈ s
⊢ iteratedDerivWithin Nat.zero f s x = ((fun g => derivWithin g s)^[Nat.zero]) f x

tactic: rw [iteratedDerivWithin_succ (hs x hx), Function.iterate_succ']
state_before: case succ
𝕜 : Type u_1
inst✝⁴ : NontriviallyNormedField 𝕜
F : Type u_2
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
E : Type ?u.85634
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
n✝ : ℕ
f : 𝕜 → F
s : Set 𝕜
x✝¹ x✝ : 𝕜
hs : UniqueDiffOn 𝕜 s
hx✝ : x✝ ∈ s
n : ℕ
IH : ∀ {x : 𝕜}, x ∈ s → iteratedDerivWithin n f s x = ((fun g => derivWithin g s)^[n]) f x
x : 𝕜
hx : x ∈ s
⊢ iteratedDerivWithin (Nat.succ n) f s x = ((fun g => derivWithin g s)^[Nat.succ n]) f x

tactic: exact derivWithin_congr (fun y hy => IH hy) (IH hx)
state_before: case succ
𝕜 : Type u_1
inst✝⁴ : NontriviallyNormedField 𝕜
F : Type u_2
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
E : Type ?u.85634
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
n✝ : ℕ
f : 𝕜 → F
s : Set 𝕜
x✝¹ x✝ : 𝕜
hs : UniqueDiffOn 𝕜 s
hx✝ : x✝ ∈ s
n : ℕ
IH : ∀ {x : 𝕜}, x ∈ s → iteratedDerivWithin n f s x = ((fun g => derivWithin g s)^[n]) f x
x : 𝕜
hx : x ∈ s
⊢ derivWithin (iteratedDerivWithin n f s) s x = ((fun g => derivWithin g s) ∘ (fun g => derivWithin g s)^[n]) f x
Theorem: IsOpen.isConnected_iff_isPathConnected
File: Mathlib/Topology/PathConnected.lean

tactic: rw [isConnected_iff_connectedSpace, isPathConnected_iff_pathConnectedSpace]
state_before: X : Type u_1
Y : Type ?u.708006
inst✝² : TopologicalSpace X
inst✝¹ : TopologicalSpace Y
x y z : X
ι : Type ?u.708021
F : Set X
inst✝ : LocPathConnectedSpace X
U : Set X
U_op : IsOpen U
⊢ IsPathConnected U ↔ IsConnected U

tactic: haveI := locPathConnected_of_isOpen U_op
state_before: X : Type u_1
Y : Type ?u.708006
inst✝² : TopologicalSpace X
inst✝¹ : TopologicalSpace Y
x y z : X
ι : Type ?u.708021
F : Set X
inst✝ : LocPathConnectedSpace X
U : Set X
U_op : IsOpen U
⊢ PathConnectedSpace ↑U ↔ ConnectedSpace ↑U

tactic: exact pathConnectedSpace_iff_connectedSpace
state_before: X : Type u_1
Y : Type ?u.708006
inst✝² : TopologicalSpace X
inst✝¹ : TopologicalSpace Y
x y z : X
ι : Type ?u.708021
F : Set X
inst✝ : LocPathConnectedSpace X
U : Set X
U_op : IsOpen U
this : LocPathConnectedSpace ↑U
⊢ PathConnectedSpace ↑U ↔ ConnectedSpace ↑U
Theorem: Nat.prod_properDivisors_prime_pow
File: Mathlib/NumberTheory/Divisors.lean

tactic: simp [h, properDivisors_prime_pow]
state_before: n : ℕ
α : Type u_1
inst✝ : CommMonoid α
k p : ℕ
f : ℕ → α
h : Prime p
⊢ ∏ x in properDivisors (p ^ k), f x = ∏ x in range k, f (p ^ x)
Theorem: edist_inv_inv
File: Mathlib/Topology/MetricSpace/IsometricSMul.lean

tactic: rw [← edist_mul_left a, ← edist_mul_right _ _ b, mul_right_inv, one_mul, inv_mul_cancel_right,
  edist_comm]
state_before: M : Type u
G : Type v
X : Type w
inst✝⁶ : PseudoEMetricSpace X
inst✝⁵ : Group G
inst✝⁴ : MulAction G X
inst✝³ : IsometricSMul G X
inst✝² : PseudoEMetricSpace G
inst✝¹ : IsometricSMul G G
inst✝ : IsometricSMul Gᵐᵒᵖ G
a b : G
⊢ edist a⁻¹ b⁻¹ = edist a b
Theorem: CategoryTheory.Bicategory.leftUnitor_comp_inv
File: Mathlib/CategoryTheory/Bicategory/Basic.lean

tactic: simp
state_before: B : Type u
inst✝ : Bicategory B
a b c d e : B
f : a ⟶ b
g : b ⟶ c
⊢ (λ_ (f ≫ g)).inv = (λ_ f).inv ▷ g ≫ (α_ (𝟙 a) f g).hom
Theorem: Hyperreal.st_neg
File: Mathlib/Data/Real/Hyperreal.lean

tactic: rw [h.st_eq, (infinite_neg.2 h).st_eq, neg_zero]
state_before: x : ℝ*
h : Infinite x
⊢ st (-x) = -st x
Theorem: CategoryTheory.Sheaf.isSheaf_of_isLimit
File: Mathlib/CategoryTheory/Sites/Limits.lean

tactic: rw [Presheaf.isSheaf_iff_multifork]
state_before: C : Type u
inst✝³ : Category C
J : GrothendieckTopology C
D : Type w
inst✝² : Category D
K : Type z
inst✝¹ : SmallCategory K
inst✝ : HasLimitsOfShape K D
F : K ⥤ Sheaf J D
E : Cone (F ⋙ sheafToPresheaf J D)
hE : IsLimit E
⊢ Presheaf.IsSheaf J E.pt

tactic: intro X S
state_before: C : Type u
inst✝³ : Category C
J : GrothendieckTopology C
D : Type w
inst✝² : Category D
K : Type z
inst✝¹ : SmallCategory K
inst✝ : HasLimitsOfShape K D
F : K ⥤ Sheaf J D
E : Cone (F ⋙ sheafToPresheaf J D)
hE : IsLimit E
⊢ ∀ (X : C) (S : GrothendieckTopology.Cover J X), Nonempty (IsLimit (GrothendieckTopology.Cover.multifork S E.pt))

tactic: exact ⟨isLimitMultiforkOfIsLimit _ _ hE _ _⟩
state_before: C : Type u
inst✝³ : Category C
J : GrothendieckTopology C
D : Type w
inst✝² : Category D
K : Type z
inst✝¹ : SmallCategory K
inst✝ : HasLimitsOfShape K D
F : K ⥤ Sheaf J D
E : Cone (F ⋙ sheafToPresheaf J D)
hE : IsLimit E
X : C
S : GrothendieckTopology.Cover J X
⊢ Nonempty (IsLimit (GrothendieckTopology.Cover.multifork S E.pt))
Theorem: AddMonoidAlgebra.le_inf_support_mul
File: Mathlib/Algebra/MonoidAlgebra/Degree.lean

tactic: refine' OrderDual.ofDual_le_ofDual.mpr <| sup_support_mul_le (_) f g
state_before: R : Type u_3
A : Type u_2
T : Type u_1
B : Type ?u.19667
ι : Type ?u.19670
inst✝¹¹ : SemilatticeSup B
inst✝¹⁰ : OrderBot B
inst✝⁹ : SemilatticeInf T
inst✝⁸ : OrderTop T
inst✝⁷ : Semiring R
inst✝⁶ : Add A
inst✝⁵ : Add B
inst✝⁴ : Add T
inst✝³ : CovariantClass B B (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1
inst✝² : CovariantClass B B (Function.swap fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1
inst✝¹ : CovariantClass T T (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1
inst✝ : CovariantClass T T (Function.swap fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1
degt : A → T
degtm : ∀ {a b : A}, degt a + degt b ≤ degt (a + b)
f g : AddMonoidAlgebra R A
⊢ Finset.inf f.support degt + Finset.inf g.support degt ≤ Finset.inf (f * g).support degt

tactic: intros a b
state_before: R : Type u_3
A : Type u_2
T : Type u_1
B : Type ?u.19667
ι : Type ?u.19670
inst✝¹¹ : SemilatticeSup B
inst✝¹⁰ : OrderBot B
inst✝⁹ : SemilatticeInf T
inst✝⁸ : OrderTop T
inst✝⁷ : Semiring R
inst✝⁶ : Add A
inst✝⁵ : Add B
inst✝⁴ : Add T
inst✝³ : CovariantClass B B (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1
inst✝² : CovariantClass B B (Function.swap fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1
inst✝¹ : CovariantClass T T (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1
inst✝ : CovariantClass T T (Function.swap fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1
degt : A → T
degtm : ∀ {a b : A}, degt a + degt b ≤ degt (a + b)
f g : AddMonoidAlgebra R A
⊢ ∀ {a b : A}, degt (a + b) ≤ degt a + degt b

tactic: exact OrderDual.ofDual_le_ofDual.mp degtm
state_before: R : Type u_3
A : Type u_2
T : Type u_1
B : Type ?u.19667
ι : Type ?u.19670
inst✝¹¹ : SemilatticeSup B
inst✝¹⁰ : OrderBot B
inst✝⁹ : SemilatticeInf T
inst✝⁸ : OrderTop T
inst✝⁷ : Semiring R
inst✝⁶ : Add A
inst✝⁵ : Add B
inst✝⁴ : Add T
inst✝³ : CovariantClass B B (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1
inst✝² : CovariantClass B B (Function.swap fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1
inst✝¹ : CovariantClass T T (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1
inst✝ : CovariantClass T T (Function.swap fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1
degt : A → T
degtm : ∀ {a b : A}, degt a + degt b ≤ degt (a + b)
f g : AddMonoidAlgebra R A
a b : A
⊢ degt (a + b) ≤ degt a + degt b
Theorem: Ring.mul_inverse_cancel_right
File: Mathlib/Algebra/GroupWithZero/Units/Basic.lean

tactic: rw [mul_assoc, mul_inverse_cancel x h, mul_one]
state_before: α : Type ?u.6975
M₀ : Type u_1
G₀ : Type ?u.6981
M₀' : Type ?u.6984
G₀' : Type ?u.6987
F : Type ?u.6990
F' : Type ?u.6993
inst✝ : MonoidWithZero M₀
x y : M₀
h : IsUnit x
⊢ y * x * inverse x = y
Theorem: Int.bitwise_xor
File: Mathlib/Data/Int/Bitwise.lean

tactic: funext m n
state_before: ⊢ bitwise xor = lxor'

tactic: cases' m with m m <;> cases' n with n n <;> try {rfl}
  <;> simp only [bitwise, natBitwise, Bool.not_false, Bool.or_true,
    cond_false, cond_true, lor, Nat.ldiff', Bool.and_true, negSucc.injEq, Bool.false_xor,
    Bool.true_xor, Bool.and_false, Nat.land', Bool.not_true, ldiff', Nat.lor', lxor', Nat.lxor']
state_before: case h.h
m n : ℤ
⊢ bitwise xor m n = lxor' m n

tactic: . congr
  funext x y
  cases x <;> cases y <;> rfl
state_before: case h.h.ofNat.negSucc
m n : ℕ
⊢ Nat.bitwise' (fun x y => !xor x !y) m n = Nat.bitwise' xor m n

case h.h.negSucc.ofNat
m n : ℕ
⊢ Nat.bitwise' (fun x y => !xor (!x) y) m n = Nat.bitwise' xor m n

case h.h.negSucc.negSucc
m n : ℕ
⊢ ↑(Nat.bitwise' (fun x y => xor (!x) !y) m n) = ↑(Nat.bitwise' xor m n)

tactic: . congr
  funext x y
  cases x <;> cases y <;> rfl
state_before: case h.h.negSucc.ofNat
m n : ℕ
⊢ Nat.bitwise' (fun x y => !xor (!x) y) m n = Nat.bitwise' xor m n

case h.h.negSucc.negSucc
m n : ℕ
⊢ ↑(Nat.bitwise' (fun x y => xor (!x) !y) m n) = ↑(Nat.bitwise' xor m n)

tactic: . congr
  funext x y
  cases x <;> cases y <;> rfl
state_before: case h.h.negSucc.negSucc
m n : ℕ
⊢ ↑(Nat.bitwise' (fun x y => xor (!x) !y) m n) = ↑(Nat.bitwise' xor m n)

tactic: congr
state_before: case h.h.ofNat.negSucc
m n : ℕ
⊢ Nat.bitwise' (fun x y => !xor x !y) m n = Nat.bitwise' xor m n

tactic: funext x y
state_before: case h.h.ofNat.negSucc.e_f
m n : ℕ
⊢ (fun x y => !xor x !y) = xor

tactic: cases x <;> cases y <;> rfl
state_before: case h.h.ofNat.negSucc.e_f.h.h
m n : ℕ
x y : Bool
⊢ (!xor x !y) = xor x y

tactic: congr
state_before: case h.h.negSucc.ofNat
m n : ℕ
⊢ Nat.bitwise' (fun x y => !xor (!x) y) m n = Nat.bitwise' xor m n

tactic: funext x y
state_before: case h.h.negSucc.ofNat.e_f
m n : ℕ
⊢ (fun x y => !xor (!x) y) = xor

tactic: cases x <;> cases y <;> rfl
state_before: case h.h.negSucc.ofNat.e_f.h.h
m n : ℕ
x y : Bool
⊢ (!xor (!x) y) = xor x y

tactic: congr
state_before: case h.h.negSucc.negSucc
m n : ℕ
⊢ ↑(Nat.bitwise' (fun x y => xor (!x) !y) m n) = ↑(Nat.bitwise' xor m n)

tactic: funext x y
state_before: case h.h.negSucc.negSucc.e_a.e_f
m n : ℕ
⊢ (fun x y => xor (!x) !y) = xor

tactic: cases x <;> cases y <;> rfl
state_before: case h.h.negSucc.negSucc.e_a.e_f.h.h
m n : ℕ
x y : Bool
⊢ (xor (!x) !y) = xor x y
Theorem: MeasureTheory.set_integral_pos_iff_support_of_nonneg_ae
File: Mathlib/MeasureTheory/Integral/SetIntegral.lean

tactic: rw [integral_pos_iff_support_of_nonneg_ae hf hfi, Measure.restrict_apply₀]
state_before: α : Type u_1
β : Type ?u.262207
E : Type ?u.262210
F : Type ?u.262213
inst✝³ : MeasurableSpace α
inst✝² : NormedAddCommGroup E
f✝ g : α → E
s t : Set α
μ ν : Measure α
l l' : Filter α
inst✝¹ : CompleteSpace E
inst✝ : NormedSpace ℝ E
f : α → ℝ
hf : 0 ≤ᵐ[Measure.restrict μ s] f
hfi : IntegrableOn f s
⊢ (0 < ∫ (x : α) in s, f x ∂μ) ↔ 0 < ↑↑μ (support f ∩ s)

tactic: rw [support_eq_preimage]
state_before: α : Type u_1
β : Type ?u.262207
E : Type ?u.262210
F : Type ?u.262213
inst✝³ : MeasurableSpace α
inst✝² : NormedAddCommGroup E
f✝ g : α → E
s t : Set α
μ ν : Measure α
l l' : Filter α
inst✝¹ : CompleteSpace E
inst✝ : NormedSpace ℝ E
f : α → ℝ
hf : 0 ≤ᵐ[Measure.restrict μ s] f
hfi : IntegrableOn f s
⊢ NullMeasurableSet (support f)

tactic: exact hfi.aestronglyMeasurable.aemeasurable.nullMeasurable (measurableSet_singleton 0).compl
state_before: α : Type u_1
β : Type ?u.262207
E : Type ?u.262210
F : Type ?u.262213
inst✝³ : MeasurableSpace α
inst✝² : NormedAddCommGroup E
f✝ g : α → E
s t : Set α
μ ν : Measure α
l l' : Filter α
inst✝¹ : CompleteSpace E
inst✝ : NormedSpace ℝ E
f : α → ℝ
hf : 0 ≤ᵐ[Measure.restrict μ s] f
hfi : IntegrableOn f s
⊢ NullMeasurableSet (f ⁻¹' {0}ᶜ)
Theorem: DiscreteValuationRing.addVal_def
File: Mathlib/RingTheory/DiscreteValuationRing/Basic.lean

tactic: rw [addVal, addValuation_apply, hr, eq_of_associated_left
    (associated_of_irreducible R hϖ (Classical.choose_spec (exists_prime R)).irreducible),
  eq_of_associated_right (Associated.symm ⟨u, mul_comm _ _⟩),
  multiplicity_pow_self_of_prime (PrincipalIdealRing.irreducible_iff_prime.1 hϖ)]
state_before: R : Type u_1
inst✝² : CommRing R
inst✝¹ : IsDomain R
inst✝ : DiscreteValuationRing R
r : R
u : Rˣ
ϖ : R
hϖ : Irreducible ϖ
n : ℕ
hr : r = ↑u * ϖ ^ n
⊢ ↑(addVal R) r = ↑n
Theorem: Set.intersecting_iff_eq_empty_of_subsingleton
File: Mathlib/Combinatorics/SetFamily/Intersecting.lean

tactic: refine'
  subsingleton_of_subsingleton.intersecting.trans
    ⟨not_imp_comm.2 fun h => subsingleton_of_subsingleton.eq_singleton_of_mem _, _⟩
state_before: α : Type u_1
inst✝² : SemilatticeInf α
inst✝¹ : OrderBot α
s✝ t : Set α
a b c : α
inst✝ : Subsingleton α
s : Set α
⊢ Intersecting s ↔ s = ∅

tactic: obtain ⟨a, ha⟩ := nonempty_iff_ne_empty.2 h
state_before: case refine'_1
α : Type u_1
inst✝² : SemilatticeInf α
inst✝¹ : OrderBot α
s✝ t : Set α
a b c : α
inst✝ : Subsingleton α
s : Set α
h : ¬s = ∅
⊢ ⊥ ∈ s

tactic: rwa [Subsingleton.elim ⊥ a]
state_before: case refine'_1.intro
α : Type u_1
inst✝² : SemilatticeInf α
inst✝¹ : OrderBot α
s✝ t : Set α
a✝ b c : α
inst✝ : Subsingleton α
s : Set α
h : ¬s = ∅
a : α
ha : a ∈ s
⊢ ⊥ ∈ s

tactic: rintro rfl
state_before: case refine'_2
α : Type u_1
inst✝² : SemilatticeInf α
inst✝¹ : OrderBot α
s✝ t : Set α
a b c : α
inst✝ : Subsingleton α
s : Set α
⊢ s = ∅ → s ≠ {⊥}

tactic: exact (Set.singleton_nonempty _).ne_empty.symm
state_before: case refine'_2
α : Type u_1
inst✝² : SemilatticeInf α
inst✝¹ : OrderBot α
s t : Set α
a b c : α
inst✝ : Subsingleton α
⊢ ∅ ≠ {⊥}
Theorem: Nat.decreasingInduction_succ
File: Mathlib/Data/Nat/Basic.lean

tactic: dsimp only [decreasingInduction]
state_before: m✝ n✝ k : ℕ
P : ℕ → Sort u_1
h : (n : ℕ) → P (n + 1) → P n
m n : ℕ
mn : m ≤ n
msn : m ≤ n + 1
hP : P (n + 1)
⊢ decreasingInduction h msn hP = decreasingInduction h mn (h n hP)

tactic: rw [leRecOn_succ]
state_before: m✝ n✝ k : ℕ
P : ℕ → Sort u_1
h : (n : ℕ) → P (n + 1) → P n
m n : ℕ
mn : m ≤ n
msn : m ≤ n + 1
hP : P (n + 1)
⊢ leRecOn msn (fun {k} ih hsk => ih (h k hsk)) (fun h => h) hP =
    leRecOn mn (fun {k} ih hsk => ih (h k hsk)) (fun h => h) (h n hP)
Theorem: IsMetricSeparated.finite_iUnion_right_iff
File: Mathlib/Topology/MetricSpace/MetricSeparated.lean

tactic: simpa only [@comm _ _ s] using finite_iUnion_left_iff hI
state_before: X : Type u_2
inst✝ : EMetricSpace X
s✝ t✝ : Set X
x y : X
ι : Type u_1
I : Set ι
hI : Set.Finite I
s : Set X
t : ι → Set X
⊢ IsMetricSeparated s (⋃ (i : ι) (_ : i ∈ I), t i) ↔ ∀ (i : ι), i ∈ I → IsMetricSeparated s (t i)
Theorem: Complex.abs_cpow_of_ne_zero
File: Mathlib/Analysis/SpecialFunctions/Pow/Real.lean

tactic: rw [cpow_def_of_ne_zero hz, abs_exp, mul_re, log_re, log_im, Real.exp_sub,
  Real.rpow_def_of_pos (abs.pos hz)]
state_before: z : ℂ
hz : z ≠ 0
w : ℂ
⊢ ↑abs (z ^ w) = ↑abs z ^ w.re / Real.exp (arg z * w.im)
Theorem: update_le_update_iff'
File: Mathlib/Order/Basic.lean

tactic: simp [update_le_update_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 ≤ update x i b ↔ a ≤ b
Theorem: Ordinal.div_mul_cancel
File: Mathlib/SetTheory/Ordinal/Arithmetic.lean

tactic: rw [mul_div_cancel _ a0]
state_before: α : Type ?u.251122
β : Type ?u.251125
γ : Type ?u.251128
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
a : Ordinal
a0 : a ≠ 0
b : Ordinal
⊢ a * (a * b / a) = a * b
Theorem: UnionFind.rank_eq
File: Mathlib/Data/UnionFind.lean

tactic: simp [rank, h, H.rank_eq]
state_before: α : Type u_1
self : UnionFind α
n : ℕ
m : UFModel n
H : UFModel.Models self.arr m
i : ℕ
h : i < size self
⊢ rank self i = UFModel.rank m i
Theorem: Real.tan_arccos
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Inverse.lean

tactic: rw [arccos, tan_pi_div_two_sub, tan_arcsin, inv_div]
state_before: x : ℝ
⊢ tan (arccos x) = sqrt (1 - x ^ 2) / x
Theorem: MulSalemSpencer.mul_right
File: Mathlib/Combinatorics/Additive/SalemSpencer.lean

tactic: rintro _ _ _ ⟨b, hb, rfl⟩ ⟨c, hc, rfl⟩ ⟨d, hd, rfl⟩ h
state_before: F : Type ?u.80185
α : Type u_1
β : Type ?u.80191
𝕜 : Type ?u.80194
E : Type ?u.80197
inst✝ : CancelCommMonoid α
s : Set α
a : α
hs : MulSalemSpencer s
⊢ MulSalemSpencer ((fun x => x * a) '' s)

tactic: rw [mul_mul_mul_comm, mul_mul_mul_comm d] at h
state_before: case intro.intro.intro.intro.intro.intro
F : Type ?u.80185
α : Type u_1
β : Type ?u.80191
𝕜 : Type ?u.80194
E : Type ?u.80197
inst✝ : CancelCommMonoid α
s : Set α
a : α
hs : MulSalemSpencer s
b : α
hb : b ∈ s
c : α
hc : c ∈ s
d : α
hd : d ∈ s
h : (fun x => x * a) b * (fun x => x * a) c = (fun x => x * a) d * (fun x => x * a) d
⊢ (fun x => x * a) b = (fun x => x * a) c

tactic: rw [hs hb hc hd (mul_right_cancel h)]
state_before: case intro.intro.intro.intro.intro.intro
F : Type ?u.80185
α : Type u_1
β : Type ?u.80191
𝕜 : Type ?u.80194
E : Type ?u.80197
inst✝ : CancelCommMonoid α
s : Set α
a : α
hs : MulSalemSpencer s
b : α
hb : b ∈ s
c : α
hc : c ∈ s
d : α
hd : d ∈ s
h : b * c * (a * a) = d * d * (a * a)
⊢ (fun x => x * a) b = (fun x => x * a) c
Theorem: Finset.lt_sup'_iff
File: Mathlib/Data/Finset/Lattice.lean

tactic: rw [← WithBot.coe_lt_coe, coe_sup', Finset.lt_sup_iff]
state_before: F : Type ?u.302432
α : Type u_1
β : Type ?u.302438
γ : Type ?u.302441
ι : Type u_2
κ : Type ?u.302447
inst✝ : LinearOrder α
s : Finset ι
H : Finset.Nonempty s
f : ι → α
a : α
⊢ a < sup' s H f ↔ ∃ b, b ∈ s ∧ a < f b

tactic: exact exists_congr (fun _ => and_congr_right' WithBot.coe_lt_coe)
state_before: F : Type ?u.302432
α : Type u_1
β : Type ?u.302438
γ : Type ?u.302441
ι : Type u_2
κ : Type ?u.302447
inst✝ : LinearOrder α
s : Finset ι
H : Finset.Nonempty s
f : ι → α
a : α
⊢ (∃ b, b ∈ s ∧ ↑a < (WithBot.some ∘ f) b) ↔ ∃ b, b ∈ s ∧ a < f b
Theorem: Real.contDiff_arctan
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/ArctanDeriv.lean

tactic: simpa
state_before: n : ℕ∞
x : ℝ
this : cos (arctan x) ≠ 0
⊢ ↑1 / cos (↑(LocalHomeomorph.symm tanLocalHomeomorph) x) ^ 2 ≠ 0
Theorem: Polynomial.coeff_X_of_ne_one
File: Mathlib/Data/Polynomial/Basic.lean

tactic: rw [coeff_X, if_neg hn.symm]
state_before: R : Type u
a b : R
m n✝ : ℕ
inst✝ : Semiring R
p q : R[X]
n : ℕ
hn : n ≠ 1
⊢ coeff X n = 0
Theorem: MeasureTheory.Measure.count_ne_zero'
File: Mathlib/MeasureTheory/Measure/MeasureSpace.lean

tactic: rw [Ne.def, count_eq_zero_iff' s_mble]
state_before: α : Type u_1
β : Type ?u.384442
γ : Type ?u.384445
δ : Type ?u.384448
ι : Type ?u.384451
R : Type ?u.384454
R' : Type ?u.384457
m0 : MeasurableSpace α
inst✝² : MeasurableSpace β
inst✝¹ : MeasurableSpace γ
μ μ₁ μ₂ μ₃ ν ν' ν₁ ν₂ : Measure α
s s' t : Set α
inst✝ : MeasurableSpace α
hs' : Set.Nonempty s
s_mble : MeasurableSet s
⊢ ↑↑count s ≠ 0

tactic: exact hs'.ne_empty
state_before: α : Type u_1
β : Type ?u.384442
γ : Type ?u.384445
δ : Type ?u.384448
ι : Type ?u.384451
R : Type ?u.384454
R' : Type ?u.384457
m0 : MeasurableSpace α
inst✝² : MeasurableSpace β
inst✝¹ : MeasurableSpace γ
μ μ₁ μ₂ μ₃ ν ν' ν₁ ν₂ : Measure α
s s' t : Set α
inst✝ : MeasurableSpace α
hs' : Set.Nonempty s
s_mble : MeasurableSet s
⊢ ¬s = ∅
Theorem: Cardinal.mk_biUnion_le
File: Mathlib/SetTheory/Cardinal/Basic.lean

tactic: rw [biUnion_eq_iUnion]
state_before: α✝ β ι α : Type u
A : ι → Set α
s : Set ι
⊢ (#↑(⋃ (x : ι) (_ : x ∈ s), A x)) ≤ (#↑s) * ⨆ (x : ↑s), #↑(A ↑x)

tactic: apply mk_iUnion_le
state_before: α✝ β ι α : Type u
A : ι → Set α
s : Set ι
⊢ (#↑(⋃ (x : ↑s), A ↑x)) ≤ (#↑s) * ⨆ (x : ↑s), #↑(A ↑x)
Theorem: Finset.right_mem_Icc
File: Mathlib/Data/Finset/LocallyFinite.lean

tactic: simp only [mem_Icc, and_true_iff, le_rfl]
state_before: ι : Type ?u.4512
α : Type u_1
inst✝¹ : Preorder α
inst✝ : LocallyFiniteOrder α
a a₁ a₂ b b₁ b₂ c x : α
⊢ b ∈ Icc a b ↔ a ≤ b
Theorem: Basis.repr_symm_apply
File: Mathlib/LinearAlgebra/Basis.lean

tactic: simp
state_before: ι : Type u_1
ι' : Type ?u.35738
R : Type u_2
R₂ : Type ?u.35744
K : Type ?u.35747
M : Type u_3
M' : Type ?u.35753
M'' : Type ?u.35756
V : Type u
V' : Type ?u.35761
inst✝⁴ : Semiring R
inst✝³ : AddCommMonoid M
inst✝² : Module R M
inst✝¹ : AddCommMonoid M'
inst✝ : Module R M'
b b₁ : Basis ι R M
i : ι
c : R
x : M
v : ι →₀ R
⊢ ↑(LinearEquiv.symm b.repr) v = ↑(LinearEquiv.symm b.repr) (Finsupp.sum v Finsupp.single)

tactic: rw [Finsupp.sum, LinearEquiv.map_sum]
state_before: ι : Type u_1
ι' : Type ?u.35738
R : Type u_2
R₂ : Type ?u.35744
K : Type ?u.35747
M : Type u_3
M' : Type ?u.35753
M'' : Type ?u.35756
V : Type u
V' : Type ?u.35761
inst✝⁴ : Semiring R
inst✝³ : AddCommMonoid M
inst✝² : Module R M
inst✝¹ : AddCommMonoid M'
inst✝ : Module R M'
b b₁ : Basis ι R M
i : ι
c : R
x : M
v : ι →₀ R
⊢ ↑(LinearEquiv.symm b.repr) (Finsupp.sum v Finsupp.single) =
    ∑ i in v.support, ↑(LinearEquiv.symm b.repr) (Finsupp.single i (↑v i))

tactic: simp [repr_symm_single, Finsupp.total_apply, Finsupp.sum]
state_before: ι : Type u_1
ι' : Type ?u.35738
R : Type u_2
R₂ : Type ?u.35744
K : Type ?u.35747
M : Type u_3
M' : Type ?u.35753
M'' : Type ?u.35756
V : Type u
V' : Type ?u.35761
inst✝⁴ : Semiring R
inst✝³ : AddCommMonoid M
inst✝² : Module R M
inst✝¹ : AddCommMonoid M'
inst✝ : Module R M'
b b₁ : Basis ι R M
i : ι
c : R
x : M
v : ι →₀ R
⊢ ∑ i in v.support, ↑(LinearEquiv.symm b.repr) (Finsupp.single i (↑v i)) = ↑(Finsupp.total ι M R ↑b) v
Theorem: exists_nhds_one_split4
File: Mathlib/Topology/Algebra/Monoid.lean

tactic: rcases exists_nhds_one_split hu with ⟨W, W1, h⟩
state_before: ι : Type ?u.161653
α : Type ?u.161656
X : Type ?u.161659
M : Type u_1
N : Type ?u.161665
inst✝³ : TopologicalSpace X
inst✝² : TopologicalSpace M
inst✝¹ : Monoid M
inst✝ : ContinuousMul M
u : Set M
hu : u ∈ 𝓝 1
⊢ ∃ V, V ∈ 𝓝 1 ∧ ∀ {v w s t : M}, v ∈ V → w ∈ V → s ∈ V → t ∈ V → v * w * s * t ∈ u

tactic: rcases exists_nhds_one_split W1 with ⟨V, V1, h'⟩
state_before: case intro.intro
ι : Type ?u.161653
α : Type ?u.161656
X : Type ?u.161659
M : Type u_1
N : Type ?u.161665
inst✝³ : TopologicalSpace X
inst✝² : TopologicalSpace M
inst✝¹ : Monoid M
inst✝ : ContinuousMul M
u : Set M
hu : u ∈ 𝓝 1
W : Set M
W1 : W ∈ 𝓝 1
h : ∀ (v : M), v ∈ W → ∀ (w : M), w ∈ W → v * w ∈ u
⊢ ∃ V, V ∈ 𝓝 1 ∧ ∀ {v w s t : M}, v ∈ V → w ∈ V → s ∈ V → t ∈ V → v * w * s * t ∈ u

tactic: use V, V1
state_before: case intro.intro.intro.intro
ι : Type ?u.161653
α : Type ?u.161656
X : Type ?u.161659
M : Type u_1
N : Type ?u.161665
inst✝³ : TopologicalSpace X
inst✝² : TopologicalSpace M
inst✝¹ : Monoid M
inst✝ : ContinuousMul M
u : Set M
hu : u ∈ 𝓝 1
W : Set M
W1 : W ∈ 𝓝 1
h : ∀ (v : M), v ∈ W → ∀ (w : M), w ∈ W → v * w ∈ u
V : Set M
V1 : V ∈ 𝓝 1
h' : ∀ (v : M), v ∈ V → ∀ (w : M), w ∈ V → v * w ∈ W
⊢ ∃ V, V ∈ 𝓝 1 ∧ ∀ {v w s t : M}, v ∈ V → w ∈ V → s ∈ V → t ∈ V → v * w * s * t ∈ u

tactic: intro v w s t v_in w_in s_in t_in
state_before: case intro.intro.intro.intro
ι : Type ?u.161653
α : Type ?u.161656
X : Type ?u.161659
M : Type u_1
N : Type ?u.161665
inst✝³ : TopologicalSpace X
inst✝² : TopologicalSpace M
inst✝¹ : Monoid M
inst✝ : ContinuousMul M
u : Set M
hu : u ∈ 𝓝 1
W : Set M
W1 : W ∈ 𝓝 1
h : ∀ (v : M), v ∈ W → ∀ (w : M), w ∈ W → v * w ∈ u
V : Set M
V1 : V ∈ 𝓝 1
h' : ∀ (v : M), v ∈ V → ∀ (w : M), w ∈ V → v * w ∈ W
⊢ ∀ {v w s t : M}, v ∈ V → w ∈ V → s ∈ V → t ∈ V → v * w * s * t ∈ u

tactic: simpa only [mul_assoc] using h _ (h' v v_in w w_in) _ (h' s s_in t t_in)
state_before: case intro.intro.intro.intro
ι : Type ?u.161653
α : Type ?u.161656
X : Type ?u.161659
M : Type u_1
N : Type ?u.161665
inst✝³ : TopologicalSpace X
inst✝² : TopologicalSpace M
inst✝¹ : Monoid M
inst✝ : ContinuousMul M
u : Set M
hu : u ∈ 𝓝 1
W : Set M
W1 : W ∈ 𝓝 1
h : ∀ (v : M), v ∈ W → ∀ (w : M), w ∈ W → v * w ∈ u
V : Set M
V1 : V ∈ 𝓝 1
h' : ∀ (v : M), v ∈ V → ∀ (w : M), w ∈ V → v * w ∈ W
v w s t : M
v_in : v ∈ V
w_in : w ∈ V
s_in : s ∈ V
t_in : t ∈ V
⊢ v * w * s * t ∈ u