tasksource/leandojo huggingface dataset:
Theorem: SeminormFamily.withSeminorms_iff_nhds_eq_iInf
File: Mathlib/Analysis/LocallyConvex/WithSeminorms.lean

tactic: rw [← p.filter_eq_iInf]
state_before: 𝕜 : Type u_1
𝕜₂ : Type ?u.438464
𝕝 : Type ?u.438467
𝕝₂ : Type ?u.438470
E : Type u_2
F : Type ?u.438476
G : Type ?u.438479
ι : Type u_3
ι' : Type ?u.438485
inst✝⁴ : NormedField 𝕜
inst✝³ : AddCommGroup E
inst✝² : Module 𝕜 E
inst✝¹ : Nonempty ι
t : TopologicalSpace E
inst✝ : TopologicalAddGroup E
p : SeminormFamily 𝕜 E ι
⊢ WithSeminorms p ↔ 𝓝 0 = ⨅ (i : ι), Filter.comap (↑(p i)) (𝓝 0)

tactic: refine' ⟨fun h => _, p.withSeminorms_of_nhds⟩
state_before: 𝕜 : Type u_1
𝕜₂ : Type ?u.438464
𝕝 : Type ?u.438467
𝕝₂ : Type ?u.438470
E : Type u_2
F : Type ?u.438476
G : Type ?u.438479
ι : Type u_3
ι' : Type ?u.438485
inst✝⁴ : NormedField 𝕜
inst✝³ : AddCommGroup E
inst✝² : Module 𝕜 E
inst✝¹ : Nonempty ι
t : TopologicalSpace E
inst✝ : TopologicalAddGroup E
p : SeminormFamily 𝕜 E ι
⊢ WithSeminorms p ↔ 𝓝 0 = FilterBasis.filter AddGroupFilterBasis.toFilterBasis

tactic: rw [h.topology_eq_withSeminorms]
state_before: 𝕜 : Type u_1
𝕜₂ : Type ?u.438464
𝕝 : Type ?u.438467
𝕝₂ : Type ?u.438470
E : Type u_2
F : Type ?u.438476
G : Type ?u.438479
ι : Type u_3
ι' : Type ?u.438485
inst✝⁴ : NormedField 𝕜
inst✝³ : AddCommGroup E
inst✝² : Module 𝕜 E
inst✝¹ : Nonempty ι
t : TopologicalSpace E
inst✝ : TopologicalAddGroup E
p : SeminormFamily 𝕜 E ι
h : WithSeminorms p
⊢ 𝓝 0 = FilterBasis.filter AddGroupFilterBasis.toFilterBasis

tactic: exact AddGroupFilterBasis.nhds_zero_eq _
state_before: 𝕜 : Type u_1
𝕜₂ : Type ?u.438464
𝕝 : Type ?u.438467
𝕝₂ : Type ?u.438470
E : Type u_2
F : Type ?u.438476
G : Type ?u.438479
ι : Type u_3
ι' : Type ?u.438485
inst✝⁴ : NormedField 𝕜
inst✝³ : AddCommGroup E
inst✝² : Module 𝕜 E
inst✝¹ : Nonempty ι
t : TopologicalSpace E
inst✝ : TopologicalAddGroup E
p : SeminormFamily 𝕜 E ι
h : WithSeminorms p
⊢ 𝓝 0 = FilterBasis.filter AddGroupFilterBasis.toFilterBasis
Theorem: ENNReal.iUnion_Iio_coe_nat
File: Mathlib/Data/Real/ENNReal.lean

tactic: ext x
state_before: α : Type ?u.132596
β : Type ?u.132599
a b c d : ℝ≥0∞
r p q : ℝ≥0
⊢ (⋃ (n : ℕ), Iio ↑n) = {⊤}ᶜ

tactic: rw [mem_iUnion]
state_before: case h
α : Type ?u.132596
β : Type ?u.132599
a b c d : ℝ≥0∞
r p q : ℝ≥0
x : ℝ≥0∞
⊢ (x ∈ ⋃ (n : ℕ), Iio ↑n) ↔ x ∈ {⊤}ᶜ

tactic: exact ⟨fun ⟨n, hn⟩ => ne_top_of_lt hn, ENNReal.exists_nat_gt⟩
state_before: case h
α : Type ?u.132596
β : Type ?u.132599
a b c d : ℝ≥0∞
r p q : ℝ≥0
x : ℝ≥0∞
⊢ (∃ i, x ∈ Iio ↑i) ↔ x ∈ {⊤}ᶜ
Theorem: MeasureTheory.Measure.Regular.exists_compact_not_null
File: Mathlib/MeasureTheory/Measure/Regular.lean

