tasksource/leandojo huggingface dataset:
Theorem: HasFDerivAt.fderiv
File: Mathlib/Analysis/Calculus/FDeriv/Basic.lean

tactic: ext
state_before: 𝕜 : Type u_1
inst✝⁸ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type u_3
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type ?u.268497
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
G' : Type ?u.268592
inst✝¹ : NormedAddCommGroup G'
inst✝ : NormedSpace 𝕜 G'
f f₀ f₁ g : E → F
f' f₀' f₁' g' e : E →L[𝕜] F
x : E
s t : Set E
L L₁ L₂ : Filter E
h : HasFDerivAt f f' x
⊢ fderiv 𝕜 f x = f'

tactic: rw [h.unique h.differentiableAt.hasFDerivAt]
state_before: case h
𝕜 : Type u_1
inst✝⁸ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type u_3
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type ?u.268497
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
G' : Type ?u.268592
inst✝¹ : NormedAddCommGroup G'
inst✝ : NormedSpace 𝕜 G'
f f₀ f₁ g : E → F
f' f₀' f₁' g' e : E →L[𝕜] F
x : E
s t : Set E
L L₁ L₂ : Filter E
h : HasFDerivAt f f' x
x✝ : E
⊢ ↑(fderiv 𝕜 f x) x✝ = ↑f' x✝
Theorem: Dfinsupp.sigmaCurry_smul
File: Mathlib/Data/Dfinsupp/Basic.lean

tactic: ext (i j)
state_before: ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
dec : DecidableEq ι
κ : Type ?u.615890
α : ι → Type u_1
δ : (i : ι) → α i → Type v
inst✝² : Monoid γ
inst✝¹ : (i : ι) → (j : α i) → AddMonoid (δ i j)
inst✝ : (i : ι) → (j : α i) → DistribMulAction γ (δ i j)
r : γ
f : Π₀ (i : (i : ι) × α i), δ i.fst i.snd
⊢ sigmaCurry (r • f) = r • sigmaCurry f

tactic: rw [@smul_apply _ _ (fun i => Π₀ j, δ i j) _ _ _ _ (sigmaCurry _), smul_apply, sigmaCurry_apply,
  sigmaCurry_apply, smul_apply]
state_before: case h.h
ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
dec : DecidableEq ι
κ : Type ?u.615890
α : ι → Type u_1
δ : (i : ι) → α i → Type v
inst✝² : Monoid γ
inst✝¹ : (i : ι) → (j : α i) → AddMonoid (δ i j)
inst✝ : (i : ι) → (j : α i) → DistribMulAction γ (δ i j)
r : γ
f : Π₀ (i : (i : ι) × α i), δ i.fst i.snd
i : ι
j : α i
⊢ ↑(↑(sigmaCurry (r • f)) i) j = ↑(↑(r • sigmaCurry f) i) j
Theorem: AntilipschitzWith.mul_le_nndist
File: Mathlib/Topology/MetricSpace/Antilipschitz.lean

tactic: simpa only [div_eq_inv_mul] using NNReal.div_le_of_le_mul' (hf.le_mul_nndist x y)
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.2568
inst✝¹ : PseudoMetricSpace α
inst✝ : PseudoMetricSpace β
K : ℝ≥0
f : α → β
hf : AntilipschitzWith K f
x y : α
⊢ K⁻¹ * nndist x y ≤ nndist (f x) (f y)
Theorem: Real.Angle.tan_periodic
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Angle.lean

tactic: intro θ
state_before: ⊢ Function.Periodic tan ↑π

tactic: induction θ using Real.Angle.induction_on
state_before: θ : Angle
⊢ tan (θ + ↑π) = tan θ

tactic: rw [← coe_add, tan_coe, tan_coe]
state_before: case h
x✝ : ℝ
⊢ tan (↑x✝ + ↑π) = tan ↑x✝

tactic: exact Real.tan_periodic _
state_before: case h
x✝ : ℝ
⊢ Real.tan (x✝ + π) = Real.tan x✝
Theorem: IsAssociatedPrime.map_of_injective
File: Mathlib/RingTheory/Ideal/AssociatedPrime.lean

tactic: obtain ⟨x, rfl⟩ := h.2
state_before: R : Type u_1
inst✝⁴ : CommRing R
I J : Ideal R
M : Type u_2
inst✝³ : AddCommGroup M
inst✝² : Module R M
M' : Type u_3
inst✝¹ : AddCommGroup M'
inst✝ : Module R M'
f : M →ₗ[R] M'
h : IsAssociatedPrime I M
hf : Function.Injective ↑f
⊢ IsAssociatedPrime I M'

