tasksource/leandojo huggingface dataset:
Theorem: preconnectedSpace_iff_connectedComponent
File: Mathlib/Topology/Connected.lean

tactic: constructor
state_before: α : Type u
β : Type v
ι : Type ?u.63690
π : ι → Type ?u.63695
inst✝ : TopologicalSpace α
s t u v : Set α
⊢ PreconnectedSpace α ↔ ∀ (x : α), connectedComponent x = univ

tactic: intro h x
state_before: case mp
α : Type u
β : Type v
ι : Type ?u.63690
π : ι → Type ?u.63695
inst✝ : TopologicalSpace α
s t u v : Set α
⊢ PreconnectedSpace α → ∀ (x : α), connectedComponent x = univ

tactic: exact eq_univ_of_univ_subset <| isPreconnected_univ.subset_connectedComponent (mem_univ x)
state_before: case mp
α : Type u
β : Type v
ι : Type ?u.63690
π : ι → Type ?u.63695
inst✝ : TopologicalSpace α
s t u v : Set α
h : PreconnectedSpace α
x : α
⊢ connectedComponent x = univ

tactic: intro h
state_before: case mpr
α : Type u
β : Type v
ι : Type ?u.63690
π : ι → Type ?u.63695
inst✝ : TopologicalSpace α
s t u v : Set α
⊢ (∀ (x : α), connectedComponent x = univ) → PreconnectedSpace α

tactic: cases' isEmpty_or_nonempty α with hα hα
state_before: case mpr
α : Type u
β : Type v
ι : Type ?u.63690
π : ι → Type ?u.63695
inst✝ : TopologicalSpace α
s t u v : Set α
h : ∀ (x : α), connectedComponent x = univ
⊢ PreconnectedSpace α

tactic: exact ⟨by rw [univ_eq_empty_iff.mpr hα]; exact isPreconnected_empty⟩
state_before: case mpr.inl
α : Type u
β : Type v
ι : Type ?u.63690
π : ι → Type ?u.63695
inst✝ : TopologicalSpace α
s t u v : Set α
h : ∀ (x : α), connectedComponent x = univ
hα : IsEmpty α
⊢ PreconnectedSpace α

tactic: rw [univ_eq_empty_iff.mpr hα]
state_before: α : Type u
β : Type v
ι : Type ?u.63690
π : ι → Type ?u.63695
inst✝ : TopologicalSpace α
s t u v : Set α
h : ∀ (x : α), connectedComponent x = univ
hα : IsEmpty α
⊢ IsPreconnected univ

tactic: exact isPreconnected_empty
state_before: α : Type u
β : Type v
ι : Type ?u.63690
π : ι → Type ?u.63695
inst✝ : TopologicalSpace α
s t u v : Set α
h : ∀ (x : α), connectedComponent x = univ
hα : IsEmpty α
⊢ IsPreconnected ∅

tactic: exact ⟨by rw [← h (Classical.choice hα)]; exact isPreconnected_connectedComponent⟩
state_before: case mpr.inr
α : Type u
β : Type v
ι : Type ?u.63690
π : ι → Type ?u.63695
inst✝ : TopologicalSpace α
s t u v : Set α
h : ∀ (x : α), connectedComponent x = univ
hα : Nonempty α
⊢ PreconnectedSpace α

tactic: rw [← h (Classical.choice hα)]
state_before: α : Type u
β : Type v
ι : Type ?u.63690
π : ι → Type ?u.63695
inst✝ : TopologicalSpace α
s t u v : Set α
h : ∀ (x : α), connectedComponent x = univ
hα : Nonempty α
⊢ IsPreconnected univ

tactic: exact isPreconnected_connectedComponent
state_before: α : Type u
β : Type v
ι : Type ?u.63690
π : ι → Type ?u.63695
inst✝ : TopologicalSpace α
s t u v : Set α
h : ∀ (x : α), connectedComponent x = univ
hα : Nonempty α
⊢ IsPreconnected (connectedComponent (Classical.choice hα))
Theorem: Polynomial.degree_eq_degree_of_associated
File: Mathlib/Data/Polynomial/RingDivision.lean

tactic: let ⟨u, hu⟩ := h
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]
h : Associated p q
⊢ degree p = degree q

tactic: simp [hu.symm]
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]
h : Associated p q
u : R[X]ˣ
hu : p * ↑u = q
⊢ degree p = degree q
Theorem: Finset.piecewise_erase_univ
File: Mathlib/Data/Fintype/Basic.lean