tactic: simp_rw [Ne.def, ← measure_univ_eq_zero, isOpen_univ.measure_eq_iSup_isCompact,
  ENNReal.iSup_eq_zero, not_forall, exists_prop, subset_univ, true_and_iff]
state_before: α : Type u_1
β : Type ?u.61981
inst✝² : MeasurableSpace α
inst✝¹ : TopologicalSpace α
μ : Measure α
inst✝ : Regular μ
⊢ (∃ K, IsCompact K ∧ ↑↑μ K ≠ 0) ↔ μ ≠ 0
Theorem: Finsupp.filter_eq_sum
File: Mathlib/Data/Finsupp/Basic.lean

tactic: rw [Subsingleton.elim D] <;> rfl
state_before: α : Type u_1
β : Type ?u.502352
γ : Type ?u.502355
ι : Type ?u.502358
M : Type u_2
M' : Type ?u.502364
N : Type ?u.502367
P : Type ?u.502370
G : Type ?u.502373
H : Type ?u.502376
R : Type ?u.502379
S : Type ?u.502382
inst✝ : AddCommMonoid M
p✝ p : α → Prop
D : DecidablePred p
f : α →₀ M
⊢ (filter p f).support = Finset.filter p f.support

tactic: rw [filter_apply_pos _ _ (mem_filter.1 hx).2]
state_before: α : Type u_1
β : Type ?u.502352
γ : Type ?u.502355
ι : Type ?u.502358
M : Type u_2
M' : Type ?u.502364
N : Type ?u.502367
P : Type ?u.502370
G : Type ?u.502373
H : Type ?u.502376
R : Type ?u.502379
S : Type ?u.502382
inst✝ : AddCommMonoid M
p✝ p : α → Prop
D : DecidablePred p
f : α →₀ M
x : α
hx : x ∈ Finset.filter p f.support
⊢ single x (↑(filter p f) x) = single x (↑f x)
Theorem: HasDerivAt.clm_apply
File: Mathlib/Analysis/Calculus/Deriv/Mul.lean

tactic: have := (hc.hasFDerivAt.clm_apply hu.hasFDerivAt).hasDerivAt
state_before: 𝕜 : Type u
inst✝⁶ : NontriviallyNormedField 𝕜
F : Type v
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
E : Type w
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace 𝕜 E
f f₀ f₁ g : 𝕜 → F
f' f₀' f₁' g' : F
x : 𝕜
s t : Set 𝕜
L L₁ L₂ : Filter 𝕜
G : Type u_1
inst✝¹ : NormedAddCommGroup G
inst✝ : NormedSpace 𝕜 G
c : 𝕜 → F →L[𝕜] G
c' : F →L[𝕜] G
d : 𝕜 → E →L[𝕜] F
d' : E →L[𝕜] F
u : 𝕜 → F
u' : F
hc : HasDerivAt c c' x
hu : HasDerivAt u u' x
⊢ HasDerivAt (fun y => ↑(c y) (u y)) (↑c' (u x) + ↑(c x) u') x

tactic: rwa [add_apply, comp_apply, flip_apply, smulRight_apply, smulRight_apply, one_apply, one_smul,
  one_smul, add_comm] at this
state_before: 𝕜 : Type u
inst✝⁶ : NontriviallyNormedField 𝕜
F : Type v
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
E : Type w
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace 𝕜 E
f f₀ f₁ g : 𝕜 → F
f' f₀' f₁' g' : F
x : 𝕜
s t : Set 𝕜
L L₁ L₂ : Filter 𝕜
G : Type u_1
inst✝¹ : NormedAddCommGroup G
inst✝ : NormedSpace 𝕜 G
c : 𝕜 → F →L[𝕜] G
c' : F →L[𝕜] G
d : 𝕜 → E →L[𝕜] F
d' : E →L[𝕜] F
u : 𝕜 → F
u' : F
hc : HasDerivAt c c' x
hu : HasDerivAt u u' x
this :
  HasDerivAt (fun y => ↑(c y) (u y))
    (↑(comp (c x) (smulRight 1 u') + ↑(ContinuousLinearMap.flip (smulRight 1 c')) (u x)) 1) x
⊢ HasDerivAt (fun y => ↑(c y) (u y)) (↑c' (u x) + ↑(c x) u') x
Theorem: ContinuousMap.dist_le_iff_of_nonempty
File: Mathlib/Topology/ContinuousFunction/Compact.lean

