tasksource/leandojo huggingface dataset:
Theorem: memℓp_zero_iff
File: Mathlib/Analysis/NormedSpace/lpSpace.lean

tactic: dsimp [Memℓp]
state_before: α : Type u_1
E : α → Type u_2
p q : ℝ≥0∞
inst✝ : (i : α) → NormedAddCommGroup (E i)
f : (i : α) → E i
⊢ Memℓp f 0 ↔ Set.Finite {i | f i ≠ 0}

tactic: rw [if_pos rfl]
state_before: α : Type u_1
E : α → Type u_2
p q : ℝ≥0∞
inst✝ : (i : α) → NormedAddCommGroup (E i)
f : (i : α) → E i
⊢ (if 0 = 0 then Set.Finite {i | ¬f i = 0}
    else if 0 = ⊤ then BddAbove (Set.range fun i => ‖f i‖) else Summable fun i => ‖f i‖ ^ 0) ↔
    Set.Finite {i | ¬f i = 0}
Theorem: spectrum.not_mem_iff
File: Mathlib/Algebra/Algebra/Spectrum.lean

tactic: apply not_iff_not.mp
state_before: R : Type u
A : Type v
inst✝² : CommSemiring R
inst✝¹ : Ring A
inst✝ : Algebra R A
r : R
a : A
⊢ ¬r ∈ σ a ↔ IsUnit (↑↑ₐ r - a)

tactic: simp [Set.not_not_mem, mem_iff]
state_before: R : Type u
A : Type v
inst✝² : CommSemiring R
inst✝¹ : Ring A
inst✝ : Algebra R A
r : R
a : A
⊢ ¬¬r ∈ σ a ↔ ¬IsUnit (↑↑ₐ r - a)
Theorem: Multiset.pow_card_le_prod
File: Mathlib/Algebra/BigOperators/Multiset/Basic.lean

tactic: rw [← Multiset.prod_replicate, ← Multiset.map_const]
state_before: ι : Type ?u.130494
α : Type u_1
β : Type ?u.130500
γ : Type ?u.130503
inst✝ : OrderedCommMonoid α
s t : Multiset α
a : α
h : ∀ (x : α), x ∈ s → a ≤ x
⊢ a ^ ↑card s ≤ prod s

tactic: exact prod_map_le_prod _ h
state_before: ι : Type ?u.130494
α : Type u_1
β : Type ?u.130500
γ : Type ?u.130503
inst✝ : OrderedCommMonoid α
s t : Multiset α
a : α
h : ∀ (x : α), x ∈ s → a ≤ x
⊢ prod (map (Function.const α a) s) ≤ prod s
Theorem: BilinForm.IsAdjointPair.comp
File: Mathlib/LinearAlgebra/BilinearForm.lean

