tasksource/leandojo huggingface dataset:
Theorem: Submodule.image2_subset_map₂
File: Mathlib/Algebra/Module/Submodule/Bilinear.lean

tactic: rintro _ ⟨i, j, hi, hj, rfl⟩
state_before: ι : Sort uι
R : Type u_1
M : Type u_2
N : Type u_4
P : Type u_3
inst✝⁶ : CommSemiring R
inst✝⁵ : AddCommMonoid M
inst✝⁴ : AddCommMonoid N
inst✝³ : AddCommMonoid P
inst✝² : Module R M
inst✝¹ : Module R N
inst✝ : Module R P
f : M →ₗ[R] N →ₗ[R] P
p : Submodule R M
q : Submodule R N
⊢ image2 (fun m n => ↑(↑f m) n) ↑p ↑q ⊆ ↑(map₂ f p q)

tactic: exact apply_mem_map₂ _ hi hj
state_before: case intro.intro.intro.intro
ι : Sort uι
R : Type u_1
M : Type u_2
N : Type u_4
P : Type u_3
inst✝⁶ : CommSemiring R
inst✝⁵ : AddCommMonoid M
inst✝⁴ : AddCommMonoid N
inst✝³ : AddCommMonoid P
inst✝² : Module R M
inst✝¹ : Module R N
inst✝ : Module R P
f : M →ₗ[R] N →ₗ[R] P
p : Submodule R M
q : Submodule R N
i : M
j : N
hi : i ∈ ↑p
hj : j ∈ ↑q
⊢ (fun m n => ↑(↑f m) n) i j ∈ ↑(map₂ f p q)
Theorem: Complex.algHom_ext
File: Mathlib/Data/Complex/Module.lean

tactic: ext ⟨x, y⟩
state_before: R : Type ?u.82639
S : Type ?u.82642
A : Type u_1
inst✝¹ : Semiring A
inst✝ : Algebra ℝ A
f g : ℂ →ₐ[ℝ] A
h : ↑f I = ↑g I
⊢ f = g

tactic: simp only [mk_eq_add_mul_I, AlgHom.map_add, AlgHom.map_coe_real_complex, AlgHom.map_mul, h]
state_before: case H.mk
R : Type ?u.82639
S : Type ?u.82642
A : Type u_1
inst✝¹ : Semiring A
inst✝ : Algebra ℝ A
f g : ℂ →ₐ[ℝ] A
h : ↑f I = ↑g I
x y : ℝ
⊢ ↑f { re := x, im := y } = ↑g { re := x, im := y }
Theorem: CircleDeg1Lift.translationNumber_zpow
File: Mathlib/Dynamics/Circle/RotationNumber/TranslationNumber.lean

tactic: simp [translationNumber_pow f n]
state_before: f✝ g : CircleDeg1Lift
f : CircleDeg1Liftˣ
n : ℕ
⊢ τ ↑(f ^ ↑n) = ↑↑n * τ ↑f

tactic: simp
state_before: f✝ g : CircleDeg1Lift
f : CircleDeg1Liftˣ
n : ℕ
⊢ τ ↑(f ^ -[n+1]) = ↑-[n+1] * τ ↑f

tactic: ring
state_before: f✝ g : CircleDeg1Lift
f : CircleDeg1Liftˣ
n : ℕ
⊢ -((↑n + 1) * τ ↑f) = (-1 + -↑n) * τ ↑f
Theorem: Nat.clog_anti_left
File: Mathlib/Data/Nat/Log.lean

tactic: rw [← le_pow_iff_clog_le (lt_of_lt_of_le hc hb)]
state_before: b c n : ℕ
hc : 1 < c
hb : c ≤ b
⊢ clog b n ≤ clog c n

tactic: calc
  n ≤ c ^ clog c n := le_pow_clog hc _
  _ ≤ b ^ clog c n := pow_le_pow_of_le_left hb _
state_before: b c n : ℕ
hc : 1 < c
hb : c ≤ b
⊢ n ≤ b ^ clog c n
Theorem: Real.isTheta_exp_comp_exp_comp
File: Mathlib/Analysis/SpecialFunctions/Exp.lean

tactic: simp only [isBoundedUnder_le_abs, ← isBoundedUnder_le_neg, neg_sub, IsTheta,
  isBigO_exp_comp_exp_comp, Pi.sub_def]
state_before: α : Type u_1
x y z : ℝ
l : Filter α
f g : α → ℝ
⊢ ((fun x => exp (f x)) =Θ[l] fun x => exp (g x)) ↔ IsBoundedUnder (fun x x_1 => x ≤ x_1) l fun x => abs (f x - g x)
Theorem: sup_eq_maxDefault
File: Mathlib/Order/Lattice.lean