tactic: refine' ⟨h.1, ⟨f x, _⟩⟩
state_before: case intro
R : Type u_1
inst✝⁴ : CommRing R
J : Ideal R
M : Type u_2
inst✝³ : AddCommGroup M
inst✝² : Module R M
M' : Type u_3
inst✝¹ : AddCommGroup M'
inst✝ : Module R M'
f : M →ₗ[R] M'
hf : Function.Injective ↑f
x : M
h : IsAssociatedPrime (Submodule.annihilator (Submodule.span R {x})) M
⊢ IsAssociatedPrime (Submodule.annihilator (Submodule.span R {x})) M'

tactic: ext r
state_before: case intro
R : Type u_1
inst✝⁴ : CommRing R
J : Ideal R
M : Type u_2
inst✝³ : AddCommGroup M
inst✝² : Module R M
M' : Type u_3
inst✝¹ : AddCommGroup M'
inst✝ : Module R M'
f : M →ₗ[R] M'
hf : Function.Injective ↑f
x : M
h : IsAssociatedPrime (Submodule.annihilator (Submodule.span R {x})) M
⊢ Submodule.annihilator (Submodule.span R {x}) = Submodule.annihilator (Submodule.span R {↑f x})

tactic: rw [Submodule.mem_annihilator_span_singleton, Submodule.mem_annihilator_span_singleton, ←
  map_smul, ← f.map_zero, hf.eq_iff]
state_before: case intro.h
R : Type u_1
inst✝⁴ : CommRing R
J : Ideal R
M : Type u_2
inst✝³ : AddCommGroup M
inst✝² : Module R M
M' : Type u_3
inst✝¹ : AddCommGroup M'
inst✝ : Module R M'
f : M →ₗ[R] M'
hf : Function.Injective ↑f
x : M
h : IsAssociatedPrime (Submodule.annihilator (Submodule.span R {x})) M
r : R
⊢ r ∈ Submodule.annihilator (Submodule.span R {x}) ↔ r ∈ Submodule.annihilator (Submodule.span R {↑f x})
Theorem: MvPolynomial.degreeOf_X
File: Mathlib/Data/MvPolynomial/Variables.lean

tactic: by_cases c : i = j
state_before: R : Type u
S : Type v
σ : Type u_1
τ : Type ?u.307598
r : R
e : ℕ
n m : σ
s : σ →₀ ℕ
inst✝² : CommSemiring R
p q : MvPolynomial σ R
inst✝¹ : DecidableEq σ
i j : σ
inst✝ : Nontrivial R
⊢ degreeOf i (X j) = if i = j then 1 else 0

tactic: simp [c, if_false, degreeOf_def, degrees_X]
state_before: case neg
R : Type u
S : Type v
σ : Type u_1
τ : Type ?u.307598
r : R
e : ℕ
n m : σ
s : σ →₀ ℕ
inst✝² : CommSemiring R
p q : MvPolynomial σ R
inst✝¹ : DecidableEq σ
i j : σ
inst✝ : Nontrivial R
c : ¬i = j
⊢ degreeOf i (X j) = if i = j then 1 else 0

tactic: simp only [c, if_true, eq_self_iff_true, degreeOf_def, degrees_X, Multiset.count_singleton]
state_before: case pos
R : Type u
S : Type v
σ : Type u_1
τ : Type ?u.307598
r : R
e : ℕ
n m : σ
s : σ →₀ ℕ
inst✝² : CommSemiring R
p q : MvPolynomial σ R
inst✝¹ : DecidableEq σ
i j : σ
inst✝ : Nontrivial R
c : i = j
⊢ degreeOf i (X j) = if i = j then 1 else 0
Theorem: CategoryTheory.LaxMonoidalFunctor.associativity_inv
File: Mathlib/CategoryTheory/Monoidal/Functor.lean

tactic: rw [Iso.eq_inv_comp, ← F.associativity_assoc, ← F.toFunctor.map_comp, Iso.hom_inv_id,
  F.toFunctor.map_id, comp_id]
state_before: C : Type u₁
inst✝³ : Category C
inst✝² : MonoidalCategory C
D : Type u₂
inst✝¹ : Category D
inst✝ : MonoidalCategory D
F : LaxMonoidalFunctor C D
X Y Z : C
⊢ (𝟙 (F.obj X) ⊗ μ F Y Z) ≫ μ F X (Y ⊗ Z) ≫ F.map (α_ X Y Z).inv =
    (α_ (F.obj X) (F.obj Y) (F.obj Z)).inv ≫ (μ F X Y ⊗ 𝟙 (F.obj Z)) ≫ μ F (X ⊗ Y) Z
Theorem: SubMulAction.mem_one'
File: Mathlib/Algebra/Algebra/Operations.lean

tactic: rw [algebraMap_eq_smul_one]
state_before: R : Type u
A : Type v
inst✝² : CommSemiring R
inst✝¹ : Semiring A
inst✝ : Algebra R A
x : A
r : R
⊢ (fun r => r • 1) r = x ↔ ↑(algebraMap R A) r = x
Theorem: cluster_point_of_compact
File: Mathlib/Topology/SubsetProperties.lean