tactic: simp only [← dist_mkOfCompact, BoundedContinuousFunction.dist_le_iff_of_nonempty,
  mkOfCompact_apply]
state_before: α : Type u_1
β : Type u_2
E : Type ?u.74386
inst✝⁴ : TopologicalSpace α
inst✝³ : CompactSpace α
inst✝² : MetricSpace β
inst✝¹ : NormedAddCommGroup E
f g : C(α, β)
C : ℝ
inst✝ : Nonempty α
⊢ dist f g ≤ C ↔ ∀ (x : α), dist (↑f x) (↑g x) ≤ C
Theorem: ENNReal.one_le_inv
File: Mathlib/Data/Real/ENNReal.lean

tactic: rw [le_inv_iff_le_inv, inv_one]
state_before: α : Type ?u.270383
β : Type ?u.270386
a b c d : ℝ≥0∞
r p q : ℝ≥0
⊢ 1 ≤ a⁻¹ ↔ a ≤ 1
Theorem: CategoryTheory.Limits.diagonalObjPullbackFstIso_inv_fst_fst
File: Mathlib/CategoryTheory/Limits/Shapes/Diagonal.lean

tactic: delta diagonalObjPullbackFstIso
state_before: C : Type u_2
inst✝⁵ : Category C
X✝ Y✝ Z✝ : C
inst✝⁴ : HasPullbacks C
S T : C
f✝ : X✝ ⟶ T
g✝ : Y✝ ⟶ T
i : T ⟶ S
inst✝³ : HasPullback i i
inst✝² : HasPullback f✝ g✝
inst✝¹ : HasPullback (f✝ ≫ i) (g✝ ≫ i)
inst✝ :
  HasPullback (diagonal i)
    (map (f✝ ≫ i) (g✝ ≫ i) i i f✝ g✝ (𝟙 S) (_ : (f✝ ≫ i) ≫ 𝟙 S = f✝ ≫ i) (_ : (g✝ ≫ i) ≫ 𝟙 S = g✝ ≫ i))
X Y Z : C
f : X ⟶ Z
g : Y ⟶ Z
⊢ (diagonalObjPullbackFstIso f g).inv ≫ fst ≫ fst = snd

tactic: simp
state_before: C : Type u_2
inst✝⁵ : Category C
X✝ Y✝ Z✝ : C
inst✝⁴ : HasPullbacks C
S T : C
f✝ : X✝ ⟶ T
g✝ : Y✝ ⟶ T
i : T ⟶ S
inst✝³ : HasPullback i i
inst✝² : HasPullback f✝ g✝
inst✝¹ : HasPullback (f✝ ≫ i) (g✝ ≫ i)
inst✝ :
  HasPullback (diagonal i)
    (map (f✝ ≫ i) (g✝ ≫ i) i i f✝ g✝ (𝟙 S) (_ : (f✝ ≫ i) ≫ 𝟙 S = f✝ ≫ i) (_ : (g✝ ≫ i) ≫ 𝟙 S = g✝ ≫ i))
X Y Z : C
f : X ⟶ Z
g : Y ⟶ Z
⊢ (pullbackRightPullbackFstIso f g fst ≪≫
          congrHom (_ : fst ≫ f = snd ≫ g) (_ : g = g) ≪≫
            pullbackAssoc f g g g ≪≫ pullbackSymmetry f (fst ≫ g) ≪≫ congrHom (_ : fst ≫ g = snd ≫ g) (_ : f = f)).inv ≫
      fst ≫ fst =
    snd
Theorem: InnerProductGeometry.angle_sub_le_pi_div_two_of_inner_eq_zero
File: Mathlib/Geometry/Euclidean/Angle/Unoriented/RightAngle.lean

tactic: rw [← neg_eq_zero, ← inner_neg_right] at h
state_before: V : Type u_1
inst✝¹ : NormedAddCommGroup V
inst✝ : InnerProductSpace ℝ V
x y : V
h : inner x y = 0
⊢ angle x (x - y) ≤ π / 2

tactic: rw [sub_eq_add_neg]
state_before: V : Type u_1
inst✝¹ : NormedAddCommGroup V
inst✝ : InnerProductSpace ℝ V
x y : V
h : inner x (-y) = 0
⊢ angle x (x - y) ≤ π / 2