tactic: rw [← compl_singleton, piecewise_compl, piecewise_singleton]
state_before: α : Type u_2
β : Type ?u.23061
γ : Type ?u.23064
inst✝¹ : Fintype α
s t : Finset α
δ : α → Sort u_1
inst✝ : DecidableEq α
a : α
f g : (a : α) → δ a
⊢ piecewise (erase univ a) f g = update f a (g a)
Theorem: BoxIntegral.integral_neg
File: Mathlib/Analysis/BoxIntegral/Basic.lean

tactic: rw [integral, integral, dif_neg h, dif_neg (mt Integrable.of_neg h), neg_zero]
state_before: ι : Type u
E : Type v
F : Type w
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedSpace ℝ E
inst✝² : NormedAddCommGroup F
inst✝¹ : NormedSpace ℝ F
I J : Box ι
π : TaggedPrepartition I
inst✝ : Fintype ι
l : IntegrationParams
f g : (ι → ℝ) → E
vol : ι →ᵇᵃ[⊤] E →L[ℝ] F
y y' : F
h : ¬Integrable I l f vol
⊢ integral I l (-f) vol = -integral I l f vol
Theorem: Nat.ArithmeticFunction.sigma_zero_apply_prime_pow
File: Mathlib/NumberTheory/ArithmeticFunction.lean

tactic: rw [sigma_zero_apply, divisors_prime_pow hp, card_map, card_range]
state_before: R : Type ?u.525397
p i : ℕ
hp : Prime p
⊢ ↑(σ 0) (p ^ i) = i + 1
Theorem: sub_smul_dslope
File: Mathlib/Analysis/Calculus/Dslope.lean

tactic: rcases eq_or_ne b a with (rfl | hne) <;> simp [dslope_of_ne, *]
state_before: 𝕜 : Type u_2
E : Type u_1
inst✝² : NontriviallyNormedField 𝕜
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
f✝ : 𝕜 → E
a✝ b✝ : 𝕜
s : Set 𝕜
f : 𝕜 → E
a b : 𝕜
⊢ (b - a) • dslope f a b = f b - f a
Theorem: IntermediateField.rank_bot
File: Mathlib/FieldTheory/Adjoin.lean