tactic: ext (x y)
state_before: α : Type u
β : Type v
inst✝² : SemilatticeSup α
inst✝¹ : DecidableRel fun x x_1 => x ≤ x_1
inst✝ : IsTotal α fun x x_1 => x ≤ x_1
⊢ (fun x x_1 => x ⊔ x_1) = maxDefault

tactic: unfold maxDefault
state_before: case h.h
α : Type u
β : Type v
inst✝² : SemilatticeSup α
inst✝¹ : DecidableRel fun x x_1 => x ≤ x_1
inst✝ : IsTotal α fun x x_1 => x ≤ x_1
x y : α
⊢ x ⊔ y = maxDefault x y

tactic: split_ifs with h'
state_before: case h.h
α : Type u
β : Type v
inst✝² : SemilatticeSup α
inst✝¹ : DecidableRel fun x x_1 => x ≤ x_1
inst✝ : IsTotal α fun x x_1 => x ≤ x_1
x y : α
⊢ x ⊔ y = if x ≤ y then y else x
Theorem: List.take_take
File: Mathlib/Data/List/Basic.lean

tactic: rw [min_zero, take_zero, take_nil]
state_before: ι : Type ?u.159083
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α
n : ℕ
l : List α
⊢ take n (take 0 l) = take (min n 0) l

tactic: rw [zero_min, take_zero, take_zero]
state_before: ι : Type ?u.159083
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α
m : ℕ
l : List α
⊢ take 0 (take m l) = take (min 0 m) l

tactic: simp only [take_nil]
state_before: ι : Type ?u.159083
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α
n m : ℕ
⊢ take (succ n) (take (succ m) []) = take (min (succ n) (succ m)) []

tactic: simp only [take, min_succ_succ, take_take n m l]
state_before: ι : Type ?u.159083
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α
n m : ℕ
a : α
l : List α
⊢ take (succ n) (take (succ m) (a :: l)) = take (min (succ n) (succ m)) (a :: l)
Theorem: CategoryTheory.GlueData.t'_iij
File: Mathlib/CategoryTheory/GlueData.lean

tactic: have eq₁ := D.t_fac i i j
state_before: C : Type u₁
inst✝¹ : Category C
C' : Type u₂
inst✝ : Category C'
D : GlueData C
i j : D.J
⊢ t' D i i j = (pullbackSymmetry (f D i i) (f D i j)).hom

tactic: have eq₂ := (IsIso.eq_comp_inv (D.f i i)).mpr (@pullback.condition _ _ _ _ _ _ (D.f i j) _)
state_before: C : Type u₁
inst✝¹ : Category C
C' : Type u₂
inst✝ : Category C'
D : GlueData C
i j : D.J
eq₁ : t' D i i j ≫ pullback.snd = pullback.fst ≫ t D i i
⊢ t' D i i j = (pullbackSymmetry (f D i i) (f D i j)).hom

tactic: rw [D.t_id, Category.comp_id, eq₂] at eq₁
state_before: C : Type u₁
inst✝¹ : Category C
C' : Type u₂
inst✝ : Category C'
D : GlueData C
i j : D.J
eq₁ : t' D i i j ≫ pullback.snd = pullback.fst ≫ t D i i
eq₂ : pullback.fst = (pullback.snd ≫ f D i j) ≫ inv (f D i i)
⊢ t' D i i j = (pullbackSymmetry (f D i i) (f D i j)).hom

tactic: have eq₃ := (IsIso.eq_comp_inv (D.f i i)).mp eq₁
state_before: C : Type u₁
inst✝¹ : Category C
C' : Type u₂
inst✝ : Category C'
D : GlueData C
i j : D.J
eq₁ : t' D i i j ≫ pullback.snd = (pullback.snd ≫ f D i j) ≫ inv (f D i i)
eq₂ : pullback.fst = (pullback.snd ≫ f D i j) ≫ inv (f D i i)
⊢ t' D i i j = (pullbackSymmetry (f D i i) (f D i j)).hom