tactic: exact angle_add_le_pi_div_two_of_inner_eq_zero h
state_before: V : Type u_1
inst✝¹ : NormedAddCommGroup V
inst✝ : InnerProductSpace ℝ V
x y : V
h : inner x (-y) = 0
⊢ angle x (x + -y) ≤ π / 2
Theorem: GeneralizedContinuedFraction.of_h_eq_intFractPair_seq1_fst_b
File: Mathlib/Algebra/ContinuedFractions/Computation/Translations.lean

tactic: cases aux_seq_eq : IntFractPair.seq1 v
state_before: K : Type u_1
inst✝¹ : LinearOrderedField K
inst✝ : FloorRing K
v : K
⊢ (of v).h = ↑(IntFractPair.seq1 v).fst.b

tactic: simp [of, aux_seq_eq]
state_before: case mk
K : Type u_1
inst✝¹ : LinearOrderedField K
inst✝ : FloorRing K
v : K
fst✝ : IntFractPair K
snd✝ : Stream'.Seq (IntFractPair K)
aux_seq_eq : IntFractPair.seq1 v = (fst✝, snd✝)
⊢ (of v).h = ↑(fst✝, snd✝).fst.b
Theorem: MeasureTheory.L1.integral_add
File: Mathlib/MeasureTheory/Integral/Bochner.lean