tactic: rw [rank_eq_one_iff]
state_before: F : Type u_2
inst✝² : Field F
E : Type u_1
inst✝¹ : Field E
inst✝ : Algebra F E
α : E
S : Set E
K L : IntermediateField F E
⊢ Module.rank F { x // x ∈ ⊥ } = 1
Theorem: Polynomial.leadingCoeff_map_of_leadingCoeff_ne_zero
File: Mathlib/Data/Polynomial/Eval.lean

tactic: unfold leadingCoeff
state_before: R : Type u
S : Type v
T : Type w
ι : Type y
a b : R
m n : ℕ
inst✝¹ : Semiring R
p q r : R[X]
inst✝ : Semiring S
f✝ f : R →+* S
hf : ↑f (leadingCoeff p) ≠ 0
⊢ leadingCoeff (map f p) = ↑f (leadingCoeff p)

tactic: rw [coeff_map, natDegree_map_of_leadingCoeff_ne_zero f hf]
state_before: R : Type u
S : Type v
T : Type w
ι : Type y
a b : R
m n : ℕ
inst✝¹ : Semiring R
p q r : R[X]
inst✝ : Semiring S
f✝ f : R →+* S
hf : ↑f (leadingCoeff p) ≠ 0
⊢ coeff (map f p) (natDegree (map f p)) = ↑f (coeff p (natDegree p))
Theorem: div_neg
File: Mathlib/Algebra/Field/Basic.lean

tactic: rw [← div_neg_eq_neg_div]
state_before: α : Type ?u.35372
β : Type ?u.35375
K : Type u_1
inst✝¹ : DivisionMonoid K
inst✝ : HasDistribNeg K
a✝ b a : K
⊢ a / -b = -(a / b)
Theorem: eventually_mapsTo_of_isCompact_absorbing_of_isOpen_of_omegaLimit_subset
File: Mathlib/Dynamics/OmegaLimit.lean

tactic: rcases eventually_closure_subset_of_isCompact_absorbing_of_isOpen_of_omegaLimit_subset f ϕ s hc₁
    hc₂ hn₁ hn₂ with
  ⟨u, hu_mem, hu⟩
state_before: τ : Type u_2
α : Type u_3
β : Type u_1
ι : Type ?u.73083
inst✝¹ : TopologicalSpace β
f : Filter τ
ϕ : τ → α → β
s s₁ s₂ : Set α
inst✝ : T2Space β
c : Set β
hc₁ : IsCompact c
hc₂ : ∀ᶠ (t : τ) in f, MapsTo (ϕ t) s c
n : Set β
hn₁ : IsOpen n
hn₂ : ω f ϕ s ⊆ n
⊢ ∀ᶠ (t : τ) in f, MapsTo (ϕ t) s n

tactic: refine' mem_of_superset hu_mem fun t ht x hx ↦ _
state_before: case intro.intro
τ : Type u_2
α : Type u_3
β : Type u_1
ι : Type ?u.73083
inst✝¹ : TopologicalSpace β
f : Filter τ
ϕ : τ → α → β
s s₁ s₂ : Set α
inst✝ : T2Space β
c : Set β
hc₁ : IsCompact c
hc₂ : ∀ᶠ (t : τ) in f, MapsTo (ϕ t) s c
n : Set β
hn₁ : IsOpen n
hn₂ : ω f ϕ s ⊆ n
u : Set τ
hu_mem : u ∈ f
hu : closure (image2 ϕ u s) ⊆ n
⊢ ∀ᶠ (t : τ) in f, MapsTo (ϕ t) s n

tactic: exact hu (subset_closure <| mem_image2_of_mem ht hx)
state_before: case intro.intro
τ : Type u_2
α : Type u_3
β : Type u_1
ι : Type ?u.73083
inst✝¹ : TopologicalSpace β
f : Filter τ
ϕ : τ → α → β
s s₁ s₂ : Set α
inst✝ : T2Space β
c : Set β
hc₁ : IsCompact c
hc₂ : ∀ᶠ (t : τ) in f, MapsTo (ϕ t) s c
n : Set β
hn₁ : IsOpen n
hn₂ : ω f ϕ s ⊆ n
u : Set τ
hu_mem : u ∈ f
hu : closure (image2 ϕ u s) ⊆ n
t : τ
ht : t ∈ u
x : α
hx : x ∈ s
⊢ ϕ t x ∈ n
Theorem: PartENat.dom_of_le_natCast
File: Mathlib/Data/Nat/PartENat.lean

tactic: exact dom_of_le_some h
state_before: x : PartENat
y : ℕ
h : x ≤ ↑y
⊢ x.Dom
Theorem: left_lt_lineMap_iff_lt
File: Mathlib/LinearAlgebra/AffineSpace/Ordered.lean

tactic: rw [lineMap_apply_zero]
state_before: k : Type u_1
E : Type u_2
PE : Type ?u.64959
inst✝³ : OrderedRing k
inst✝² : OrderedAddCommGroup E
inst✝¹ : Module k E
inst✝ : OrderedSMul k E
a a' b b' : E
r r' : k
h : 0 < r
⊢ a < ↑(lineMap a b) r ↔ ↑(lineMap a b) 0 < ↑(lineMap a b) r
Theorem: left_inv_eq_right_inv
File: Mathlib/Algebra/Group/Defs.lean

tactic: rw [← one_mul c, ← hba, mul_assoc, hac, mul_one b]
state_before: G : Type ?u.41375
M : Type u
inst✝ : Monoid M
a b c : M
hba : b * a = 1
hac : a * c = 1
⊢ b = c
Theorem: UniformSpace.complete_of_convergent_controlled_sequences
File: Mathlib/Topology/UniformSpace/Cauchy.lean

tactic: obtain ⟨U', -, hU'⟩ := (𝓤 α).exists_antitone_seq
state_before: α : Type u
β : Type v
inst✝¹ : UniformSpace α
inst✝ : IsCountablyGenerated (𝓤 α)
U : ℕ → Set (α × α)
U_mem : ∀ (n : ℕ), U n ∈ 𝓤 α
HU : ∀ (u : ℕ → α), (∀ (N m n : ℕ), N ≤ m → N ≤ n → (u m, u n) ∈ U N) → ∃ a, Tendsto u atTop (𝓝 a)
⊢ CompleteSpace α

tactic: have Hmem : ∀ n, U n ∩ U' n ∈ 𝓤 α := fun n => inter_mem (U_mem n) (hU'.2 ⟨n, Subset.refl _⟩)
state_before: case intro.intro
α : Type u
β : Type v
inst✝¹ : UniformSpace α
inst✝ : IsCountablyGenerated (𝓤 α)
U : ℕ → Set (α × α)
U_mem : ∀ (n : ℕ), U n ∈ 𝓤 α
HU : ∀ (u : ℕ → α), (∀ (N m n : ℕ), N ≤ m → N ≤ n → (u m, u n) ∈ U N) → ∃ a, Tendsto u atTop (𝓝 a)
U' : ℕ → Set (α × α)
hU' : ∀ {s : Set (α × α)}, s ∈ 𝓤 α ↔ ∃ i, U' i ⊆ s
⊢ CompleteSpace α