tactic: rw [Category.assoc, ← pullback.condition, ← Category.assoc] at eq₃
state_before: C : Type u₁
inst✝¹ : Category C
C' : Type u₂
inst✝ : Category C'
D : GlueData C
i j : D.J
eq₁ : t' D i i j ≫ pullback.snd = (pullback.snd ≫ f D i j) ≫ inv (f D i i)
eq₂ : pullback.fst = (pullback.snd ≫ f D i j) ≫ inv (f D i i)
eq₃ : (t' D i i j ≫ pullback.snd) ≫ f D i i = pullback.snd ≫ f D i j
⊢ t' D i i j = (pullbackSymmetry (f D i i) (f D i j)).hom

tactic: exact
  Mono.right_cancellation _ _
    ((Mono.right_cancellation _ _ eq₃).trans (pullbackSymmetry_hom_comp_fst _ _).symm)
state_before: C : Type u₁
inst✝¹ : Category C
C' : Type u₂
inst✝ : Category C'
D : GlueData C
i j : D.J
eq₁ : t' D i i j ≫ pullback.snd = (pullback.snd ≫ f D i j) ≫ inv (f D i i)
eq₂ : pullback.fst = (pullback.snd ≫ f D i j) ≫ inv (f D i i)
eq₃ : (t' D i i j ≫ pullback.fst) ≫ f D i j = pullback.snd ≫ f D i j
⊢ t' D i i j = (pullbackSymmetry (f D i i) (f D i j)).hom
Theorem: List.Sublist.diff_right
File: Std/Data/List/Lemmas.lean

tactic: simp only [diff_cons, (h.erase _).diff_right]
state_before: α : Type u_1
inst✝ : DecidableEq α
l₁ l₂ : List α
a : α
l₃ : List α
h : l₁ <+ l₂
⊢ List.diff l₁ (a :: l₃) <+ List.diff l₂ (a :: l₃)
Theorem: Matrix.toLinAlgEquiv_mul
File: Mathlib/LinearAlgebra/Matrix/ToLin.lean

tactic: convert Matrix.toLin_mul v₁ v₁ v₁ A B
state_before: R : Type u_2
inst✝⁹ : CommSemiring R
l : Type ?u.2717466
m : Type ?u.2717469
n : Type u_1
inst✝⁸ : Fintype n
inst✝⁷ : Fintype m
inst✝⁶ : DecidableEq n
M₁ : Type u_3
M₂ : Type ?u.2717493
inst✝⁵ : AddCommMonoid M₁
inst✝⁴ : AddCommMonoid M₂
inst✝³ : Module R M₁
inst✝² : Module R M₂
v₁ : Basis n R M₁
v₂ : Basis m R M₂
M₃ : Type ?u.2717995
inst✝¹ : AddCommMonoid M₃
inst✝ : Module R M₃
v₃ : Basis l R M₃
A B : Matrix n n R
⊢ ↑(toLinAlgEquiv v₁) (A ⬝ B) = comp (↑(toLinAlgEquiv v₁) A) (↑(toLinAlgEquiv v₁) B)
Theorem: BumpCovering.continuous_toPouFun
File: Mathlib/Topology/PartitionOfUnity.lean

tactic: refine' (f i).continuous.mul <|
  continuous_finprod_cond (fun j _ => continuous_const.sub (f j).continuous) _
state_before: ι : Type u
X : Type v
inst✝ : TopologicalSpace X
s : Set X
f : BumpCovering ι X s
i : ι
⊢ Continuous (toPouFun f i)

tactic: simp only [mulSupport_one_sub]
state_before: ι : Type u
X : Type v
inst✝ : TopologicalSpace X
s : Set X
f : BumpCovering ι X s
i : ι
⊢ LocallyFinite fun i => mulSupport fun x => 1 - ↑(toFun s f i) x

tactic: exact f.locallyFinite
state_before: ι : Type u
X : Type v
inst✝ : TopologicalSpace X
s : Set X
f : BumpCovering ι X s
i : ι
⊢ LocallyFinite fun i => support fun x => ↑(toFun s f i) x
Theorem: Int.mem_toNat'
File: Std/Data/Int/Lemmas.lean

tactic: constructor <;> intro.
state_before: m n : Nat
⊢ toNat' -[m+1] = some n ↔ -[m+1] = ↑n
Theorem: Cubic.mem_roots_iff
File: Mathlib/Algebra/CubicDiscriminant.lean

tactic: rw [roots, mem_roots h0, IsRoot, toPoly]
state_before: R : Type u_1
S : Type ?u.683267
F : Type ?u.683270
K : Type ?u.683273
P : Cubic R
inst✝² : CommRing R
inst✝¹ : CommRing S
φ : R →+* S
inst✝ : IsDomain R
h0 : toPoly P ≠ 0
x : R
⊢ x ∈ roots P ↔ P.a * x ^ 3 + P.b * x ^ 2 + P.c * x + P.d = 0

tactic: simp only [eval_C, eval_X, eval_add, eval_mul, eval_pow]
state_before: R : Type u_1
S : Type ?u.683267
F : Type ?u.683270
K : Type ?u.683273
P : Cubic R
inst✝² : CommRing R
inst✝¹ : CommRing S
φ : R →+* S
inst✝ : IsDomain R
h0 : toPoly P ≠ 0
x : R
⊢ eval x (↑C P.a * X ^ 3 + ↑C P.b * X ^ 2 + ↑C P.c * X + ↑C P.d) = 0 ↔ P.a * x ^ 3 + P.b * x ^ 2 + P.c * x + P.d = 0
Theorem: Submodule.eq_top_of_disjoint
File: Mathlib/LinearAlgebra/FiniteDimensional.lean

tactic: have h_finrank_inf : finrank K ↑(s ⊓ t) = 0 := by
  rw [disjoint_iff_inf_le, le_bot_iff] at hdisjoint
  rw [hdisjoint, finrank_bot]
state_before: K : Type u
V : Type v
inst✝³ : DivisionRing K
inst✝² : AddCommGroup V
inst✝¹ : Module K V
inst✝ : FiniteDimensional K V
s t : Submodule K V
hdim : finrank K { x // x ∈ s } + finrank K { x // x ∈ t } = finrank K V
hdisjoint : Disjoint s t
⊢ s ⊔ t = ⊤

tactic: apply eq_top_of_finrank_eq
state_before: K : Type u
V : Type v
inst✝³ : DivisionRing K
inst✝² : AddCommGroup V
inst✝¹ : Module K V
inst✝ : FiniteDimensional K V
s t : Submodule K V
hdim : finrank K { x // x ∈ s } + finrank K { x // x ∈ t } = finrank K V
hdisjoint : Disjoint s t
h_finrank_inf : finrank K { x // x ∈ s ⊓ t } = 0
⊢ s ⊔ t = ⊤

tactic: rw [← hdim]
state_before: case h
K : Type u
V : Type v
inst✝³ : DivisionRing K
inst✝² : AddCommGroup V
inst✝¹ : Module K V
inst✝ : FiniteDimensional K V
s t : Submodule K V
hdim : finrank K { x // x ∈ s } + finrank K { x // x ∈ t } = finrank K V
hdisjoint : Disjoint s t
h_finrank_inf : finrank K { x // x ∈ s ⊓ t } = 0
⊢ finrank K { x // x ∈ s ⊔ t } = finrank K V

tactic: convert s.finrank_sup_add_finrank_inf_eq t
state_before: case h
K : Type u
V : Type v
inst✝³ : DivisionRing K
inst✝² : AddCommGroup V
inst✝¹ : Module K V
inst✝ : FiniteDimensional K V
s t : Submodule K V
hdim : finrank K { x // x ∈ s } + finrank K { x // x ∈ t } = finrank K V
hdisjoint : Disjoint s t
h_finrank_inf : finrank K { x // x ∈ s ⊓ t } = 0
⊢ finrank K { x // x ∈ s ⊔ t } = finrank K { x // x ∈ s } + finrank K { x // x ∈ t }

tactic: rw [h_finrank_inf]
state_before: case h.e'_2
K : Type u
V : Type v
inst✝³ : DivisionRing K
inst✝² : AddCommGroup V
inst✝¹ : Module K V
inst✝ : FiniteDimensional K V
s t : Submodule K V
hdim : finrank K { x // x ∈ s } + finrank K { x // x ∈ t } = finrank K V
hdisjoint : Disjoint s t
h_finrank_inf : finrank K { x // x ∈ s ⊓ t } = 0
⊢ finrank K { x // x ∈ s ⊔ t } = finrank K { x // x ∈ s ⊔ t } + finrank K { x // x ∈ s ⊓ t }

tactic: rfl
state_before: case h.e'_2
K : Type u
V : Type v
inst✝³ : DivisionRing K
inst✝² : AddCommGroup V
inst✝¹ : Module K V
inst✝ : FiniteDimensional K V
s t : Submodule K V
hdim : finrank K { x // x ∈ s } + finrank K { x // x ∈ t } = finrank K V
hdisjoint : Disjoint s t
h_finrank_inf : finrank K { x // x ∈ s ⊓ t } = 0
⊢ finrank K { x // x ∈ s ⊔ t } = finrank K { x // x ∈ s ⊔ t } + 0

tactic: rw [disjoint_iff_inf_le, le_bot_iff] at hdisjoint
state_before: K : Type u
V : Type v
inst✝³ : DivisionRing K
inst✝² : AddCommGroup V
inst✝¹ : Module K V
inst✝ : FiniteDimensional K V
s t : Submodule K V
hdim : finrank K { x // x ∈ s } + finrank K { x // x ∈ t } = finrank K V
hdisjoint : Disjoint s t
⊢ finrank K { x // x ∈ s ⊓ t } = 0

tactic: rw [hdisjoint, finrank_bot]
state_before: K : Type u
V : Type v
inst✝³ : DivisionRing K
inst✝² : AddCommGroup V
inst✝¹ : Module K V
inst✝ : FiniteDimensional K V
s t : Submodule K V
hdim : finrank K { x // x ∈ s } + finrank K { x // x ∈ t } = finrank K V
hdisjoint : s ⊓ t = ⊥
⊢ finrank K { x // x ∈ s ⊓ t } = 0
Theorem: Fintype.card_option
File: Mathlib/Data/Fintype/Option.lean

tactic: simp
state_before: α✝ : Type ?u.2694
β : Type ?u.2697
γ : Type ?u.2700
α : Type u_1
inst✝ : Fintype α
⊢ ¬none ∈ map Embedding.some univ
Theorem: Real.range_cos_infinite
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Basic.lean

tactic: rw [Real.range_cos]
state_before: ⊢ Set.Infinite (range cos)

tactic: exact Icc_infinite (by norm_num)
state_before: ⊢ Set.Infinite (Icc (-1) 1)

tactic: norm_num
state_before: ⊢ -1 < 1
Theorem: subalgebra_top_finrank_eq_submodule_top_finrank
File: Mathlib/LinearAlgebra/Finrank.lean

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

tactic: rfl
state_before: K : Type u
V : Type v
F : Type u_1
E : Type u_2
inst✝² : CommRing F
inst✝¹ : Ring E
inst✝ : Algebra F E
⊢ finrank F { x // x ∈ ⊤ } = finrank F { x // x ∈ ↑Subalgebra.toSubmodule ⊤ }
Theorem: CategoryTheory.Abelian.coimageImageComparison_eq_coimageImageComparison'
File: Mathlib/CategoryTheory/Abelian/Images.lean

tactic: apply coequalizer.hom_ext
state_before: C : Type u
inst✝³ : Category C
inst✝² : HasZeroMorphisms C
inst✝¹ : HasKernels C
inst✝ : HasCokernels C
P Q : C
f : P ⟶ Q
⊢ coimageImageComparison f = coimageImageComparison' f

tactic: apply equalizer.hom_ext
state_before: case h
C : Type u
inst✝³ : Category C
inst✝² : HasZeroMorphisms C
inst✝¹ : HasKernels C
inst✝ : HasCokernels C
P Q : C
f : P ⟶ Q
⊢ coequalizer.π (kernel.ι f) 0 ≫ coimageImageComparison f = coequalizer.π (kernel.ι f) 0 ≫ coimageImageComparison' f

tactic: simp [coimageImageComparison, coimageImageComparison']
state_before: case h.h
C : Type u
inst✝³ : Category C
inst✝² : HasZeroMorphisms C
inst✝¹ : HasKernels C
inst✝ : HasCokernels C
P Q : C
f : P ⟶ Q
⊢ (coequalizer.π (kernel.ι f) 0 ≫ coimageImageComparison f) ≫ equalizer.ι (cokernel.π f) 0 =
    (coequalizer.π (kernel.ι f) 0 ≫ coimageImageComparison' f) ≫ equalizer.ι (cokernel.π f) 0
Theorem: geom_gold_isSol_fibRec
File: Mathlib/Data/Real/GoldenRatio.lean

tactic: rw [fibRec.geom_sol_iff_root_charPoly, fibRec_charPoly_eq]
state_before: α : Type ?u.57955
inst✝ : CommSemiring α
⊢ LinearRecurrence.IsSolution fibRec fun x => φ ^ x

tactic: simp [sub_eq_zero, - div_pow]
state_before: α : Type ?u.57955
inst✝ : CommSemiring α
⊢ IsRoot (X ^ 2 - (X + 1)) φ
Theorem: isSquare_inv
File: Mathlib/Algebra/Parity.lean

tactic: refine' ⟨fun h => _, fun h => _⟩
state_before: F : Type ?u.32005
α : Type u_1
β : Type ?u.32011
R : Type ?u.32014
inst✝ : DivisionMonoid α
a : α
⊢ IsSquare a⁻¹ ↔ IsSquare a

tactic: rw [← isSquare_op_iff, ← inv_inv a]
state_before: case refine'_1
F : Type ?u.32005
α : Type u_1
β : Type ?u.32011
R : Type ?u.32014
inst✝ : DivisionMonoid α
a : α
h : IsSquare a⁻¹
⊢ IsSquare a

tactic: exact h.map (MulEquiv.inv' α)
state_before: case refine'_1
F : Type ?u.32005
α : Type u_1
β : Type ?u.32011
R : Type ?u.32014
inst✝ : DivisionMonoid α
a : α
h : IsSquare a⁻¹
⊢ IsSquare (op a⁻¹⁻¹)

tactic: exact ((isSquare_op_iff a).mpr h).map (MulEquiv.inv' α).symm
state_before: case refine'_2
F : Type ?u.32005
α : Type u_1
β : Type ?u.32011
R : Type ?u.32014
inst✝ : DivisionMonoid α
a : α
h : IsSquare a
⊢ IsSquare a⁻¹
Theorem: Ideal.eq_bot_or_top
File: Mathlib/RingTheory/Ideal/Basic.lean

tactic: rw [or_iff_not_imp_right]
state_before: α : Type u
β : Type v
K : Type u
inst✝ : DivisionSemiring K
I : Ideal K
⊢ I = ⊥ ∨ I = ⊤

tactic: change _ ≠ _ → _
state_before: α : Type u
β : Type v
K : Type u
inst✝ : DivisionSemiring K
I : Ideal K
⊢ ¬I = ⊤ → I = ⊥

tactic: rw [Ideal.ne_top_iff_one]
state_before: α : Type u
β : Type v
K : Type u
inst✝ : DivisionSemiring K
I : Ideal K
⊢ I ≠ ⊤ → I = ⊥

tactic: intro h1
state_before: α : Type u
β : Type v
K : Type u
inst✝ : DivisionSemiring K
I : Ideal K
⊢ ¬1 ∈ I → I = ⊥

tactic: rw [eq_bot_iff]
state_before: α : Type u
β : Type v
K : Type u
inst✝ : DivisionSemiring K
I : Ideal K
h1 : ¬1 ∈ I
⊢ I = ⊥

tactic: intro r hr
state_before: α : Type u
β : Type v
K : Type u
inst✝ : DivisionSemiring K
I : Ideal K
h1 : ¬1 ∈ I
⊢ I ≤ ⊥

tactic: by_cases H : r = 0
state_before: α : Type u
β : Type v
K : Type u
inst✝ : DivisionSemiring K
I : Ideal K
h1 : ¬1 ∈ I
r : K
hr : r ∈ I
⊢ r ∈ ⊥

tactic: simpa [H, h1] using I.mul_mem_left r⁻¹ hr
state_before: case neg
α : Type u
β : Type v
K : Type u
inst✝ : DivisionSemiring K
I : Ideal K
h1 : ¬1 ∈ I
r : K
hr : r ∈ I
H : ¬r = 0
⊢ r ∈ ⊥

tactic: simpa
state_before: case pos
α : Type u
β : Type v
K : Type u
inst✝ : DivisionSemiring K
I : Ideal K
h1 : ¬1 ∈ I
r : K
hr : r ∈ I
H : r = 0
⊢ r ∈ ⊥
Theorem: MeasureTheory.Integrable.norm_toL1_eq_lintegral_norm
File: Mathlib/MeasureTheory/Function/L1Space.lean

tactic: rw [norm_toL1, lintegral_norm_eq_lintegral_edist]
state_before: α : Type u_2
β : Type u_1
γ : Type ?u.1321854
δ : Type ?u.1321857
m : MeasurableSpace α
μ ν : Measure α
inst✝² : MeasurableSpace δ
inst✝¹ : NormedAddCommGroup β
inst✝ : NormedAddCommGroup γ
f : α → β
hf : Integrable f
⊢ ‖toL1 f hf‖ = ENNReal.toReal (∫⁻ (a : α), ENNReal.ofReal ‖f a‖ ∂μ)
Theorem: MeasureTheory.set_lintegral_map
File: Mathlib/MeasureTheory/Integral/Lebesgue.lean

tactic: rw [restrict_map hg hs, lintegral_map hf hg]
state_before: α : Type u_2
β : Type u_1
γ : Type ?u.1258568
δ : Type ?u.1258571
m : MeasurableSpace α
μ ν : Measure α
inst✝ : MeasurableSpace β
f : β → ℝ≥0∞
g : α → β
s : Set β
hs : MeasurableSet s
hf : Measurable f
hg : Measurable g
⊢ (∫⁻ (y : β) in s, f y ∂Measure.map g μ) = ∫⁻ (x : α) in g ⁻¹' s, f (g x) ∂μ
Theorem: exists_mem_ne_zero_of_rank_pos
File: Mathlib/LinearAlgebra/Dimension.lean

tactic: rw [eq, rank_bot] at h
state_before: K : Type u
V V₁ V₂ V₃ : Type v
V' V'₁ : Type v'
V'' : Type v''
ι : Type w
ι' : Type w'
η : Type u₁'
φ : η → Type ?u.123250
R : Type u
inst✝⁷ : Ring R
M : Type v
inst✝⁶ : AddCommGroup M
inst✝⁵ : Module R M
M' : Type v'
inst✝⁴ : AddCommGroup M'
inst✝³ : Module R M'
M₁ : Type v
inst✝² : AddCommGroup M₁
inst✝¹ : Module R M₁
inst✝ : Nontrivial R
s : Submodule R M
h : 0 < Module.rank R { x // x ∈ s }
eq : s = ⊥
⊢ False

tactic: exact lt_irrefl _ h
state_before: K : Type u
V V₁ V₂ V₃ : Type v
V' V'₁ : Type v'
V'' : Type v''
ι : Type w
ι' : Type w'
η : Type u₁'
φ : η → Type ?u.123250
R : Type u
inst✝⁷ : Ring R
M : Type v
inst✝⁶ : AddCommGroup M
inst✝⁵ : Module R M
M' : Type v'
inst✝⁴ : AddCommGroup M'
inst✝³ : Module R M'
M₁ : Type v
inst✝² : AddCommGroup M₁
inst✝¹ : Module R M₁
inst✝ : Nontrivial R
s : Submodule R M
h : 0 < 0
eq : s = ⊥
⊢ False
Theorem: Prod.mk_covby_mk_iff_left
File: Mathlib/Order/Cover.lean

tactic: simp_rw [covby_iff_wcovby_and_lt, mk_wcovby_mk_iff_left, mk_lt_mk_iff_left]
state_before: α : Type u_2
β : Type u_1
inst✝¹ : PartialOrder α
inst✝ : PartialOrder β
a a₁ a₂ : α
b b₁ b₂ : β
x y : α × β
⊢ (a₁, b) ⋖ (a₂, b) ↔ a₁ ⋖ a₂
Theorem: Set.iUnion_iUnion_eq'
File: Mathlib/Data/Set/Lattice.lean

tactic: simpa using biUnion_range
state_before: α : Type u_2
β : Type u_1
γ : Type ?u.203664
ι : Sort u_3
ι' : Sort ?u.203670
ι₂ : Sort ?u.203673
κ : ι → Sort ?u.203678
κ₁ : ι → Sort ?u.203683
κ₂ : ι → Sort ?u.203688
κ' : ι' → Sort ?u.203693
f : ι → α
g : α → Set β
⊢ (⋃ (x : α) (y : ι) (_ : f y = x), g x) = ⋃ (y : ι), g (f y)
Theorem: Cycle.Chain.imp
File: Mathlib/Data/List/Cycle.lean

tactic: induction s using Cycle.induction_on
state_before: α : Type u_1
r : α → α → Prop
s : Cycle α
r₁ r₂ : α → α → Prop
H : ∀ (a b : α), r₁ a b → r₂ a b
p : Chain r₁ s
⊢ Chain r₂ s

tactic: triv
state_before: case H0
α : Type u_1
r : α → α → Prop
s : Cycle α
r₁ r₂ : α → α → Prop
H : ∀ (a b : α), r₁ a b → r₂ a b
p : Chain r₁ Cycle.nil
⊢ Chain r₂ Cycle.nil

tactic: rw [chain_coe_cons] at p⊢
state_before: case HI
α : Type u_1
r : α → α → Prop
s : Cycle α
r₁ r₂ : α → α → Prop
H : ∀ (a b : α), r₁ a b → r₂ a b
a✝¹ : α
l✝ : List α
a✝ : Chain r₁ ↑l✝ → Chain r₂ ↑l✝
p : Chain r₁ ↑(a✝¹ :: l✝)
⊢ Chain r₂ ↑(a✝¹ :: l✝)

tactic: exact p.imp H
state_before: case HI
α : Type u_1
r : α → α → Prop
s : Cycle α
r₁ r₂ : α → α → Prop
H : ∀ (a b : α), r₁ a b → r₂ a b
a✝¹ : α
l✝ : List α
a✝ : Chain r₁ ↑l✝ → Chain r₂ ↑l✝
p : List.Chain r₁ a✝¹ (l✝ ++ [a✝¹])
⊢ List.Chain r₂ a✝¹ (l✝ ++ [a✝¹])
Theorem: normalizedFactorsEquivOfQuotEquiv_multiplicity_eq_multiplicity
File: Mathlib/RingTheory/DedekindDomain/Ideal.lean

tactic: rw [normalizedFactorsEquivOfQuotEquiv, Equiv.coe_fn_mk, Subtype.coe_mk]
state_before: R : Type u_1
A : Type u_2
K : Type ?u.1163688
inst✝¹³ : CommRing R
inst✝¹² : CommRing A
inst✝¹¹ : Field K
inst✝¹⁰ : IsDomain A
inst✝⁹ : IsDedekindDomain A
I : Ideal R
J : Ideal A
B : Type ?u.1164225
inst✝⁸ : CommRing B
inst✝⁷ : IsDomain B
inst✝⁶ : IsDedekindDomain B
L✝ : Ideal B
inst✝⁵ : IsDomain R
inst✝⁴ : IsDedekindDomain R
f : R ⧸ I ≃+* A ⧸ J
inst✝³ : DecidableEq (Ideal R)
inst✝² : DecidableEq (Ideal A)
inst✝¹ : DecidableRel fun x x_1 => x ∣ x_1
inst✝ : DecidableRel fun x x_1 => x ∣ x_1
hI : I ≠ ⊥
hJ : J ≠ ⊥
L : Ideal R
hL : L ∈ normalizedFactors I
⊢ multiplicity (↑(↑(normalizedFactorsEquivOfQuotEquiv f hI hJ) { val := L, property := hL })) J = multiplicity L I

tactic: refine multiplicity_factor_dvd_iso_eq_multiplicity_of_mem_normalizedFactors hI hJ hL
  (d := (idealFactorsEquivOfQuotEquiv f).toEquiv) ?_
state_before: R : Type u_1
A : Type u_2
K : Type ?u.1163688
inst✝¹³ : CommRing R
inst✝¹² : CommRing A
inst✝¹¹ : Field K
inst✝¹⁰ : IsDomain A
inst✝⁹ : IsDedekindDomain A
I : Ideal R
J : Ideal A
B : Type ?u.1164225
inst✝⁸ : CommRing B
inst✝⁷ : IsDomain B
inst✝⁶ : IsDedekindDomain B
L✝ : Ideal B
inst✝⁵ : IsDomain R
inst✝⁴ : IsDedekindDomain R
f : R ⧸ I ≃+* A ⧸ J
inst✝³ : DecidableEq (Ideal R)
inst✝² : DecidableEq (Ideal A)
inst✝¹ : DecidableRel fun x x_1 => x ∣ x_1
inst✝ : DecidableRel fun x x_1 => x ∣ x_1
hI : I ≠ ⊥
hJ : J ≠ ⊥
L : Ideal R
hL : L ∈ normalizedFactors I
⊢ multiplicity
      (↑(↑(idealFactorsEquivOfQuotEquiv f)
          { val := ↑{ val := L, property := hL }, property := (_ : ↑{ val := L, property := hL } ∣ I) }))
      J =
    multiplicity L I

tactic: exact fun ⟨l, hl⟩ ⟨l', hl'⟩ => idealFactorsEquivOfQuotEquiv_is_dvd_iso f hl hl'
state_before: R : Type u_1
A : Type u_2
K : Type ?u.1163688
inst✝¹³ : CommRing R
inst✝¹² : CommRing A
inst✝¹¹ : Field K
inst✝¹⁰ : IsDomain A
inst✝⁹ : IsDedekindDomain A
I : Ideal R
J : Ideal A
B : Type ?u.1164225
inst✝⁸ : CommRing B
inst✝⁷ : IsDomain B
inst✝⁶ : IsDedekindDomain B
L✝ : Ideal B
inst✝⁵ : IsDomain R
inst✝⁴ : IsDedekindDomain R
f : R ⧸ I ≃+* A ⧸ J
inst✝³ : DecidableEq (Ideal R)
inst✝² : DecidableEq (Ideal A)
inst✝¹ : DecidableRel fun x x_1 => x ∣ x_1
inst✝ : DecidableRel fun x x_1 => x ∣ x_1
hI : I ≠ ⊥
hJ : J ≠ ⊥
L : Ideal R
hL : L ∈ normalizedFactors I
⊢ ∀ (l l' : { l // l ∣ I }),
    ↑(↑(idealFactorsEquivOfQuotEquiv f).toEquiv l) ∣ ↑(↑(idealFactorsEquivOfQuotEquiv f).toEquiv l') ↔ ↑l ∣ ↑l'
Theorem: Finset.prod_attach_univ
File: Mathlib/Data/Fintype/BigOperators.lean

tactic: simp
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.14166
inst✝¹ : Fintype α
inst✝ : CommMonoid β
f : { a // a ∈ univ } → β
x : { x // x ∈ univ }
⊢ f x =
    f
      { val := ↑(Equiv.subtypeUnivEquiv (_ : ∀ (x : α), x ∈ univ)) x,
        property := (_ : ↑(Equiv.subtypeUnivEquiv (_ : ∀ (x : α), x ∈ univ)) x ∈ univ) }
Theorem: isOpen_iff_ball_subset
File: Mathlib/Topology/UniformSpace/Basic.lean

tactic: simp_rw [isOpen_iff_mem_nhds, nhds_eq_comap_uniformity]
state_before: α : Type ua
β : Type ub
γ : Type uc
δ : Type ud
ι : Sort ?u.58600
inst✝ : UniformSpace α
s : Set α
⊢ IsOpen s ↔ ∀ (x : α), x ∈ s → ∃ V, V ∈ 𝓤 α ∧ ball x V ⊆ s

tactic: rfl
state_before: α : Type ua
β : Type ub
γ : Type uc
δ : Type ud
ι : Sort ?u.58600
inst✝ : UniformSpace α
s : Set α
⊢ (∀ (a : α), a ∈ s → s ∈ comap (Prod.mk a) (𝓤 α)) ↔ ∀ (x : α), x ∈ s → ∃ V, V ∈ 𝓤 α ∧ ball x V ⊆ s
Theorem: isSMulRegular_of_group
File: Mathlib/Algebra/Regular/SMul.lean

tactic: intro x y h
state_before: R : Type u_2
S : Type ?u.31171
M : Type ?u.31174
a b : R
s : S
G : Type u_1
inst✝¹ : Group G
inst✝ : MulAction G R
g : G
⊢ IsSMulRegular R g