tactic: simp only [integral]
state_before: α : Type u_1
E : Type u_2
F : Type ?u.449573
𝕜 : Type ?u.449576
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedAddCommGroup F
m : MeasurableSpace α
μ : Measure α
inst✝⁵ : NormedSpace ℝ E
inst✝⁴ : NontriviallyNormedField 𝕜
inst✝³ : NormedSpace 𝕜 E
inst✝² : SMulCommClass ℝ 𝕜 E
inst✝¹ : NormedSpace ℝ F
inst✝ : CompleteSpace E
f g : { x // x ∈ Lp E 1 }
⊢ integral (f + g) = integral f + integral g

tactic: exact map_add integralCLM f g
state_before: α : Type u_1
E : Type u_2
F : Type ?u.449573
𝕜 : Type ?u.449576
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedAddCommGroup F
m : MeasurableSpace α
μ : Measure α
inst✝⁵ : NormedSpace ℝ E
inst✝⁴ : NontriviallyNormedField 𝕜
inst✝³ : NormedSpace 𝕜 E
inst✝² : SMulCommClass ℝ 𝕜 E
inst✝¹ : NormedSpace ℝ F
inst✝ : CompleteSpace E
f g : { x // x ∈ Lp E 1 }
⊢ ↑integralCLM (f + g) = ↑integralCLM f + ↑integralCLM g
Theorem: Prime.isPrimePow
File: Mathlib/Algebra/IsPrimePow.lean

tactic: simp
state_before: R : Type u_1
inst✝ : CommMonoidWithZero R
n p✝ : R
k : ℕ
p : R
hp : Prime p
⊢ p ^ 1 = p
Theorem: SatisfiesM_Except_eq
File: Std/Classes/LawfulMonad.lean

tactic: revert x
state_before: ε : Type u_1
α✝ : Type u_2
p : α✝ → Prop
x : Except ε α✝
⊢ SatisfiesM p x → ∀ (a : α✝), x = Except.ok a → p a

tactic: intro | .ok _, ⟨.ok ⟨_, h⟩, rfl⟩, _, rfl => exact h
state_before: ε : Type u_1
α✝ : Type u_2
p : α✝ → Prop
⊢ ∀ {x : Except ε α✝}, SatisfiesM p x → ∀ (a : α✝), x = Except.ok a → p a

tactic: exact h
state_before: ε : Type u_1
α✝ : Type u_2
p : α✝ → Prop
x✝³ : Except ε α✝
x✝² : SatisfiesM p x✝³
x✝¹ : α✝
x✝ : x✝³ = Except.ok x✝¹
val✝ : α✝
h : p val✝
⊢ p { val := val✝, property := h }.val
Theorem: multiplicity.isUnit_right
File: Mathlib/RingTheory/Multiplicity.lean

tactic: simp only [_root_.pow_zero, one_dvd]
state_before: α : Type u_1
inst✝¹ : CommMonoid α
inst✝ : DecidableRel fun x x_1 => x ∣ x_1
a b : α
ha : ¬IsUnit a
hb : IsUnit b
⊢ a ^ 0 ∣ b

tactic: rw [pow_one]
state_before: α : Type u_1
inst✝¹ : CommMonoid α
inst✝ : DecidableRel fun x x_1 => x ∣ x_1
a b : α
ha : ¬IsUnit a
hb : IsUnit b
⊢ ¬a ^ (0 + 1) ∣ b

tactic: exact fun h => mt (isUnit_of_dvd_unit h) ha hb
state_before: α : Type u_1
inst✝¹ : CommMonoid α
inst✝ : DecidableRel fun x x_1 => x ∣ x_1
a b : α
ha : ¬IsUnit a
hb : IsUnit b
⊢ ¬a ∣ b
Theorem: SimpleGraph.exists_ne_odd_degree_of_exists_odd_degree
File: Mathlib/Combinatorics/SimpleGraph/DegreeSum.lean

tactic: haveI := Classical.decEq V
state_before: V : Type u
G : SimpleGraph V
inst✝¹ : Fintype V
inst✝ : DecidableRel G.Adj
v : V
h : Odd (degree G v)
⊢ ∃ w, w ≠ v ∧ Odd (degree G w)

tactic: rcases G.odd_card_odd_degree_vertices_ne v h with ⟨k, hg⟩
state_before: V : Type u
G : SimpleGraph V
inst✝¹ : Fintype V
inst✝ : DecidableRel G.Adj
v : V
h : Odd (degree G v)
this : DecidableEq V
⊢ ∃ w, w ≠ v ∧ Odd (degree G w)

tactic: have hg' : (filter (fun w : V => w ≠ v ∧ Odd (G.degree w)) univ).card > 0 := by
  rw [hg]
  apply Nat.succ_pos
state_before: case intro
V : Type u
G : SimpleGraph V
inst✝¹ : Fintype V
inst✝ : DecidableRel G.Adj
v : V
h : Odd (degree G v)
this : DecidableEq V
k : ℕ
hg : card (filter (fun w => w ≠ v ∧ Odd (degree G w)) univ) = 2 * k + 1
⊢ ∃ w, w ≠ v ∧ Odd (degree G w)

tactic: rcases card_pos.mp hg' with ⟨w, hw⟩
state_before: case intro
V : Type u
G : SimpleGraph V
inst✝¹ : Fintype V
inst✝ : DecidableRel G.Adj
v : V
h : Odd (degree G v)
this : DecidableEq V
k : ℕ
hg : card (filter (fun w => w ≠ v ∧ Odd (degree G w)) univ) = 2 * k + 1
hg' : card (filter (fun w => w ≠ v ∧ Odd (degree G w)) univ) > 0
⊢ ∃ w, w ≠ v ∧ Odd (degree G w)

tactic: simp only [true_and_iff, mem_filter, mem_univ, Ne.def] at hw
state_before: case intro.intro
V : Type u
G : SimpleGraph V
inst✝¹ : Fintype V
inst✝ : DecidableRel G.Adj
v : V
h : Odd (degree G v)
this : DecidableEq V
k : ℕ
hg : card (filter (fun w => w ≠ v ∧ Odd (degree G w)) univ) = 2 * k + 1
hg' : card (filter (fun w => w ≠ v ∧ Odd (degree G w)) univ) > 0
w : V
hw : w ∈ filter (fun w => w ≠ v ∧ Odd (degree G w)) univ
⊢ ∃ w, w ≠ v ∧ Odd (degree G w)

tactic: exact ⟨w, hw⟩
state_before: case intro.intro
V : Type u
G : SimpleGraph V
inst✝¹ : Fintype V
inst✝ : DecidableRel G.Adj
v : V
h : Odd (degree G v)
this : DecidableEq V
k : ℕ
hg : card (filter (fun w => w ≠ v ∧ Odd (degree G w)) univ) = 2 * k + 1
hg' : card (filter (fun w => w ≠ v ∧ Odd (degree G w)) univ) > 0
w : V
hw : ¬w = v ∧ Odd (degree G w)
⊢ ∃ w, w ≠ v ∧ Odd (degree G w)

tactic: rw [hg]
state_before: V : Type u
G : SimpleGraph V
inst✝¹ : Fintype V
inst✝ : DecidableRel G.Adj
v : V
h : Odd (degree G v)
this : DecidableEq V
k : ℕ
hg : card (filter (fun w => w ≠ v ∧ Odd (degree G w)) univ) = 2 * k + 1
⊢ card (filter (fun w => w ≠ v ∧ Odd (degree G w)) univ) > 0

tactic: apply Nat.succ_pos
state_before: V : Type u
G : SimpleGraph V
inst✝¹ : Fintype V
inst✝ : DecidableRel G.Adj
v : V
h : Odd (degree G v)
this : DecidableEq V
k : ℕ
hg : card (filter (fun w => w ≠ v ∧ Odd (degree G w)) univ) = 2 * k + 1
⊢ 2 * k + 1 > 0
Theorem: SimpleGraph.ne_of_adj
File: Mathlib/Combinatorics/SimpleGraph/Basic.lean

tactic: rintro rfl
state_before: ι : Sort ?u.11825
𝕜 : Type ?u.11828
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
h : Adj G a b
⊢ a ≠ b

tactic: exact G.irrefl h
state_before: ι : Sort ?u.11825
𝕜 : Type ?u.11828
V : Type u
W : Type v
X : Type w
G : SimpleGraph V
G' : SimpleGraph W
a c u v w : V
e : Sym2 V
h : Adj G a a
⊢ False
Theorem: List.mapIdx_append
File: Mathlib/Data/List/Indexes.lean

tactic: induction' K with a J IH generalizing f
state_before: α✝ : Type u
β : Type v
α : Type u_1
K L : List α
f : ℕ → α → β
⊢ mapIdx f (K ++ L) = mapIdx f K ++ mapIdx (fun i a => f (i + length K) a) L

tactic: rfl
state_before: case nil
α✝ : Type u
β : Type v
α : Type u_1
L : List α
f✝ f : ℕ → α → β
⊢ mapIdx f ([] ++ L) = mapIdx f [] ++ mapIdx (fun i a => f (i + length []) a) L

tactic: simp [IH fun i ↦ f (i + 1), add_assoc]
state_before: case cons
α✝ : Type u
β : Type v
α : Type u_1
L : List α
f✝ : ℕ → α → β
a : α
J : List α
IH : ∀ (f : ℕ → α → β), mapIdx f (J ++ L) = mapIdx f J ++ mapIdx (fun i a => f (i + length J) a) L
f : ℕ → α → β
⊢ mapIdx f (a :: J ++ L) = mapIdx f (a :: J) ++ mapIdx (fun i a_1 => f (i + length (a :: J)) a_1) L
Theorem: ZNum.add_le_add_left
File: Mathlib/Data/Num/Lemmas.lean

tactic: intro a b h c
state_before: α : Type ?u.1030791
⊢ ∀ (a b : ZNum), a ≤ b → ∀ (c : ZNum), c + a ≤ c + b

tactic: revert h
state_before: α : Type ?u.1030791
a b : ZNum
h : a ≤ b
c : ZNum
⊢ c + a ≤ c + b

tactic: transfer_rw
state_before: α : Type ?u.1030791
a b c : ZNum
⊢ a ≤ b → c + a ≤ c + b

tactic: exact fun h => _root_.add_le_add_left h c
state_before: α : Type ?u.1030791
a b c : ZNum
⊢ ↑a ≤ ↑b → ↑c + ↑a ≤ ↑c + ↑b
Theorem: Ordinal.mul_div_cancel
File: Mathlib/SetTheory/Ordinal/Arithmetic.lean

tactic: simpa only [add_zero, zero_div] using mul_add_div a b0 0
state_before: α : Type ?u.243802
β : Type ?u.243805
γ : Type ?u.243808
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
a b : Ordinal
b0 : b ≠ 0
⊢ b * a / b = a
Theorem: subalgebra_top_rank_eq_submodule_top_rank
File: Mathlib/LinearAlgebra/Finrank.lean

tactic: rw [← Algebra.top_toSubmodule]
state_before: K : Type u
V : Type v
F : Type u_2
E : Type u_1
inst✝² : CommRing F
inst✝¹ : Ring E
inst✝ : Algebra F E
⊢ Module.rank F { x // x ∈ ⊤ } = Module.rank F { x // x ∈ ⊤ }

tactic: rfl
state_before: K : Type u
V : Type v
F : Type u_2
E : Type u_1
inst✝² : CommRing F
inst✝¹ : Ring E
inst✝ : Algebra F E
⊢ Module.rank F { x // x ∈ ⊤ } = Module.rank F { x // x ∈ ↑Subalgebra.toSubmodule ⊤ }
Theorem: Finset.subset_inter
File: Mathlib/Data/Finset/Basic.lean

tactic: simp (config := { contextual := true }) [subset_iff, mem_inter]
state_before: α : Type u_1
β : Type ?u.174037
γ : Type ?u.174040
inst✝ : DecidableEq α
s s₁✝ s₂✝ t t₁ t₂ u✝ v : Finset α
a b : α
s₁ s₂ u : Finset α
⊢ s₁ ⊆ s₂ → s₁ ⊆ u → s₁ ⊆ s₂ ∩ u
Theorem: Sym2.mk''_eq_mk''_iff
File: Mathlib/Data/Sym/Sym2.lean

tactic: cases p
state_before: α : Type u_1
β : Type ?u.5513
γ : Type ?u.5516
p q : α × α
⊢ Quotient.mk (Rel.setoid α) p = Quotient.mk (Rel.setoid α) q ↔ p = q ∨ p = Prod.swap q

tactic: cases q
state_before: case mk
α : Type u_1
β : Type ?u.5513
γ : Type ?u.5516
q : α × α
fst✝ snd✝ : α
⊢ Quotient.mk (Rel.setoid α) (fst✝, snd✝) = Quotient.mk (Rel.setoid α) q ↔ (fst✝, snd✝) = q ∨ (fst✝, snd✝) = Prod.swap q

tactic: simp only [eq_iff, Prod.mk.inj_iff, Prod.swap_prod_mk]
state_before: case mk.mk
α : Type u_1
β : Type ?u.5513
γ : Type ?u.5516
fst✝¹ snd✝¹ fst✝ snd✝ : α
⊢ Quotient.mk (Rel.setoid α) (fst✝¹, snd✝¹) = Quotient.mk (Rel.setoid α) (fst✝, snd✝) ↔
    (fst✝¹, snd✝¹) = (fst✝, snd✝) ∨ (fst✝¹, snd✝¹) = Prod.swap (fst✝, snd✝)
Theorem: Metric.hausdorffDist_closure₂
File: Mathlib/Topology/MetricSpace/HausdorffDistance.lean

tactic: simp [hausdorffDist]
state_before: ι : Sort ?u.86905
α : Type u
β : Type v
inst✝¹ : PseudoMetricSpace α
inst✝ : PseudoMetricSpace β
s t u : Set α
x y : α
Φ : α → β
⊢ hausdorffDist s (closure t) = hausdorffDist s t
Theorem: Orthonormal.exists_hilbertBasis_extension
File: Mathlib/Analysis/InnerProductSpace/l2Space.lean

tactic: simpa [maximal_orthonormal_iff_orthogonalComplement_eq_bot hw_ortho] using hw_max
state_before: ι : Type ?u.915782
𝕜 : Type u_2
inst✝⁴ : IsROrC 𝕜
E : Type u_1
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace 𝕜 E
cplt : CompleteSpace E
G : ι → Type ?u.915933
inst✝¹ : (i : ι) → NormedAddCommGroup (G i)
inst✝ : (i : ι) → InnerProductSpace 𝕜 (G i)
v : ι → E
hv : Orthonormal 𝕜 v
s : Set E
hs : Orthonormal 𝕜 Subtype.val
w : Set E
hws : w ⊇ s
hw_ortho : Orthonormal 𝕜 Subtype.val
hw_max : ∀ (u : Set E), u ⊇ w → Orthonormal 𝕜 Subtype.val → u = w
⊢ (span 𝕜 (Set.range Subtype.val))ᗮ = ⊥
Theorem: BoxIntegral.Prepartition.split_of_not_mem_Ioo
File: Mathlib/Analysis/BoxIntegral/Partition/Split.lean

tactic: refine' ((isPartitionTop I).eq_of_boxes_subset fun J hJ => _).symm
state_before: ι : Type u_1
M : Type ?u.36480
n : ℕ
I J : Box ι
i : ι
x : ℝ
h : ¬x ∈ Ioo (Box.lower I i) (Box.upper I i)
⊢ split I i x = ⊤

tactic: rcases mem_top.1 hJ with rfl
state_before: ι : Type u_1
M : Type ?u.36480
n : ℕ
I J✝ : Box ι
i : ι
x : ℝ
h : ¬x ∈ Ioo (Box.lower I i) (Box.upper I i)
J : Box ι
hJ : J ∈ ⊤.boxes
⊢ J ∈ (split I i x).boxes

tactic: clear hJ
state_before: ι : Type u_1
M : Type ?u.36480
n : ℕ
J✝ : Box ι
i : ι
x : ℝ
J : Box ι
h : ¬x ∈ Ioo (Box.lower J i) (Box.upper J i)
hJ : J ∈ ⊤.boxes
⊢ J ∈ (split J i x).boxes

tactic: rw [mem_boxes, mem_split_iff]
state_before: ι : Type u_1
M : Type ?u.36480
n : ℕ
J✝ : Box ι
i : ι
x : ℝ
J : Box ι
h : ¬x ∈ Ioo (Box.lower J i) (Box.upper J i)
⊢ J ∈ (split J i x).boxes

tactic: rw [mem_Ioo, not_and_or, not_lt, not_lt] at h
state_before: ι : Type u_1
M : Type ?u.36480
n : ℕ
J✝ : Box ι
i : ι
x : ℝ
J : Box ι
h : ¬x ∈ Ioo (Box.lower J i) (Box.upper J i)
⊢ ↑J = Box.splitLower J i x ∨ ↑J = Box.splitUpper J i x

tactic: cases h <;> [right; left]
state_before: ι : Type u_1
M : Type ?u.36480
n : ℕ
J✝ : Box ι
i : ι
x : ℝ
J : Box ι
h : x ≤ Box.lower J i ∨ Box.upper J i ≤ x
⊢ ↑J = Box.splitLower J i x ∨ ↑J = Box.splitUpper J i x

tactic: rwa [eq_comm, Box.splitUpper_eq_self]
state_before: case inl.h
ι : Type u_1
M : Type ?u.36480
n : ℕ
J✝ : Box ι
i : ι
x : ℝ
J : Box ι
h✝ : x ≤ Box.lower J i
⊢ ↑J = Box.splitUpper J i x

tactic: rwa [eq_comm, Box.splitLower_eq_self]
state_before: case inr.h
ι : Type u_1
M : Type ?u.36480
n : ℕ
J✝ : Box ι
i : ι
x : ℝ
J : Box ι
h✝ : Box.upper J i ≤ x
⊢ ↑J = Box.splitLower J i x
Theorem: Real.arccos_of_one_le
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Inverse.lean

tactic: rw [arccos, arcsin_of_one_le hx, sub_self]
state_before: x : ℝ
hx : 1 ≤ x
⊢ arccos x = 0
Theorem: Function.minimalPeriod_eq_prime_pow
File: Mathlib/Dynamics/PeriodicPts.lean

tactic: apply Nat.eq_prime_pow_of_dvd_least_prime_pow hp.out <;>
  rwa [← isPeriodicPt_iff_minimalPeriod_dvd]
state_before: α : Type u_1
β : Type ?u.27026
f fa : α → α
fb : β → β
x y : α
m n p k : ℕ
hp : Fact (Nat.Prime p)
hk : ¬IsPeriodicPt f (p ^ k) x
hk1 : IsPeriodicPt f (p ^ (k + 1)) x
⊢ minimalPeriod f x = p ^ (k + 1)
Theorem: Subgroup.closure_le_normalClosure
File: Mathlib/GroupTheory/Subgroup/Basic.lean

tactic: simp only [subset_normalClosure, closure_le]
state_before: G : Type u_1
G' : Type ?u.445572
inst✝² : Group G
inst✝¹ : Group G'
A : Type ?u.445581
inst✝ : AddGroup A
s✝ s : Set G
⊢ closure s ≤ normalClosure s
Theorem: Finset.prod_range_add_one_eq_factorial
File: Mathlib/Algebra/BigOperators/Intervals.lean

tactic: simp [Finset.range_succ, prod_range_add_one_eq_factorial n]
state_before: α : Type u
β : Type v
γ : Type w
s₂ s₁ s : Finset α
a : α
g f : α → β
inst✝ : CommMonoid β
n : ℕ
⊢ ∏ x in range (n + 1), (x + 1) = (n + 1)!
Theorem: Finset.noncommProd_toFinset
File: Mathlib/Data/Finset/NoncommProd.lean

tactic: rw [← List.dedup_eq_self] at hl
state_before: F : Type ?u.140576
ι : Type ?u.140579
α : Type u_1
β : Type u_2
γ : Type ?u.140588
f✝ : α → β → β
op : α → α → α
inst✝² : Monoid β
inst✝¹ : Monoid γ
inst✝ : DecidableEq α
l : List α
f : α → β
comm : Set.Pairwise ↑(List.toFinset l) fun a b => Commute (f a) (f b)
hl : List.Nodup l
⊢ noncommProd (List.toFinset l) f comm = List.prod (List.map f l)

tactic: simp [noncommProd, hl]
state_before: F : Type ?u.140576
ι : Type ?u.140579
α : Type u_1
β : Type u_2
γ : Type ?u.140588
f✝ : α → β → β
op : α → α → α
inst✝² : Monoid β
inst✝¹ : Monoid γ
inst✝ : DecidableEq α
l : List α
f : α → β
comm : Set.Pairwise ↑(List.toFinset l) fun a b => Commute (f a) (f b)
hl✝ : List.Nodup l
hl : List.dedup l = l
⊢ noncommProd (List.toFinset l) f comm = List.prod (List.map f l)