tactic: refine ⟨fun hf => (HU (seq hf Hmem) fun N m n hm hn => ?_).imp <|
  le_nhds_of_seq_tendsto_nhds _ _ fun s hs => ?_⟩
state_before: case intro.intro
α : Type u
β : Type v
inst✝¹ : UniformSpace α
inst✝ : IsCountablyGenerated (𝓤 α)
U : ℕ → Set (α × α)
U_mem : ∀ (n : ℕ), U n ∈ 𝓤 α
HU : ∀ (u : ℕ → α), (∀ (N m n : ℕ), N ≤ m → N ≤ n → (u m, u n) ∈ U N) → ∃ a, Tendsto u atTop (𝓝 a)
U' : ℕ → Set (α × α)
hU' : ∀ {s : Set (α × α)}, s ∈ 𝓤 α ↔ ∃ i, U' i ⊆ s
Hmem : ∀ (n : ℕ), U n ∩ U' n ∈ 𝓤 α
⊢ CompleteSpace α

tactic: exact inter_subset_left _ _ (seq_pair_mem hf Hmem hm hn)
state_before: case intro.intro.refine_1
α : Type u
β : Type v
inst✝¹ : UniformSpace α
inst✝ : IsCountablyGenerated (𝓤 α)
U : ℕ → Set (α × α)
U_mem : ∀ (n : ℕ), U n ∈ 𝓤 α
HU : ∀ (u : ℕ → α), (∀ (N m n : ℕ), N ≤ m → N ≤ n → (u m, u n) ∈ U N) → ∃ a, Tendsto u atTop (𝓝 a)
U' : ℕ → Set (α × α)
hU' : ∀ {s : Set (α × α)}, s ∈ 𝓤 α ↔ ∃ i, U' i ⊆ s
Hmem : ∀ (n : ℕ), U n ∩ U' n ∈ 𝓤 α
f✝ : Filter α
hf : Cauchy f✝
N m n : ℕ
hm : N ≤ m
hn : N ≤ n
⊢ (SequentiallyComplete.seq hf Hmem m, SequentiallyComplete.seq hf Hmem n) ∈ U N

tactic: rcases hU'.1 hs with ⟨N, hN⟩
state_before: case intro.intro.refine_2
α : Type u
β : Type v
inst✝¹ : UniformSpace α
inst✝ : IsCountablyGenerated (𝓤 α)
U : ℕ → Set (α × α)
U_mem : ∀ (n : ℕ), U n ∈ 𝓤 α
HU : ∀ (u : ℕ → α), (∀ (N m n : ℕ), N ≤ m → N ≤ n → (u m, u n) ∈ U N) → ∃ a, Tendsto u atTop (𝓝 a)
U' : ℕ → Set (α × α)
hU' : ∀ {s : Set (α × α)}, s ∈ 𝓤 α ↔ ∃ i, U' i ⊆ s
Hmem : ∀ (n : ℕ), U n ∩ U' n ∈ 𝓤 α
f✝ : Filter α
hf : Cauchy f✝
s : Set (α × α)
hs : s ∈ 𝓤 α
⊢ ∃ n, U n ∩ U' n ⊆ s

tactic: exact ⟨N, Subset.trans (inter_subset_right _ _) hN⟩
state_before: case intro.intro.refine_2.intro
α : Type u
β : Type v
inst✝¹ : UniformSpace α
inst✝ : IsCountablyGenerated (𝓤 α)
U : ℕ → Set (α × α)
U_mem : ∀ (n : ℕ), U n ∈ 𝓤 α
HU : ∀ (u : ℕ → α), (∀ (N m n : ℕ), N ≤ m → N ≤ n → (u m, u n) ∈ U N) → ∃ a, Tendsto u atTop (𝓝 a)
U' : ℕ → Set (α × α)
hU' : ∀ {s : Set (α × α)}, s ∈ 𝓤 α ↔ ∃ i, U' i ⊆ s
Hmem : ∀ (n : ℕ), U n ∩ U' n ∈ 𝓤 α
f✝ : Filter α
hf : Cauchy f✝
s : Set (α × α)
hs : s ∈ 𝓤 α
N : ℕ
hN : U' N ⊆ s
⊢ ∃ n, U n ∩ U' n ⊆ s
Theorem: tsum_geometric_inv_two_ge
File: Mathlib/Analysis/SpecificLimits/Basic.lean