tactic: simpa using isCompact_univ (show f ≤ 𝓟 univ by simp)
state_before: α : Type u
β : Type v
ι : Type ?u.73726
π : ι → Type ?u.73731
inst✝³ : TopologicalSpace α
inst✝² : TopologicalSpace β
s t : Set α
inst✝¹ : CompactSpace α
f : Filter α
inst✝ : NeBot f
⊢ ∃ x, ClusterPt x f

tactic: simp
state_before: α : Type u
β : Type v
ι : Type ?u.73726
π : ι → Type ?u.73731
inst✝³ : TopologicalSpace α
inst✝² : TopologicalSpace β
s t : Set α
inst✝¹ : CompactSpace α
f : Filter α
inst✝ : NeBot f
⊢ f ≤ 𝓟 univ
Theorem: Fin.rev_le_rev
File: Mathlib/Data/Fin/Basic.lean

tactic: simp only [le_iff_val_le_val, val_rev, tsub_le_tsub_iff_left (Nat.add_one_le_iff.2 j.is_lt),
  add_le_add_iff_right, iff_self]
state_before: n m : ℕ
i j : Fin n
⊢ ↑rev i ≤ ↑rev j ↔ j ≤ i
Theorem: padicValNat.div_pow
File: Mathlib/NumberTheory/Padics/PadicVal.lean

tactic: rw [padicValNat.div_of_dvd dvd, padicValNat.prime_pow]
state_before: p a b : ℕ
hp : Fact (Nat.Prime p)
dvd : p ^ a ∣ b
⊢ padicValNat p (b / p ^ a) = padicValNat p b - a
Theorem: Matrix.blockDiagonal_conjTranspose
File: Mathlib/Data/Matrix/Block.lean

tactic: simp only [conjTranspose, blockDiagonal_transpose]
state_before: l : Type ?u.132794
m : Type u_2
n : Type u_3
o : Type u_4
p : Type ?u.132806
q : Type ?u.132809
m' : o → Type ?u.132814
n' : o → Type ?u.132819
p' : o → Type ?u.132824
R : Type ?u.132827
S : Type ?u.132830
α✝ : Type ?u.132833
β : Type ?u.132836
inst✝⁴ : DecidableEq o
inst✝³ : Zero α✝
inst✝² : Zero β
α : Type u_1
inst✝¹ : AddMonoid α
inst✝ : StarAddMonoid α
M : o → Matrix m n α
⊢ (blockDiagonal M)ᴴ = blockDiagonal fun k => (M k)ᴴ

tactic: rw [blockDiagonal_map _ star (star_zero α)]
state_before: l : Type ?u.132794
m : Type u_2
n : Type u_3
o : Type u_4
p : Type ?u.132806
q : Type ?u.132809
m' : o → Type ?u.132814
n' : o → Type ?u.132819
p' : o → Type ?u.132824
R : Type ?u.132827
S : Type ?u.132830
α✝ : Type ?u.132833
β : Type ?u.132836
inst✝⁴ : DecidableEq o
inst✝³ : Zero α✝
inst✝² : Zero β
α : Type u_1
inst✝¹ : AddMonoid α
inst✝ : StarAddMonoid α
M : o → Matrix m n α
⊢ map (blockDiagonal fun k => (M k)ᵀ) star = blockDiagonal fun k => map (M k)ᵀ star
Theorem: Set.iInter₂_eq_empty_iff
File: Mathlib/Data/Set/Lattice.lean

tactic: simp only [eq_empty_iff_forall_not_mem, mem_iInter, not_forall]
state_before: α : Type u_1
β : Type ?u.131162
γ : Type ?u.131165
ι : Sort u_2
ι' : Sort ?u.131171
ι₂ : Sort ?u.131174
κ : ι → Sort u_3
κ₁ : ι → Sort ?u.131184
κ₂ : ι → Sort ?u.131189
κ' : ι' → Sort ?u.131194
s : (i : ι) → κ i → Set α
⊢ (⋂ (i : ι) (j : κ i), s i j) = ∅ ↔ ∀ (a : α), ∃ i j, ¬a ∈ s i j
Theorem: ENNReal.toReal_le_add'
File: Mathlib/Data/Real/ENNReal.lean