tactic: rw [LinearMap.comp_apply, LinearMap.comp_apply, h', h]
state_before: R : Type u_1
M : Type u_4
inst✝²⁴ : Semiring R
inst✝²³ : AddCommMonoid M
inst✝²² : Module R M
R₁ : Type ?u.1095252
M₁ : Type ?u.1095255
inst✝²¹ : Ring R₁
inst✝²⁰ : AddCommGroup M₁
inst✝¹⁹ : Module R₁ M₁
R₂ : Type ?u.1095864
M₂ : Type ?u.1095867
inst✝¹⁸ : CommSemiring R₂
inst✝¹⁷ : AddCommMonoid M₂
inst✝¹⁶ : Module R₂ M₂
R₃ : Type ?u.1096054
M₃ : Type ?u.1096057
inst✝¹⁵ : CommRing R₃
inst✝¹⁴ : AddCommGroup M₃
inst✝¹³ : Module R₃ M₃
V : Type ?u.1096645
K : Type ?u.1096648
inst✝¹² : Field K
inst✝¹¹ : AddCommGroup V
inst✝¹⁰ : Module K V
B : BilinForm R M
B₁ : BilinForm R₁ M₁
B₂ : BilinForm R₂ M₂
M₂' : Type ?u.1097862
M₂'' : Type ?u.1097865
inst✝⁹ : AddCommMonoid M₂'
inst✝⁸ : AddCommMonoid M₂''
inst✝⁷ : Module R₂ M₂'
inst✝⁶ : Module R₂ M₂''
F : BilinForm R M
M' : Type u_2
inst✝⁵ : AddCommMonoid M'
inst✝⁴ : Module R M'
B' : BilinForm R M'
f f'✝ : M →ₗ[R] M'
g g'✝ : M' →ₗ[R] M
M₁' : Type ?u.1098613
inst✝³ : AddCommGroup M₁'
inst✝² : Module R₁ M₁'
B₁' : BilinForm R₁ M₁'
f₁ f₁' : M₁ →ₗ[R₁] M₁'
g₁ g₁' : M₁' →ₗ[R₁] M₁
B₂' : BilinForm R₂ M₂'
f₂ f₂' : M₂ →ₗ[R₂] M₂'
g₂ g₂' : M₂' →ₗ[R₂] M₂
M'' : Type u_3
inst✝¹ : AddCommMonoid M''
inst✝ : Module R M''
B'' : BilinForm R M''
f' : M' →ₗ[R] M''
g' : M'' →ₗ[R] M'
h : IsAdjointPair B B' f g
h' : IsAdjointPair B' B'' f' g'
x : M
y : M''
⊢ bilin B'' (↑(LinearMap.comp f' f) x) y = bilin B x (↑(LinearMap.comp g g') y)
Theorem: star_div'
File: Mathlib/Algebra/Star/Basic.lean

tactic: apply op_injective
state_before: R : Type u
inst✝¹ : Semifield R
inst✝ : StarRing R
x y : R
⊢ star (x / y) = star x / star y

tactic: rw [division_def, op_div, mul_comm, star_mul, star_inv', op_mul, op_inv]
state_before: case a
R : Type u
inst✝¹ : Semifield R
inst✝ : StarRing R
x y : R
⊢ op (star (x / y)) = op (star x / star y)
Theorem: Submodule.isTorsion'_iff_torsion'_eq_top
File: Mathlib/Algebra/Module/Torsion.lean

tactic: rw [← @mem_torsion'_iff R, h]
state_before: R : Type u_3
M : Type u_1
inst✝⁵ : CommSemiring R
inst✝⁴ : AddCommMonoid M
inst✝³ : Module R M
S : Type u_2
inst✝² : CommMonoid S
inst✝¹ : DistribMulAction S M
inst✝ : SMulCommClass S R M
h : torsion' R M S = ⊤
x : M
⊢ ∃ a, a • x = 0

tactic: trivial
state_before: R : Type u_3
M : Type u_1
inst✝⁵ : CommSemiring R
inst✝⁴ : AddCommMonoid M
inst✝³ : Module R M
S : Type u_2
inst✝² : CommMonoid S
inst✝¹ : DistribMulAction S M
inst✝ : SMulCommClass S R M
h : torsion' R M S = ⊤
x : M
⊢ x ∈ ⊤
Theorem: Turing.ToPartrec.Code.succ_eval
File: Mathlib/Computability/TMToPartrec.lean

tactic: simp [eval]
state_before: ⊢ eval succ = fun v => pure [Nat.succ (List.headI v)]
Theorem: List.zipWith_eq_nil_iff
File: Mathlib/Data/List/Zip.lean

tactic: cases l <;> cases l' <;> simp
state_before: α : Type u
β : Type u_1
γ : Type u_2
δ : Type ?u.614
ε : Type ?u.617
f : α → β → γ
l : List α
l' : List β
⊢ zipWith f l l' = [] ↔ l = [] ∨ l' = []
Theorem: contDiff_succ_iff_deriv
File: Mathlib/Analysis/Calculus/ContDiff.lean

tactic: simp only [← contDiffOn_univ, contDiffOn_succ_iff_deriv_of_open, isOpen_univ,
  differentiableOn_univ]
state_before: 𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type ?u.3055922
inst✝¹ : NormedAddCommGroup X
inst✝ : NormedSpace 𝕜 X
s s₁ t u : Set E
f f₁ : E → F
g : F → G
x x₀ : E
c : F
b : E × F → G
m n✝ : ℕ∞
p : E → FormalMultilinearSeries 𝕜 E F
f₂ : 𝕜 → F
s₂ : Set 𝕜
n : ℕ
⊢ ContDiff 𝕜 (↑(n + 1)) f₂ ↔ Differentiable 𝕜 f₂ ∧ ContDiff 𝕜 (↑n) (deriv f₂)
Theorem: Finset.disjSups_empty_right
File: Mathlib/Data/Finset/Sups.lean

tactic: simp [disjSups]
state_before: α : Type u_1
inst✝³ : DecidableEq α
inst✝² : SemilatticeSup α
inst✝¹ : OrderBot α
inst✝ : DecidableRel Disjoint
s s₁ s₂ t t₁ t₂ u : Finset α
a b c : α
⊢ s ○ ∅ = ∅
Theorem: div_lt_iff_lt_mul'
File: Mathlib/Algebra/Order/Group/Defs.lean

tactic: rw [div_lt_iff_lt_mul, mul_comm]
state_before: α : Type u
inst✝² : CommGroup α
inst✝¹ : LT α
inst✝ : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x < x_1
a b c d : α
⊢ a / b < c ↔ a < b * c
Theorem: List.eq_replicate_length
File: Mathlib/Data/List/Basic.lean

tactic: simp
state_before: ι : Type ?u.12121
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α
a : α
⊢ [] = replicate (length []) a ↔ ∀ (b : α), b ∈ [] → b = a

tactic: simp [eq_replicate_length]
state_before: ι : Type ?u.12121
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α
a b : α
l : List α
⊢ b :: l = replicate (length (b :: l)) a ↔ ∀ (b_1 : α), b_1 ∈ b :: l → b_1 = a
Theorem: Finset.two_lt_card
File: Mathlib/Data/Finset/Card.lean

tactic: simp_rw [two_lt_card_iff, exists_and_left]
state_before: α : Type u_1
β : Type ?u.58012
s t : Finset α
f : α → β
n : ℕ
⊢ 2 < card s ↔ ∃ a, a ∈ s ∧ ∃ b, b ∈ s ∧ ∃ c, c ∈ s ∧ a ≠ b ∧ a ≠ c ∧ b ≠ c
Theorem: CategoryTheory.MonoidalCategory.rightUnitor_inv_naturality
File: Mathlib/CategoryTheory/Monoidal/Category.lean

tactic: simp
state_before: C✝ : Type u
𝒞 : Category C✝
inst✝² : MonoidalCategory C✝
C : Type u
inst✝¹ : Category C
inst✝ : MonoidalCategory C
U V W X✝ Y Z X X' : C
f : X ⟶ X'
⊢ f ≫ (ρ_ X').inv = (ρ_ X).inv ≫ (f ⊗ 𝟙 tensorUnit')
Theorem: LinearMap.trace_eq_contract_of_basis'
File: Mathlib/LinearAlgebra/Trace.lean

tactic: simp [LinearEquiv.eq_comp_toLinearMap_symm, trace_eq_contract_of_basis b]
state_before: R : Type u_2
inst✝⁶ : CommRing R
M : Type u_3
inst✝⁵ : AddCommGroup M
inst✝⁴ : Module R M
N : Type ?u.355819
inst✝³ : AddCommGroup N
inst✝² : Module R N
ι : Type u_1
inst✝¹ : Fintype ι
inst✝ : DecidableEq ι
b : Basis ι R M
⊢ trace R M = comp (contractLeft R M) ↑(LinearEquiv.symm (dualTensorHomEquivOfBasis b))
Theorem: Multiset.inter_le_right
File: Mathlib/Data/Multiset/Basic.lean

tactic: simpa [h] using cons_le_cons a (IH (t.erase a))
state_before: α : Type u_1
β : Type ?u.174218
γ : Type ?u.174221
inst✝ : DecidableEq α
s✝¹ t✝ u : Multiset α
a✝ b : α
s✝ : Multiset α
a : α
s : Multiset α
IH : ∀ (t : Multiset α), s ∩ t ≤ t
t : Multiset α
h : a ∈ t
⊢ (a ::ₘ s) ∩ t ≤ t

tactic: simp [h, IH]
state_before: α : Type u_1
β : Type ?u.174218
γ : Type ?u.174221
inst✝ : DecidableEq α
s✝¹ t✝ u : Multiset α
a✝ b : α
s✝ : Multiset α
a : α
s : Multiset α
IH : ∀ (t : Multiset α), s ∩ t ≤ t
t : Multiset α
h : ¬a ∈ t
⊢ (a ::ₘ s) ∩ t ≤ t
Theorem: CategoryTheory.Limits.imageSubobject_comp_le
File: Mathlib/CategoryTheory/Subobject/Limits.lean

tactic: simp
state_before: C : Type u
inst✝³ : Category C
X Y Z : C
f✝ : X ⟶ Y
inst✝² : HasImage f✝
X' : C
h : X' ⟶ X
f : X ⟶ Y
inst✝¹ : HasImage f
inst✝ : HasImage (h ≫ f)
⊢ image.preComp h f ≫ image.ι f = image.ι (h ≫ f)
Theorem: LieIdeal.map_comap_bracket_eq
File: Mathlib/Algebra/Lie/IdealOperations.lean

tactic: rw [← map_sup_ker_eq_map, ← comap_bracket_eq h, map_comap_eq h, inf_eq_right]
state_before: R : Type u
L : Type v
L' : Type w₂
inst✝⁴ : CommRing R
inst✝³ : LieRing L
inst✝² : LieAlgebra R L
inst✝¹ : LieRing L'
inst✝ : LieAlgebra R L'
f : L →ₗ⁅R⁆ L'
I : LieIdeal R L
J J₁ J₂ : LieIdeal R L'
h : LieHom.IsIdealMorphism f
⊢ map f ⁅comap f J₁, comap f J₂⁆ = ⁅LieHom.idealRange f ⊓ J₁, LieHom.idealRange f ⊓ J₂⁆

tactic: exact le_trans (LieSubmodule.lie_le_left _ _) inf_le_left
state_before: R : Type u
L : Type v
L' : Type w₂
inst✝⁴ : CommRing R
inst✝³ : LieRing L
inst✝² : LieAlgebra R L
inst✝¹ : LieRing L'
inst✝ : LieAlgebra R L'
f : L →ₗ⁅R⁆ L'
I : LieIdeal R L
J J₁ J₂ : LieIdeal R L'
h : LieHom.IsIdealMorphism f
⊢ ⁅LieHom.idealRange f ⊓ J₁, LieHom.idealRange f ⊓ J₂⁆ ≤ LieHom.idealRange f
Theorem: PNat.exists_prime_and_dvd
File: Mathlib/Data/PNat/Prime.lean

tactic: obtain ⟨p, hp⟩ := Nat.exists_prime_and_dvd (mt coe_eq_one_iff.mp hn)
state_before: n : ℕ+
hn : n ≠ 1
⊢ ∃ p, Prime p ∧ p ∣ n

tactic: exists (⟨p, Nat.Prime.pos hp.left⟩ : ℕ+)
state_before: case intro
n : ℕ+
hn : n ≠ 1
p : ℕ
hp : Nat.Prime p ∧ p ∣ ↑n
⊢ ∃ p, Prime p ∧ p ∣ n

tactic: rw [dvd_iff]
state_before: case intro
n : ℕ+
hn : n ≠ 1
p : ℕ
hp : Nat.Prime p ∧ p ∣ ↑n
⊢ Prime { val := p, property := (_ : 0 < p) } ∧ { val := p, property := (_ : 0 < p) } ∣ n

tactic: apply hp
state_before: case intro
n : ℕ+
hn : n ≠ 1
p : ℕ
hp : Nat.Prime p ∧ p ∣ ↑n
⊢ Prime { val := p, property := (_ : 0 < p) } ∧ ↑{ val := p, property := (_ : 0 < p) } ∣ ↑n
Theorem: Asymptotics.superpolynomialDecay_zero
File: Mathlib/Analysis/Asymptotics/SuperpolynomialDecay.lean

tactic: simpa only [Pi.zero_apply, MulZeroClass.mul_zero] using tendsto_const_nhds
state_before: α : Type u_1
β : Type u_2
l✝ : Filter α
k✝ f g g' : α → β
inst✝¹ : TopologicalSpace β
inst✝ : CommSemiring β
l : Filter α
k : α → β
z : ℕ
⊢ Tendsto (fun a => k a ^ z * OfNat.ofNat 0 a) l (𝓝 0)
Theorem: Multiset.toFinset_add
File: Mathlib/Data/Finset/Basic.lean

tactic: simp
state_before: α : Type u_1
β : Type ?u.446238
γ : Type ?u.446241
inst✝ : DecidableEq α
s✝ t✝ s t : Multiset α
⊢ ∀ (a : α), a ∈ toFinset (s + t) ↔ a ∈ toFinset s ∪ toFinset t
Theorem: CategoryTheory.Limits.IsTerminal.hasTerminal
File: Mathlib/CategoryTheory/Limits/Shapes/Terminal.lean

tactic: aesop_cat
state_before: C : Type u₁
inst✝ : Category C
X : C
h : IsTerminal X
F : Discrete PEmpty ⥤ C
⊢ (X_1 : Discrete PEmpty) → ((Functor.const (Discrete PEmpty)).obj X).obj X_1 ⟶ F.obj X_1

tactic: aesop_cat
state_before: C : Type u₁
inst✝ : Category C
X : C
h : IsTerminal X
F : Discrete PEmpty ⥤ C
⊢ ∀ ⦃X_1 Y : Discrete PEmpty⦄ (f : X_1 ⟶ Y),
    ((Functor.const (Discrete PEmpty)).obj X).map f ≫ id (Discrete.casesOn Y fun as => False.elim (_ : False)) =
      id (Discrete.casesOn X_1 fun as => False.elim (_ : False)) ≫ F.map f
Theorem: Ordinal.add_sub_add_cancel
File: Mathlib/SetTheory/Ordinal/Arithmetic.lean

tactic: rw [← sub_sub, add_sub_cancel]
state_before: α : Type ?u.133314
β : Type ?u.133317
γ : Type ?u.133320
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
a b c : Ordinal
⊢ a + b - (a + c) = b - c
Theorem: Path.truncate_range
File: Mathlib/Topology/PathConnected.lean

tactic: rw [← γ.extend_range]
state_before: X✝ : Type ?u.458739
Y : Type ?u.458742
inst✝² : TopologicalSpace X✝
inst✝¹ : TopologicalSpace Y
x y z : X✝
ι : Type ?u.458757
γ✝ : Path x y
X : Type u_1
inst✝ : TopologicalSpace X
a b : X
γ : Path a b
t₀ t₁ : ℝ
⊢ range ↑(truncate γ t₀ t₁) ⊆ range ↑γ

tactic: simp only [range_subset_iff, SetCoe.exists, SetCoe.forall]
state_before: X✝ : Type ?u.458739
Y : Type ?u.458742
inst✝² : TopologicalSpace X✝
inst✝¹ : TopologicalSpace Y
x y z : X✝
ι : Type ?u.458757
γ✝ : Path x y
X : Type u_1
inst✝ : TopologicalSpace X
a b : X
γ : Path a b
t₀ t₁ : ℝ
⊢ range ↑(truncate γ t₀ t₁) ⊆ range (extend γ)

tactic: intro x _hx
state_before: X✝ : Type ?u.458739
Y : Type ?u.458742
inst✝² : TopologicalSpace X✝
inst✝¹ : TopologicalSpace Y
x y z : X✝
ι : Type ?u.458757
γ✝ : Path x y
X : Type u_1
inst✝ : TopologicalSpace X
a b : X
γ : Path a b
t₀ t₁ : ℝ
⊢ ∀ (x : ℝ) (h : x ∈ I), ↑(truncate γ t₀ t₁) { val := x, property := h } ∈ range (extend γ)

tactic: simp only [FunLike.coe, Path.truncate, mem_range_self]
state_before: X✝ : Type ?u.458739
Y : Type ?u.458742
inst✝² : TopologicalSpace X✝
inst✝¹ : TopologicalSpace Y
x✝ y z : X✝
ι : Type ?u.458757
γ✝ : Path x✝ y
X : Type u_1
inst✝ : TopologicalSpace X
a b : X
γ : Path a b
t₀ t₁ x : ℝ
_hx : x ∈ I
⊢ ↑(truncate γ t₀ t₁) { val := x, property := _hx } ∈ range (extend γ)
Theorem: Matrix.cons_val_succ'
File: Mathlib/Data/Fin/VecNotation.lean

tactic: simp only [vecCons, Fin.cons, Fin.cases_succ']
state_before: α : Type u
m n o : ℕ
m' : Type ?u.14497
n' : Type ?u.14500
o' : Type ?u.14503
i : ℕ
h : Nat.succ i < Nat.succ m
x : α
u : Fin m → α
⊢ vecCons x u { val := Nat.succ i, isLt := h } = u { val := i, isLt := (_ : i < m) }
Theorem: Affine.Simplex.face_eq_mkOfPoint
File: Mathlib/LinearAlgebra/AffineSpace/Independent.lean

tactic: ext
state_before: k : Type u_1
V : Type u_2
P : Type u_3
inst✝³ : Ring k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
n : ℕ
s : Simplex k P n
i : Fin (n + 1)
⊢ face s (_ : Finset.card {i} = 1) = mkOfPoint k (points s i)

tactic: simp only [Affine.Simplex.mkOfPoint_points, Affine.Simplex.face_points]
state_before: case h
k : Type u_1
V : Type u_2
P : Type u_3
inst✝³ : Ring k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
n : ℕ
s : Simplex k P n
i : Fin (n + 1)
i✝ : Fin (0 + 1)
⊢ points (face s (_ : Finset.card {i} = 1)) i✝ = points (mkOfPoint k (points s i)) i✝

tactic: rw [Finset.orderEmbOfFin_singleton]
state_before: case h
k : Type u_1
V : Type u_2
P : Type u_3
inst✝³ : Ring k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
n : ℕ
s : Simplex k P n
i : Fin (n + 1)
i✝ : Fin (0 + 1)
⊢ points s (↑(Finset.orderEmbOfFin {i} (_ : Finset.card {i} = 1)) i✝) = points s i
Theorem: CategoryTheory.GrothendieckTopology.arrow_intersect
File: Mathlib/CategoryTheory/Sites/Grothendieck.lean

tactic: simpa [covers_iff] using And.intro hS hR
state_before: C : Type u
inst✝ : Category C
X Y : C
S✝ R✝ : Sieve X
J : GrothendieckTopology C
f : Y ⟶ X
S R : Sieve X
hS : Covers J S f
hR : Covers J R f
⊢ Covers J (S ⊓ R) f
Theorem: Int.norm_coe_units
File: Mathlib/Analysis/NormedSpace/Int.lean

tactic: rw [← coe_nnnorm, nnnorm_coe_units, NNReal.coe_one]
state_before: e : ℤˣ
⊢ ‖↑e‖ = 1
Theorem: Nat.div_mod_eq_mod_mul_div
File: Mathlib/Data/Nat/ModEq.lean

tactic: simp [hb0]
state_before: m n a✝ b✝ c✝ d a b c : ℕ
hb0 : b = 0
⊢ a / b % c = a % (b * c) / b

tactic: rw [← @add_right_cancel_iff _ _ _ (c * (a / b / c)), mod_add_div, Nat.div_div_eq_div_mul, ←
  mul_right_inj' hb0, ← @add_left_cancel_iff _ _ _ (a % b), mod_add_div, mul_add, ←
  @add_left_cancel_iff _ _ _ (a % (b * c) % b), add_left_comm, ← add_assoc (a % (b * c) % b),
  mod_add_div, ← mul_assoc, mod_add_div, mod_mul_right_mod]
state_before: m n a✝ b✝ c✝ d a b c : ℕ
hb0 : ¬b = 0
⊢ a / b % c = a % (b * c) / b
Theorem: Units.dvd_mul_right
File: Mathlib/Algebra/Divisibility/Units.lean

tactic: rw [← mul_assoc, ← Eq, Units.mul_inv_cancel_right]
state_before: α : Type u_1
inst✝ : Monoid α
a b : α
u : αˣ
x✝ : a ∣ b * ↑u
c : α
Eq : b * ↑u = a * c
⊢ b = a * (c * ↑u⁻¹)
Theorem: invOf_div
File: Mathlib/Algebra/Invertible.lean

tactic: simp [← mul_div_assoc]
state_before: α : Type u
inst✝³ : GroupWithZero α
a b : α
inst✝² : Invertible a
inst✝¹ : Invertible b
inst✝ : Invertible (a / b)
⊢ a / b * (b / a) = 1
Theorem: LocalHomeomorph.extend_left_inv
File: Mathlib/Geometry/Manifold/SmoothManifoldWithCorners.lean

tactic: rwa [f.extend_source]
state_before: 𝕜 : Type u_4
E : Type u_3
M : Type u_1
H : Type u_2
E' : Type ?u.133168
M' : Type ?u.133171
H' : Type ?u.133174
inst✝⁸ : NontriviallyNormedField 𝕜
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
inst✝⁵ : TopologicalSpace H
inst✝⁴ : TopologicalSpace M
f f' : LocalHomeomorph M H
I : ModelWithCorners 𝕜 E H
inst✝³ : NormedAddCommGroup E'
inst✝² : NormedSpace 𝕜 E'
inst✝¹ : TopologicalSpace H'
inst✝ : TopologicalSpace M'
I' : ModelWithCorners 𝕜 E' H'
x✝ : M
s t : Set M
x : M
hxf : x ∈ f.source
⊢ x ∈ (extend f I).source
Theorem: Multiset.mem_powersetLen
File: Mathlib/Data/Multiset/Powerset.lean

tactic: simp [powersetLen_coe']
state_before: α : Type u_1
n : ℕ
s t : Multiset α
l : List α
⊢ s ∈ powersetLen n (Quotient.mk (isSetoid α) l) ↔ s ≤ Quotient.mk (isSetoid α) l ∧ ↑card s = n
Theorem: Set.disjoint_prod
File: Mathlib/Data/Set/Prod.lean

tactic: simp_rw [disjoint_left, mem_prod, not_and_or, Prod.forall, and_imp, ← @forall_or_right α, ←
  @forall_or_left β, ← @forall_or_right (_ ∈ s₁), ← @forall_or_left (_ ∈ t₁)]
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.14121
δ : Type ?u.14124
s s₁ s₂ : Set α
t t₁ t₂ : Set β
a : α
b : β
⊢ Disjoint (s₁ ×ˢ t₁) (s₂ ×ˢ t₂) ↔ Disjoint s₁ s₂ ∨ Disjoint t₁ t₂
Theorem: LocallyConstant.comap_comp
File: Mathlib/Topology/LocallyConstant/Basic.lean

tactic: ext
state_before: X : Type u_2
Y : Type u_3
Z : Type u_1
α : Type u_4
inst✝² : TopologicalSpace X
inst✝¹ : TopologicalSpace Y
inst✝ : TopologicalSpace Z
f : X → Y
g : Y → Z
hf : Continuous f
hg : Continuous g
⊢ comap f ∘ comap g = comap (g ∘ f)

tactic: rw [Function.comp_apply]
state_before: case h.h
X : Type u_2
Y : Type u_3
Z : Type u_1
α : Type u_4
inst✝² : TopologicalSpace X
inst✝¹ : TopologicalSpace Y
inst✝ : TopologicalSpace Z
f : X → Y
g : Y → Z
hf : Continuous f
hg : Continuous g
x✝¹ : LocallyConstant Z α
x✝ : X
⊢ ↑((comap f ∘ comap g) x✝¹) x✝ = ↑(comap (g ∘ f) x✝¹) x✝

tactic: simp only [hf, hg, hg.comp hf, coe_comap]
state_before: case h.h
X : Type u_2
Y : Type u_3
Z : Type u_1
α : Type u_4
inst✝² : TopologicalSpace X
inst✝¹ : TopologicalSpace Y
inst✝ : TopologicalSpace Z
f : X → Y
g : Y → Z
hf : Continuous f
hg : Continuous g
x✝¹ : LocallyConstant Z α
x✝ : X
⊢ ↑(comap f (comap g x✝¹)) x✝ = ↑(comap (g ∘ f) x✝¹) x✝

tactic: rfl
state_before: case h.h
X : Type u_2
Y : Type u_3
Z : Type u_1
α : Type u_4
inst✝² : TopologicalSpace X
inst✝¹ : TopologicalSpace Y
inst✝ : TopologicalSpace Z
f : X → Y
g : Y → Z
hf : Continuous f
hg : Continuous g
x✝¹ : LocallyConstant Z α
x✝ : X
⊢ ((↑x✝¹ ∘ g) ∘ f) x✝ = (↑x✝¹ ∘ g ∘ f) x✝
Theorem: exists_succ_iterate_iff_le
File: Mathlib/Order/SuccPred/Basic.lean

tactic: refine' ⟨_, exists_succ_iterate_of_le⟩
state_before: α : Type u_1
inst✝² : Preorder α
inst✝¹ : SuccOrder α
inst✝ : IsSuccArchimedean α
a b : α
⊢ (∃ n, (succ^[n]) a = b) ↔ a ≤ b

tactic: rintro ⟨n, rfl⟩
state_before: α : Type u_1
inst✝² : Preorder α
inst✝¹ : SuccOrder α
inst✝ : IsSuccArchimedean α
a b : α
⊢ (∃ n, (succ^[n]) a = b) → a ≤ b

tactic: exact id_le_iterate_of_id_le le_succ n a
state_before: case intro
α : Type u_1
inst✝² : Preorder α
inst✝¹ : SuccOrder α
inst✝ : IsSuccArchimedean α
a : α
n : ℕ
⊢ a ≤ (succ^[n]) a
Theorem: Set.biInter_insert
File: Mathlib/Data/Set/Lattice.lean

tactic: simp
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.100478
ι : Sort ?u.100481
ι' : Sort ?u.100484
ι₂ : Sort ?u.100487
κ : ι → Sort ?u.100492
κ₁ : ι → Sort ?u.100497
κ₂ : ι → Sort ?u.100502
κ' : ι' → Sort ?u.100507
a : α
s : Set α
t : α → Set β
⊢ (⋂ (x : α) (_ : x ∈ insert a s), t x) = t a ∩ ⋂ (x : α) (_ : x ∈ s), t x
Theorem: QuaternionGroup.quaternionGroup_one_isCyclic
File: Mathlib/GroupTheory/SpecificGroups/Quaternion.lean

tactic: apply isCyclic_of_orderOf_eq_card
state_before: n : ℕ
⊢ IsCyclic (QuaternionGroup 1)

tactic: rw [card, mul_one]
state_before: case hx
n : ℕ
⊢ orderOf ?x = Fintype.card (QuaternionGroup 1)

case x
n : ℕ
⊢ QuaternionGroup 1

tactic: exact orderOf_xa 0
state_before: case hx
n : ℕ
⊢ orderOf ?x = 4

case x
n : ℕ
⊢ QuaternionGroup 1

case x
n : ℕ
⊢ QuaternionGroup 1

case x
n : ℕ
⊢ QuaternionGroup 1
Theorem: PadicInt.modPart_nonneg
File: Mathlib/NumberTheory/Padics/RingHoms.lean

tactic: exact_mod_cast hp_prime.1.ne_zero
state_before: p : ℕ
hp_prime : Fact (Nat.Prime p)
r : ℚ
⊢ ↑p ≠ 0
Theorem: tendsto_pow_neg_atTop
File: Mathlib/Topology/Algebra/Order/Field.lean

tactic: simpa only [zpow_neg, zpow_ofNat] using (@tendsto_pow_atTop 𝕜 _ _ hn).inv_tendsto_atTop
state_before: 𝕜 : Type u_1
α : Type ?u.31571
inst✝² : LinearOrderedField 𝕜
inst✝¹ : TopologicalSpace 𝕜
inst✝ : OrderTopology 𝕜
l : Filter α
f g : α → 𝕜
n : ℕ
hn : n ≠ 0
⊢ Tendsto (fun x => x ^ (-↑n)) atTop (𝓝 0)
Theorem: Set.countable_iUnion
File: Mathlib/Data/Set/Countable.lean

tactic: haveI := fun a => (ht a).to_subtype
state_before: α : Type u
β : Type v
γ : Type w
ι : Sort x
t : ι → Set α
inst✝ : Countable ι
ht : ∀ (i : ι), Set.Countable (t i)
⊢ Set.Countable (⋃ (i : ι), t i)

tactic: rw [iUnion_eq_range_psigma]
state_before: α : Type u
β : Type v
γ : Type w
ι : Sort x
t : ι → Set α
inst✝ : Countable ι
ht : ∀ (i : ι), Set.Countable (t i)
this : ∀ (a : ι), Countable ↑(t a)
⊢ Set.Countable (⋃ (i : ι), t i)

tactic: apply countable_range
state_before: α : Type u
β : Type v
γ : Type w
ι : Sort x
t : ι → Set α
inst✝ : Countable ι
ht : ∀ (i : ι), Set.Countable (t i)
this : ∀ (a : ι), Countable ↑(t a)
⊢ Set.Countable (range fun a => ↑a.snd)
Theorem: MeasureTheory.SimpleFunc.range_eq_empty_of_isEmpty
File: Mathlib/MeasureTheory/Function/SimpleFunc.lean

tactic: rw [← Finset.not_nonempty_iff_eq_empty]
state_before: α : Type u_2
β✝ : Type ?u.125758
γ : Type ?u.125761
δ : Type ?u.125764
inst✝ : MeasurableSpace α
β : Type u_1
hα : IsEmpty α
f : α →ₛ β
⊢ SimpleFunc.range f = ∅

tactic: by_contra h
state_before: α : Type u_2
β✝ : Type ?u.125758
γ : Type ?u.125761
δ : Type ?u.125764
inst✝ : MeasurableSpace α
β : Type u_1
hα : IsEmpty α
f : α →ₛ β
⊢ ¬Finset.Nonempty (SimpleFunc.range f)

tactic: obtain ⟨y, hy_mem⟩ := h
state_before: α : Type u_2
β✝ : Type ?u.125758
γ : Type ?u.125761
δ : Type ?u.125764
inst✝ : MeasurableSpace α
β : Type u_1
hα : IsEmpty α
f : α →ₛ β
h : Finset.Nonempty (SimpleFunc.range f)
⊢ False

tactic: rw [SimpleFunc.mem_range, Set.mem_range] at hy_mem
state_before: case intro
α : Type u_2
β✝ : Type ?u.125758
γ : Type ?u.125761
δ : Type ?u.125764
inst✝ : MeasurableSpace α
β : Type u_1
hα : IsEmpty α
f : α →ₛ β
y : β
hy_mem : y ∈ SimpleFunc.range f
⊢ False

tactic: obtain ⟨x, hxy⟩ := hy_mem
state_before: case intro
α : Type u_2
β✝ : Type ?u.125758
γ : Type ?u.125761
δ : Type ?u.125764
inst✝ : MeasurableSpace α
β : Type u_1
hα : IsEmpty α
f : α →ₛ β
y : β
hy_mem : ∃ y_1, ↑f y_1 = y
⊢ False

tactic: rw [isEmpty_iff] at hα
state_before: case intro.intro
α : Type u_2
β✝ : Type ?u.125758
γ : Type ?u.125761
δ : Type ?u.125764
inst✝ : MeasurableSpace α
β : Type u_1
hα : IsEmpty α
f : α →ₛ β
y : β
x : α
hxy : ↑f x = y
⊢ False

tactic: exact hα x
state_before: case intro.intro
α : Type u_2
β✝ : Type ?u.125758
γ : Type ?u.125761
δ : Type ?u.125764
inst✝ : MeasurableSpace α
β : Type u_1
hα : α → False
f : α →ₛ β
y : β
x : α
hxy : ↑f x = y
⊢ False
Theorem: Int.fract_periodic
File: Mathlib/Algebra/Periodic.lean

tactic: exact_mod_cast Int.fract_add_int a 1
state_before: α✝ : Type ?u.230327
β : Type ?u.230330
γ : Type ?u.230333
f g : α✝ → β
c c₁ c₂ x : α✝
α : Type u_1
inst✝¹ : LinearOrderedRing α
inst✝ : FloorRing α
a : α
⊢ fract (a + 1) = fract a
Theorem: Num.natSize_to_nat
File: Mathlib/Data/Num/Lemmas.lean

tactic: rw [← size_eq_natSize, size_to_nat]
state_before: α : Type ?u.444246
n : Num
⊢ natSize n = Nat.size ↑n
Theorem: prodXSubSmul.eval
File: Mathlib/Algebra/Polynomial/GroupRingAction.lean

tactic: simp
state_before: M : Type ?u.80364
inst✝⁴ : Monoid M
G : Type u_2
inst✝³ : Group G
inst✝² : Fintype G
R : Type u_1
inst✝¹ : CommRing R
inst✝ : MulSemiringAction G R
x : R
⊢ ↑↑↑(aeval x) (X - ↑C (ofQuotientStabilizer G x ↑1)) = 0