tactic: have B : ((Finset.range n).sum fun i : ℕ => ite (n ≤ i) ((2⁻¹ : ℝ) ^ i) 0) = 0 :=
  Finset.sum_eq_zero fun i hi =>
    ite_eq_right_iff.2 fun h => (lt_irrefl _ ((Finset.mem_range.1 hi).trans_le h)).elim
state_before: α : Type ?u.233518
β : Type ?u.233521
ι : Type ?u.233524
n : ℕ
A : Summable fun i => if n ≤ i then 2⁻¹ ^ i else 0
⊢ (∑' (i : ℕ), if n ≤ i then 2⁻¹ ^ i else 0) = 2 * 2⁻¹ ^ n

tactic: simp only [← _root_.sum_add_tsum_nat_add n A, B, if_true, zero_add, zero_le',
  le_add_iff_nonneg_left, pow_add, _root_.tsum_mul_right, tsum_geometric_inv_two]
state_before: α : Type ?u.233518
β : Type ?u.233521
ι : Type ?u.233524
n : ℕ
A : Summable fun i => if n ≤ i then 2⁻¹ ^ i else 0
B : (∑ i in Finset.range n, if n ≤ i then 2⁻¹ ^ i else 0) = 0
⊢ (∑' (i : ℕ), if n ≤ i then 2⁻¹ ^ i else 0) = 2 * 2⁻¹ ^ n

tactic: intro i
state_before: α : Type ?u.233518
β : Type ?u.233521
ι : Type ?u.233524
n : ℕ
⊢ ∀ (b : ℕ), (if n ≤ b then 2⁻¹ ^ b else 0) ≤ (1 / 2) ^ b

tactic: by_cases hi : n ≤ i <;> simp [hi]
state_before: α : Type ?u.233518
β : Type ?u.233521
ι : Type ?u.233524
n i : ℕ
⊢ (if n ≤ i then 2⁻¹ ^ i else 0) ≤ (1 / 2) ^ i

tactic: apply pow_nonneg
state_before: case neg
α : Type ?u.233518
β : Type ?u.233521
ι : Type ?u.233524
n i : ℕ
hi : ¬n ≤ i
⊢ 0 ≤ 2 ^ i

tactic: exact zero_le_two
state_before: case neg.H
α : Type ?u.233518
β : Type ?u.233521
ι : Type ?u.233524
n i : ℕ
hi : ¬n ≤ i
⊢ 0 ≤ 2
Theorem: SimpleGraph.Walk.darts_takeUntil_subset
File: Mathlib/Combinatorics/SimpleGraph/Connectivity.lean

tactic: rw [← take_spec p h, darts_append, List.mem_append]
state_before: V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
inst✝ : DecidableEq V
u v w : V
p : Walk G v w
h : u ∈ support p
x : Dart G
hx : x ∈ darts (takeUntil p u h)
⊢ x ∈ darts p

tactic: exact Or.inl hx
state_before: V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
inst✝ : DecidableEq V
u v w : V
p : Walk G v w
h : u ∈ support p
x : Dart G
hx : x ∈ darts (takeUntil p u h)
⊢ x ∈ darts (takeUntil p u h) ∨ x ∈ darts (dropUntil p u h)
Theorem: Nat.ArithmeticFunction.cardDistinctFactors_zero
File: Mathlib/NumberTheory/ArithmeticFunction.lean

tactic: simp
state_before: R : Type ?u.568779
⊢ ↑ω 0 = 0
Theorem: Complex.conj_eq_iff_real
File: Mathlib/Data/Complex/Basic.lean

tactic: rw [e, conj_ofReal]
state_before: z : ℂ
x✝ : ∃ r, z = ↑r
h : ℝ
e : z = ↑h
⊢ ↑(starRingEnd ℂ) z = z
Theorem: CategoryTheory.Arrow.iso_w
File: Mathlib/CategoryTheory/Arrow.lean

tactic: have eq := Arrow.hom.congr_right e.inv_hom_id
state_before: T : Type u
inst✝ : Category T
f g : Arrow T
e : f ≅ g
⊢ g.hom = e.inv.left ≫ f.hom ≫ e.hom.right

tactic: rw [Arrow.comp_right, Arrow.id_right] at eq
state_before: T : Type u
inst✝ : Category T
f g : Arrow T
e : f ≅ g
eq : (e.inv ≫ e.hom).right = (𝟙 g).right
⊢ g.hom = e.inv.left ≫ f.hom ≫ e.hom.right

tactic: erw [Arrow.w_assoc, eq, Category.comp_id]
state_before: T : Type u
inst✝ : Category T
f g : Arrow T
e : f ≅ g
eq : e.inv.right ≫ e.hom.right = 𝟙 g.right
⊢ g.hom = e.inv.left ≫ f.hom ≫ e.hom.right
Theorem: Bool.and_eq_true
File: src/lean/Init/SimpLemmas.lean

tactic: cases a <;> cases b <;> decide
state_before: a b : Bool
⊢ ((a && b) = true) = (a = true ∧ b = true)
Theorem: CategoryTheory.Limits.IsLimit.conePointsIsoOfNatIso_inv_comp
File: Mathlib/CategoryTheory/Limits/IsLimit.lean

tactic: simp
state_before: J : Type u₁
inst✝² : Category J
K : Type u₂
inst✝¹ : Category K
C : Type u₃
inst✝ : Category C
F✝ : J ⥤ C
t✝ : Cone F✝
F G : J ⥤ C
s : Cone F
t : Cone G
P : IsLimit s
Q : IsLimit t
w : F ≅ G
j : J
⊢ (conePointsIsoOfNatIso P Q w).inv ≫ s.π.app j = t.π.app j ≫ w.inv.app j
Theorem: Multiset.product_singleton
File: Mathlib/Data/Multiset/Bind.lean

tactic: simp only [SProd.sprod, product, bind_singleton, map_singleton]
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.58929
δ : Type ?u.58932
a : α
b : β
s : Multiset α
t : Multiset β
⊢ {a} ×ˢ {b} = {(a, b)}
Theorem: Metric.dense_iff
File: Mathlib/Topology/MetricSpace/Basic.lean

tactic: simp only [mem_closure_iff, Set.Nonempty, exists_prop, mem_inter_iff, mem_ball', and_comm]
state_before: α : Type u
β : Type v
X : Type ?u.306162
ι : Type ?u.306165
inst✝ : PseudoMetricSpace α
x✝ y z : α
ε ε₁ ε₂ : ℝ
s✝ s : Set α
x : α
⊢ x ∈ closure s ↔ ∀ (r : ℝ), r > 0 → Set.Nonempty (ball x r ∩ s)
Theorem: Real.exp_strictMono
File: Mathlib/Data/Complex/Exponential.lean

tactic: rw [← sub_add_cancel y x, Real.exp_add]
state_before: x✝ y✝ x y : ℝ
h : x < y
⊢ exp x < exp y

tactic: exact (lt_mul_iff_one_lt_left (exp_pos _)).2
    (lt_of_lt_of_le (by linarith) (add_one_le_exp_of_nonneg (by linarith)))
state_before: x✝ y✝ x y : ℝ
h : x < y
⊢ exp x < exp (y - x) * exp x

tactic: linarith
state_before: x✝ y✝ x y : ℝ
h : x < y
⊢ 1 < y - x + 1

tactic: linarith
state_before: x✝ y✝ x y : ℝ
h : x < y
⊢ 0 ≤ y - x
Theorem: Nat.WithBot.add_eq_two_iff
File: Mathlib/Data/Nat/WithBot.lean

tactic: rcases n, m with ⟨_ | _, _ | _⟩
state_before: n m : WithBot ℕ
⊢ n + m = 2 ↔ n = 0 ∧ m = 2 ∨ n = 1 ∧ m = 1 ∨ n = 2 ∧ m = 0

tactic: any_goals refine' ⟨fun h => Option.noConfusion h, fun h => _⟩; aesop
state_before: case none.none

⊢ none + none = 2 ↔ none = 0 ∧ none = 2 ∨ none = 1 ∧ none = 1 ∨ none = 2 ∧ none = 0

case none.some
val✝ : ℕ
⊢ none + some val✝ = 2 ↔ none = 0 ∧ some val✝ = 2 ∨ none = 1 ∧ some val✝ = 1 ∨ none = 2 ∧ some val✝ = 0

case some.none
val✝ : ℕ
⊢ some val✝ + none = 2 ↔ some val✝ = 0 ∧ none = 2 ∨ some val✝ = 1 ∧ none = 1 ∨ some val✝ = 2 ∧ none = 0

case some.some
val✝¹ val✝ : ℕ
⊢ some val✝¹ + some val✝ = 2 ↔
    some val✝¹ = 0 ∧ some val✝ = 2 ∨ some val✝¹ = 1 ∧ some val✝ = 1 ∨ some val✝¹ = 2 ∧ some val✝ = 0

tactic: repeat' erw [WithBot.coe_eq_coe]
state_before: case some.some
val✝¹ val✝ : ℕ
⊢ some val✝¹ + some val✝ = 2 ↔
    some val✝¹ = 0 ∧ some val✝ = 2 ∨ some val✝¹ = 1 ∧ some val✝ = 1 ∨ some val✝¹ = 2 ∧ some val✝ = 0

tactic: exact Nat.add_eq_two_iff
state_before: case some.some
val✝¹ val✝ : ℕ
⊢ (fun x x_1 => x + x_1) val✝¹ val✝ = ↑2 ↔ val✝¹ = 0 ∧ val✝ = ↑2 ∨ val✝¹ = 1 ∧ val✝ = 1 ∨ val✝¹ = ↑2 ∧ val✝ = 0

tactic: refine' ⟨fun h => Option.noConfusion h, fun h => _⟩
state_before: case some.some
val✝¹ val✝ : ℕ
⊢ some val✝¹ + some val✝ = 2 ↔
    some val✝¹ = 0 ∧ some val✝ = 2 ∨ some val✝¹ = 1 ∧ some val✝ = 1 ∨ some val✝¹ = 2 ∧ some val✝ = 0

tactic: aesop
state_before: case some.none
val✝ : ℕ
h : some val✝ = 0 ∧ none = 2 ∨ some val✝ = 1 ∧ none = 1 ∨ some val✝ = 2 ∧ none = 0
⊢ some val✝ + none = 2

tactic: erw [WithBot.coe_eq_coe]
state_before: case some.some
val✝¹ val✝ : ℕ
⊢ (fun x x_1 => x + x_1) val✝¹ val✝ = ↑2 ↔ val✝¹ = 0 ∧ val✝ = ↑2 ∨ val✝¹ = 1 ∧ val✝ = 1 ∨ val✝¹ = ↑2 ∧ val✝ = 0
Theorem: SimpleGraph.isAcyclic_iff_forall_edge_isBridge
File: Mathlib/Combinatorics/SimpleGraph/Acyclic.lean

tactic: simp [isAcyclic_iff_forall_adj_isBridge, Sym2.forall]
state_before: V : Type u
G : SimpleGraph V
⊢ IsAcyclic G ↔ ∀ ⦃e : Sym2 V⦄, e ∈ edgeSet G → IsBridge G e
Theorem: Nat.testBit_eq_inth
File: Mathlib/Data/Nat/Bitwise.lean

tactic: induction' i with i ih generalizing n
state_before: n i : ℕ
⊢ testBit n i = List.getI (bits n) i

tactic: conv_lhs => rw [← bit_decomp n]
state_before: case succ
n✝ i : ℕ
ih : ∀ (n : ℕ), testBit n i = List.getI (bits n) i
n : ℕ
⊢ testBit n (succ i) = List.getI (bits n) (succ i)

tactic: rw [testBit_succ, ih n.div2, div2_bits_eq_tail]
state_before: case succ
n✝ i : ℕ
ih : ∀ (n : ℕ), testBit n i = List.getI (bits n) i
n : ℕ
⊢ testBit (bit (bodd n) (div2 n)) (succ i) = List.getI (bits n) (succ i)

tactic: cases n.bits <;> simp
state_before: case succ
n✝ i : ℕ
ih : ∀ (n : ℕ), testBit n i = List.getI (bits n) i
n : ℕ
⊢ List.getI (List.tail (bits n)) i = List.getI (bits n) (succ i)

tactic: simp [testBit, shiftr, bodd_eq_bits_head, List.getI_zero_eq_headI]
state_before: case zero
n✝ n : ℕ
⊢ testBit n zero = List.getI (bits n) zero
Theorem: Finset.prod_preimage
File: Mathlib/Data/Finset/Preimage.lean

tactic: classical
  rw [prod_preimage', prod_filter_of_ne]
  exact fun x hx => Not.imp_symm (hg x hx)
state_before: α : Type u
β : Type v
ι : Sort w
γ : Type x
inst✝ : CommMonoid β
f : α → γ
s : Finset γ
hf : InjOn f (f ⁻¹' ↑s)
g : γ → β
hg : ∀ (x : γ), x ∈ s → ¬x ∈ Set.range f → g x = 1
⊢ ∏ x in preimage s f hf, g (f x) = ∏ x in s, g x

tactic: rw [prod_preimage', prod_filter_of_ne]
state_before: α : Type u
β : Type v
ι : Sort w
γ : Type x
inst✝ : CommMonoid β
f : α → γ
s : Finset γ
hf : InjOn f (f ⁻¹' ↑s)
g : γ → β
hg : ∀ (x : γ), x ∈ s → ¬x ∈ Set.range f → g x = 1
⊢ ∏ x in preimage s f hf, g (f x) = ∏ x in s, g x

tactic: exact fun x hx => Not.imp_symm (hg x hx)
state_before: α : Type u
β : Type v
ι : Sort w
γ : Type x
inst✝ : CommMonoid β
f : α → γ
s : Finset γ
hf : InjOn f (f ⁻¹' ↑s)
g : γ → β
hg : ∀ (x : γ), x ∈ s → ¬x ∈ Set.range f → g x = 1
⊢ ∀ (x : γ), x ∈ s → g x ≠ 1 → x ∈ Set.range f
Theorem: Nat.ArithmeticFunction.vonMangoldt_apply_pow
File: Mathlib/NumberTheory/VonMangoldt.lean

tactic: simp only [vonMangoldt_apply, isPrimePow_pow_iff hk, pow_minFac hk]
state_before: n k : ℕ
hk : k ≠ 0
⊢ ↑Λ (n ^ k) = ↑Λ n
Theorem: Function.Antiperiodic.mul_const'
File: Mathlib/Algebra/Periodic.lean

tactic: simpa only [div_eq_mul_inv] using h.mul_const ha
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.201763
f g : α → β
c c₁ c₂ x : α
inst✝¹ : DivisionSemiring α
inst✝ : Neg β
h : Antiperiodic f c
a : α
ha : a ≠ 0
⊢ Antiperiodic (fun x => f (x * a)) (c / a)
Theorem: Finset.piecewise_univ
File: Mathlib/Data/Fintype/Basic.lean

tactic: ext i
state_before: α : Type u_1
β : Type ?u.21892
γ : Type ?u.21895
inst✝¹ : Fintype α
s t : Finset α
inst✝ : (i : α) → Decidable (i ∈ univ)
δ : α → Sort u_2
f g : (i : α) → δ i
⊢ piecewise univ f g = f

tactic: simp [piecewise]
state_before: case h
α : Type u_1
β : Type ?u.21892
γ : Type ?u.21895
inst✝¹ : Fintype α
s t : Finset α
inst✝ : (i : α) → Decidable (i ∈ univ)
δ : α → Sort u_2
f g : (i : α) → δ i
i : α
⊢ piecewise univ f g i = f i
Theorem: Computability.decode_encodeNat
File: Mathlib/Computability/Encoding.lean

tactic: intro n
state_before: ⊢ ∀ (n : ℕ), decodeNat (encodeNat n) = n

tactic: conv_rhs => rw [← Num.to_of_nat n]
state_before: n : ℕ
⊢ decodeNat (encodeNat n) = n

tactic: exact congr_arg ((↑) : Num → ℕ) (decode_encodeNum n)
state_before: n : ℕ
⊢ decodeNat (encodeNat n) = ↑↑n
Theorem: Cardinal.nfp_lt_ord_of_isRegular
File: Mathlib/SetTheory/Cardinal/Cofinality.lean

tactic: rw [hc.cof_eq]
state_before: α : Type ?u.164415
r : α → α → Prop
f : Ordinal → Ordinal
c : Cardinal
hc : IsRegular c
hc' : c ≠ ℵ₀
hf : ∀ (i : Ordinal), i < ord c → f i < ord c
a : Ordinal
⊢ ℵ₀ < Ordinal.cof (ord c)

tactic: exact lt_of_le_of_ne hc.1 hc'.symm
state_before: α : Type ?u.164415
r : α → α → Prop
f : Ordinal → Ordinal
c : Cardinal
hc : IsRegular c
hc' : c ≠ ℵ₀
hf : ∀ (i : Ordinal), i < ord c → f i < ord c
a : Ordinal
⊢ ℵ₀ < c
Theorem: Polynomial.hasseDeriv_zero'
File: Mathlib/Data/Polynomial/HasseDeriv.lean

tactic: simp only [hasseDeriv_apply, tsub_zero, Nat.choose_zero_right, Nat.cast_one, one_mul,
  sum_monomial_eq]
state_before: R : Type u_1
inst✝ : Semiring R
k : ℕ
f : R[X]
⊢ ↑(hasseDeriv 0) f = f
Theorem: Polynomial.coeff_mem_frange
File: Mathlib/RingTheory/Polynomial/Basic.lean

tactic: simp only [frange, exists_prop, mem_support_iff, Finset.mem_image, Ne.def]
state_before: R : Type u
S : Type ?u.48578
inst✝ : Semiring R
p : R[X]
n : ℕ
h : coeff p n ≠ 0
⊢ coeff p n ∈ frange p

tactic: exact ⟨n, h, rfl⟩
state_before: R : Type u
S : Type ?u.48578
inst✝ : Semiring R
p : R[X]
n : ℕ
h : coeff p n ≠ 0
⊢ ∃ a, ¬coeff p a = 0 ∧ coeff p a = coeff p n