tactic: refine le_trans (toReal_mono' hle ?_) toReal_add_le
state_before: α : Type ?u.797651
β : Type ?u.797654
a b c d : ℝ≥0∞
r p q : ℝ≥0
hle : a ≤ b + c
hb : b = ⊤ → a = ⊤
hc : c = ⊤ → a = ⊤
⊢ ENNReal.toReal a ≤ ENNReal.toReal b + ENNReal.toReal c

tactic: simpa only [add_eq_top, or_imp] using And.intro hb hc
state_before: α : Type ?u.797651
β : Type ?u.797654
a b c d : ℝ≥0∞
r p q : ℝ≥0
hle : a ≤ b + c
hb : b = ⊤ → a = ⊤
hc : c = ⊤ → a = ⊤
⊢ b + c = ⊤ → a = ⊤
Theorem: List.set_eq_nil
File: Mathlib/Data/List/Basic.lean

tactic: cases l <;> cases n <;> simp only [set]
state_before: ι : Type ?u.222965
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ l : List α
n : ℕ
a : α
⊢ set l n a = [] ↔ l = []
Theorem: AddMonoid.IsTorsion.module_of_torsion
File: Mathlib/GroupTheory/Torsion.lean

tactic: obtain ⟨n, npos, hn⟩ := (isOfFinAddOrder_iff_nsmul_eq_zero _).mp (tR 1)
state_before: G : Type ?u.172795
H : Type ?u.172798
R : Type u_1
M : Type u_2
inst✝² : AddCommMonoid M
inst✝¹ : Semiring R
inst✝ : Module R M
tR : IsTorsion R
f : M
⊢ ∃ n, 0 < n ∧ n • f = 0

tactic: exact ⟨n, npos, by simp only [nsmul_eq_smul_cast R _ f, ← nsmul_one, hn, zero_smul]⟩
state_before: case intro.intro
G : Type ?u.172795
H : Type ?u.172798
R : Type u_1
M : Type u_2
inst✝² : AddCommMonoid M
inst✝¹ : Semiring R
inst✝ : Module R M
tR : IsTorsion R
f : M
n : ℕ
npos : 0 < n
hn : n • 1 = 0
⊢ ∃ n, 0 < n ∧ n • f = 0

tactic: simp only [nsmul_eq_smul_cast R _ f, ← nsmul_one, hn, zero_smul]
state_before: G : Type ?u.172795
H : Type ?u.172798
R : Type u_1
M : Type u_2
inst✝² : AddCommMonoid M
inst✝¹ : Semiring R
inst✝ : Module R M
tR : IsTorsion R
f : M
n : ℕ
npos : 0 < n
hn : n • 1 = 0
⊢ n • f = 0
Theorem: PowerSeries.order_monomial_of_ne_zero
File: Mathlib/RingTheory/PowerSeries/Basic.lean

tactic: rw [order_monomial, if_neg h]
state_before: R : Type u_1
inst✝ : Semiring R
φ : PowerSeries R
n : ℕ
a : R
h : a ≠ 0
⊢ order (↑(monomial R n) a) = ↑n
Theorem: rec_heq_of_heq
File: Mathlib/Logic/Basic.lean

tactic: subst e
state_before: α : Sort u_1
a : α
β : Sort u_2
b : α
C : α → Sort u_2
x : C a
y : β
e : a = b
h : HEq x y
⊢ HEq (e ▸ x) y

tactic: exact h
state_before: α : Sort u_1
a : α
β : Sort u_2
C : α → Sort u_2
x : C a
y : β
h : HEq x y
⊢ HEq ((_ : a = a) ▸ x) y
Theorem: EuclideanDomain.GCD.induction
File: Mathlib/Algebra/EuclideanDomain/Defs.lean

tactic: change P a b
state_before: R : Type u
inst✝ : EuclideanDomain R
P : R → R → Prop
x✝ : R
a : R := x✝
b : R
H0 : ∀ (x : R), P 0 x
H1 : ∀ (a b : R), a ≠ 0 → P (b % a) a → P a b
a0 : a = 0
⊢ P x✝ b

tactic: exact a0.symm ▸ H0 b
state_before: R : Type u
inst✝ : EuclideanDomain R
P : R → R → Prop
x✝ : R
a : R := x✝
b : R
H0 : ∀ (x : R), P 0 x
H1 : ∀ (a b : R), a ≠ 0 → P (b % a) a → P a b
a0 : a = 0
⊢ P a b
Theorem: AddCircle.addOrderOf_div_of_gcd_eq_one
File: Mathlib/Topology/Instances/AddCircle.lean

tactic: convert gcd_mul_addOrderOf_div_eq p m hn
state_before: 𝕜 : Type u_1
B : Type ?u.185954
inst✝² : LinearOrderedField 𝕜
inst✝¹ : TopologicalSpace 𝕜
inst✝ : OrderTopology 𝕜
p q : 𝕜
hp : Fact (0 < p)
m n : ℕ
hn : 0 < n
h : Nat.gcd m n = 1
⊢ addOrderOf ↑(↑m / ↑n * p) = n

tactic: rw [h, one_mul]
state_before: case h.e'_2
𝕜 : Type u_1
B : Type ?u.185954
inst✝² : LinearOrderedField 𝕜
inst✝¹ : TopologicalSpace 𝕜
inst✝ : OrderTopology 𝕜
p q : 𝕜
hp : Fact (0 < p)
m n : ℕ
hn : 0 < n
h : Nat.gcd m n = 1
⊢ addOrderOf ↑(↑m / ↑n * p) = Nat.gcd m n * addOrderOf ↑(↑m / ↑n * p)
Theorem: Complex.abs_exp_ofReal_mul_I
File: Mathlib/Data/Complex/Exponential.lean

tactic: rw [exp_mul_I, abs_cos_add_sin_mul_I]
state_before: x : ℝ
⊢ ↑abs (exp (↑x * I)) = 1
Theorem: PerfectClosure.add_aux_right
File: Mathlib/FieldTheory/PerfectClosure.lean

tactic: rw [← iterate_succ_apply, iterate_succ_apply', iterate_succ_apply', ← frobenius_add]
state_before: K : Type u
inst✝² : CommRing K
p : ℕ
inst✝¹ : Fact (Nat.Prime p)
inst✝ : CharP K p
x y1 y2 : ℕ × K
H : R K p y1 y2
n : ℕ
y : K
⊢ R K p (x.fst + (n, y).fst, (↑(frobenius K p)^[(n, y).fst]) x.snd + (↑(frobenius K p)^[x.fst]) (n, y).snd)
    (x.fst + (n + 1, ↑(frobenius K p) y).fst,
      (↑(frobenius K p)^[(n + 1, ↑(frobenius K p) y).fst]) x.snd +
        (↑(frobenius K p)^[x.fst]) (n + 1, ↑(frobenius K p) y).snd)

tactic: apply R.intro
state_before: K : Type u
inst✝² : CommRing K
p : ℕ
inst✝¹ : Fact (Nat.Prime p)
inst✝ : CharP K p
x y1 y2 : ℕ × K
H : R K p y1 y2
n : ℕ
y : K
⊢ R K p (x.fst + (n, y).fst, (↑(frobenius K p)^[(n, y).fst]) x.snd + (↑(frobenius K p)^[x.fst]) (n, y).snd)
    (x.fst + (n + 1, ↑(frobenius K p) y).fst,
      ↑(frobenius K p) ((↑(frobenius K p)^[n]) x.snd + (↑(frobenius K p)^[x.fst]) y))
Theorem: continuousAt_update_of_ne
File: Mathlib/Topology/Separation.lean

tactic: simp only [← continuousWithinAt_univ, continuousWithinAt_update_of_ne hne]
state_before: α : Type u
β : Type v
inst✝³ : TopologicalSpace α
inst✝² : T1Space α
inst✝¹ : DecidableEq α
inst✝ : TopologicalSpace β
f : α → β
x y : α
z : β
hne : y ≠ x
⊢ ContinuousAt (update f x z) y ↔ ContinuousAt f y
Theorem: CategoryTheory.Limits.pullback.mapDesc_comp
File: Mathlib/CategoryTheory/Limits/Shapes/Pullbacks.lean

tactic: aesop_cat
state_before: C : Type u
inst✝⁵ : Category C
D : Type u₂
inst✝⁴ : Category D
W X✝ Y✝ Z X Y S T S' : C
f : X ⟶ T
g : Y ⟶ T
i : T ⟶ S
i' : S ⟶ S'
inst✝³ : HasPullback f g
inst✝² : HasPullback (f ≫ i) (g ≫ i)
inst✝¹ : HasPullback (f ≫ i ≫ i') (g ≫ i ≫ i')
inst✝ : HasPullback ((f ≫ i) ≫ i') ((g ≫ i) ≫ i')
⊢ mapDesc f g (i ≫ i') =
    mapDesc f g i ≫
      mapDesc (f ≫ i) (g ≫ i) i' ≫ (congrHom (_ : (f ≫ i) ≫ i' = f ≫ i ≫ i') (_ : (g ≫ i) ≫ i' = g ≫ i ≫ i')).hom
Theorem: map_ratCast
File: Mathlib/Data/Rat/Cast.lean

tactic: rw [cast_def, map_div₀, map_intCast, map_natCast, cast_def]
state_before: F : Type u_3
ι : Type ?u.80063
α : Type u_1
β : Type u_2
inst✝² : DivisionRing α
inst✝¹ : DivisionRing β
inst✝ : RingHomClass F α β
f : F
q : ℚ
⊢ ↑f ↑q = ↑q
Theorem: Nat.nonempty_of_pos_sInf
File: Mathlib/Data/Nat/Lattice.lean

tactic: by_contra contra
state_before: s : Set ℕ
h : 0 < sInf s
⊢ Set.Nonempty s

tactic: rw [Set.not_nonempty_iff_eq_empty] at contra
state_before: s : Set ℕ
h : 0 < sInf s
contra : ¬Set.Nonempty s
⊢ False

tactic: have h' : sInf s ≠ 0 := ne_of_gt h
state_before: s : Set ℕ
h : 0 < sInf s
contra : s = ∅
⊢ False

tactic: apply h'
state_before: s : Set ℕ
h : 0 < sInf s
contra : s = ∅
h' : sInf s ≠ 0
⊢ False

tactic: rw [Nat.sInf_eq_zero]
state_before: s : Set ℕ
h : 0 < sInf s
contra : s = ∅
h' : sInf s ≠ 0
⊢ sInf s = 0

tactic: right
state_before: s : Set ℕ
h : 0 < sInf s
contra : s = ∅
h' : sInf s ≠ 0
⊢ 0 ∈ s ∨ s = ∅

tactic: assumption
state_before: case h
s : Set ℕ
h : 0 < sInf s
contra : s = ∅
h' : sInf s ≠ 0
⊢ s = ∅
Theorem: SimpleGraph.adj_iff_exists_edge_coe
File: Mathlib/Combinatorics/SimpleGraph/Basic.lean

tactic: simp only [mem_edgeSet, exists_prop, SetCoe.exists, exists_eq_right, Subtype.coe_mk]
state_before: ι : Sort ?u.72136
𝕜 : Type ?u.72139
V : Type u
W : Type v
X : Type w
G : SimpleGraph V
G' : SimpleGraph W
a b c u v w : V
e : Sym2 V
G₁ G₂ : SimpleGraph V
⊢ Adj G a b ↔ ∃ e, ↑e = Quotient.mk (Sym2.Rel.setoid V) (a, b)
Theorem: List.foldl_eq_foldlM
File: Std/Data/List/Init/Lemmas.lean

tactic: induction l generalizing b <;> simp [*, foldl]
state_before: β : Type u_1
α : Type u_2
f : β → α → β
b : β
l : List α
⊢ foldl f b l = List.foldlM f b l
Theorem: Fin.succ_pred
File: Mathlib/Data/Fin/Basic.lean

tactic: simp only [mk_zero, ne_eq, not_true] at hi
state_before: n m : ℕ
h : 0 < n + 1
hi : { val := 0, isLt := h } ≠ 0
⊢ succ (pred { val := 0, isLt := h } hi) = { val := 0, isLt := h }
Theorem: dvdNotUnit_of_dvd_of_not_dvd
File: Mathlib/Algebra/GroupWithZero/Divisibility.lean

tactic: constructor
state_before: α : Type u_1
inst✝ : CommMonoidWithZero α
a b : α
hd : a ∣ b
hnd : ¬b ∣ a
⊢ DvdNotUnit a b

tactic: rintro rfl
state_before: case left
α : Type u_1
inst✝ : CommMonoidWithZero α
a b : α
hd : a ∣ b
hnd : ¬b ∣ a
⊢ a ≠ 0

tactic: exact hnd (dvd_zero _)
state_before: case left
α : Type u_1
inst✝ : CommMonoidWithZero α
b : α
hd : 0 ∣ b
hnd : ¬b ∣ 0
⊢ False

tactic: rcases hd with ⟨c, rfl⟩
state_before: case right
α : Type u_1
inst✝ : CommMonoidWithZero α
a b : α
hd : a ∣ b
hnd : ¬b ∣ a
⊢ ∃ x, ¬IsUnit x ∧ b = a * x

tactic: refine' ⟨c, _, rfl⟩
state_before: case right.intro
α : Type u_1
inst✝ : CommMonoidWithZero α
a c : α
hnd : ¬a * c ∣ a
⊢ ∃ x, ¬IsUnit x ∧ a * c = a * x

tactic: rintro ⟨u, rfl⟩
state_before: case right.intro
α : Type u_1
inst✝ : CommMonoidWithZero α
a c : α
hnd : ¬a * c ∣ a
⊢ ¬IsUnit c

tactic: simp at hnd
state_before: case right.intro.intro
α : Type u_1
inst✝ : CommMonoidWithZero α
a : α
u : αˣ
hnd : ¬a * ↑u ∣ a
⊢ False
Theorem: Real.sin_sq_pi_over_two_pow
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Basic.lean

tactic: rw [sin_sq, cos_pi_over_two_pow]
state_before: x : ℝ
n : ℕ
⊢ sin (π / 2 ^ (n + 1)) ^ 2 = 1 - (sqrtTwoAddSeries 0 n / 2) ^ 2
Theorem: Fin.insertNth_eq_iff
File: Mathlib/Data/Fin/Tuple/Basic.lean

tactic: simp [funext_iff, forall_iff_succAbove i, eq_comm]
state_before: m n : ℕ
α : Fin (n + 1) → Type u
β : Type v
i : Fin (n + 1)
x : α i
p : (j : Fin n) → α (↑(succAbove i) j)
q : (j : Fin (n + 1)) → α j
⊢ insertNth i x p = q ↔ q i = x ∧ p = fun j => q (↑(succAbove i) j)
Theorem: Lagrange.eval_interpolate_not_at_node
File: Mathlib/LinearAlgebra/Lagrange.lean

tactic: simp_rw [interpolate_apply, mul_sum, eval_finset_sum, eval_mul, eval_C]
state_before: F : Type u_2
inst✝¹ : Field F
ι : Type u_1
s : Finset ι
v : ι → F
i : ι
r : ι → F
x : F
inst✝ : DecidableEq ι
hx : ∀ (i : ι), i ∈ s → x ≠ v i
⊢ eval x (↑(interpolate s v) r) = eval x (nodal s v) * ∑ i in s, nodalWeight s v i * (x - v i)⁻¹ * r i

tactic: refine' sum_congr rfl fun i hi => _
state_before: F : Type u_2
inst✝¹ : Field F
ι : Type u_1
s : Finset ι
v : ι → F
i : ι
r : ι → F
x : F
inst✝ : DecidableEq ι
hx : ∀ (i : ι), i ∈ s → x ≠ v i
⊢ ∑ x_1 in s, r x_1 * eval x (Lagrange.basis s v x_1) =
    ∑ x_1 in s, eval x (nodal s v) * (nodalWeight s v x_1 * (x - v x_1)⁻¹ * r x_1)

tactic: rw [← mul_assoc, mul_comm, eval_basis_not_at_node hi (hx _ hi)]
state_before: F : Type u_2
inst✝¹ : Field F
ι : Type u_1
s : Finset ι
v : ι → F
i✝ : ι
r : ι → F
x : F
inst✝ : DecidableEq ι
hx : ∀ (i : ι), i ∈ s → x ≠ v i
i : ι
hi : i ∈ s
⊢ r i * eval x (Lagrange.basis s v i) = eval x (nodal s v) * (nodalWeight s v i * (x - v i)⁻¹ * r i)
Theorem: Set.Iio_union_Ioo'
File: Mathlib/Data/Set/Intervals/Basic.lean

tactic: ext x
state_before: α : Type u_1
β : Type ?u.104239
inst✝ : LinearOrder α
a a₁ a₂ b b₁ b₂ c d : α
h₁ : c < b
⊢ Iio b ∪ Ioo c d = Iio (max b d)

tactic: cases' lt_or_le x b with hba hba
state_before: case h
α : Type u_1
β : Type ?u.104239
inst✝ : LinearOrder α
a a₁ a₂ b b₁ b₂ c d : α
h₁ : c < b
x : α
⊢ x ∈ Iio b ∪ Ioo c d ↔ x ∈ Iio (max b d)

tactic: simp [hba, h₁]
state_before: case h.inl
α : Type u_1
β : Type ?u.104239
inst✝ : LinearOrder α
a a₁ a₂ b b₁ b₂ c d : α
h₁ : c < b
x : α
hba : x < b
⊢ x ∈ Iio b ∪ Ioo c d ↔ x ∈ Iio (max b d)

tactic: simp only [mem_Iio, mem_union, mem_Ioo, lt_max_iff]
state_before: case h.inr
α : Type u_1
β : Type ?u.104239
inst✝ : LinearOrder α
a a₁ a₂ b b₁ b₂ c d : α
h₁ : c < b
x : α
hba : b ≤ x
⊢ x ∈ Iio b ∪ Ioo c d ↔ x ∈ Iio (max b d)

tactic: refine' or_congr Iff.rfl ⟨And.right, _⟩
state_before: case h.inr
α : Type u_1
β : Type ?u.104239
inst✝ : LinearOrder α
a a₁ a₂ b b₁ b₂ c d : α
h₁ : c < b
x : α
hba : b ≤ x
⊢ x < b ∨ c < x ∧ x < d ↔ x < b ∨ x < d

tactic: exact fun h₂ => ⟨h₁.trans_le hba, h₂⟩
state_before: case h.inr
α : Type u_1
β : Type ?u.104239
inst✝ : LinearOrder α
a a₁ a₂ b b₁ b₂ c d : α
h₁ : c < b
x : α
hba : b ≤ x
⊢ x < d → c < x ∧ x < d
Theorem: List.concat_perm
File: Mathlib/Data/List/Perm.lean

tactic: simp
state_before: α : Type uu
β : Type vv
l₁ l₂ l : List α
a : α
⊢ concat l a ~ a :: l
Theorem: PadicInt.norm_lt_one_mul
File: Mathlib/NumberTheory/Padics/PadicIntegers.lean

tactic: simp
state_before: p : ℕ
hp : Fact (Nat.Prime p)
z1 z2 : ℤ_[p]
hz2 : ‖z2‖ < 1
⊢ ‖z1 * z2‖ = ‖z1‖ * ‖z2‖
Theorem: sq_lt_one_iff_abs_lt_one
File: Mathlib/Algebra/GroupPower/Order.lean

tactic: simpa only [one_pow, abs_one] using @sq_lt_sq _ _ x 1
state_before: β : Type ?u.269074
A : Type ?u.269077
G : Type ?u.269080
M : Type ?u.269083
R : Type u_1
inst✝ : LinearOrderedRing R
x✝ y x : R
⊢ x ^ 2 < 1 ↔ abs x < 1
Theorem: Std.AssocList.findEntryP?_eq
File: Std/Data/AssocList.lean

tactic: induction l <;> simp [findEntryP?]
state_before: α : Type u_1
β : Type u_2
p : α → β → Bool
l : AssocList α β
⊢ findEntryP? p l =
    List.find?
      (fun x =>
        match x with
        | (a, b) => p a b)
      (toList l)

tactic: split <;> simp [*]
state_before: case cons
α : Type u_1
β : Type u_2
p : α → β → Bool
key✝ : α
value✝ : β
tail✝ : AssocList α β
tail_ih✝ :
  findEntryP? p tail✝ =
    List.find?
      (fun x =>
        match x with
        | (a, b) => p a b)
      (toList tail✝)
⊢ (bif p key✝ value✝ then some (key✝, value✝) else findEntryP? p tail✝) =
    match p key✝ value✝ with
    | true => some (key✝, value✝)
    | false => List.find? (fun x => p x.fst x.snd) (toList tail✝)
Theorem: Complex.continuousAt_cpow_of_re_pos
File: Mathlib/Analysis/SpecialFunctions/Pow/Continuity.lean

tactic: cases' p with z w
state_before: p : ℂ × ℂ
h₁ : 0 ≤ p.fst.re ∨ p.fst.im ≠ 0
h₂ : 0 < p.snd.re
⊢ ContinuousAt (fun x => x.fst ^ x.snd) p

tactic: rw [← not_lt_zero_iff, lt_iff_le_and_ne, not_and_or, Ne.def, Classical.not_not,
  not_le_zero_iff] at h₁
state_before: case mk
z w : ℂ
h₁ : 0 ≤ (z, w).fst.re ∨ (z, w).fst.im ≠ 0
h₂ : 0 < (z, w).snd.re
⊢ ContinuousAt (fun x => x.fst ^ x.snd) (z, w)

tactic: rcases h₁ with (h₁ | (rfl : z = 0))
state_before: case mk
z w : ℂ
h₁ : (0 < (z, w).fst.re ∨ (z, w).fst.im ≠ 0) ∨ (z, w).fst = 0
h₂ : 0 < (z, w).snd.re
⊢ ContinuousAt (fun x => x.fst ^ x.snd) (z, w)

tactic: exacts [continuousAt_cpow h₁, continuousAt_cpow_zero_of_re_pos h₂]
state_before: case mk.inl
z w : ℂ
h₂ : 0 < (z, w).snd.re
h₁ : 0 < (z, w).fst.re ∨ (z, w).fst.im ≠ 0
⊢ ContinuousAt (fun x => x.fst ^ x.snd) (z, w)

case mk.inr
w : ℂ
h₂ : 0 < (0, w).snd.re
⊢ ContinuousAt (fun x => x.fst ^ x.snd) (0, w)
Theorem: OnePoint.continuousAt_infty
File: Mathlib/Topology/Compactification/OnePoint.lean

tactic: simp only [hasBasis_coclosedCompact.tendsto_left_iff, and_assoc]
state_before: X : Type u_2
inst✝¹ : TopologicalSpace X
s : Set (OnePoint X)
t : Set X
Y : Type u_1
inst✝ : TopologicalSpace Y
f : OnePoint X → Y
⊢ Tendsto (f ∘ some) (coclosedCompact X) (𝓝 (f ∞)) ↔
    ∀ (s : Set Y), s ∈ 𝓝 (f ∞) → ∃ t, IsClosed t ∧ IsCompact t ∧ MapsTo (f ∘ some) (tᶜ) s
Theorem: FirstOrder.Language.Substructure.CG.sup
File: Mathlib/ModelTheory/FinitelyGenerated.lean

tactic: rw [closure_union, ht₁.2, ht₂.2]
state_before: L : Language
M : Type u_3
inst✝ : Structure L M
N₁ N₂ : Substructure L M
hN₁ : CG N₁
hN₂ : CG N₂
t₁ : Set M
ht₁ : Set.Countable t₁ ∧ LowerAdjoint.toFun (closure L) t₁ = N₁
t₂ : Set M
ht₂ : Set.Countable t₂ ∧ LowerAdjoint.toFun (closure L) t₂ = N₂
⊢ LowerAdjoint.toFun (closure L) (t₁ ∪ t₂) = N₁ ⊔ N₂