tasksource/leandojo huggingface dataset:
Theorem: List.append_cons
File: src/lean/Init/Data/List/Basic.lean

tactic: induction as with
| nil => simp
| cons a as ih => simp [ih]
state_before: α : Type u
β : Type v
γ : Type w
as : List α
b : α
bs : List α
⊢ as ++ b :: bs = as ++ b :: nil ++ bs

tactic: simp
state_before: case nil
α : Type u
β : Type v
γ : Type w
b : α
bs : List α
⊢ nil ++ b :: bs = nil ++ b :: nil ++ bs

tactic: simp [ih]
state_before: case cons
α : Type u
β : Type v
γ : Type w
b : α
bs : List α
a : α
as : List α
ih : as ++ b :: bs = as ++ b :: nil ++ bs
⊢ a :: as ++ b :: bs = a :: as ++ b :: nil ++ bs
Theorem: Asymptotics.bound_of_isBigO_nat_atTop
File: Mathlib/Analysis/Asymptotics/Asymptotics.lean

tactic: rwa [Nat.cofinite_eq_atTop]
state_before: α : Type ?u.686737
β : Type ?u.686740
E : Type u_1
F : Type ?u.686746
G : Type ?u.686749
E' : Type ?u.686752
F' : Type ?u.686755
G' : Type ?u.686758
E'' : Type u_2
F'' : Type ?u.686764
G'' : Type ?u.686767
R : Type ?u.686770
R' : Type ?u.686773
𝕜 : Type ?u.686776
𝕜' : Type ?u.686779
inst✝¹² : Norm E
inst✝¹¹ : Norm F
inst✝¹⁰ : Norm G
inst✝⁹ : SeminormedAddCommGroup E'
inst✝⁸ : SeminormedAddCommGroup F'
inst✝⁷ : SeminormedAddCommGroup G'
inst✝⁶ : NormedAddCommGroup E''
inst✝⁵ : NormedAddCommGroup F''
inst✝⁴ : NormedAddCommGroup G''
inst✝³ : SeminormedRing R
inst✝² : SeminormedRing R'
inst✝¹ : NormedField 𝕜
inst✝ : NormedField 𝕜'
c c' c₁ c₂ : ℝ
f✝ : α → E
g : α → F
k : α → G
f' : α → E'
g' : α → F'
k' : α → G'
f'' : α → E''
g''✝ : α → F''
k'' : α → G''
l l' : Filter α
f : ℕ → E
g'' : ℕ → E''
h : f =O[atTop] g''
⊢ (fun x => f x) =O[cofinite] fun x => g'' x
Theorem: uniformCauchySeqOn_iff_uniformCauchySeqOnFilter
File: Mathlib/Topology/UniformSpace/UniformConvergence.lean

tactic: simp only [UniformCauchySeqOn, UniformCauchySeqOnFilter]
state_before: α : Type u
β : Type v
γ : Type w
ι : Type x
inst✝ : UniformSpace β
F : ι → α → β
f : α → β
s s' : Set α
x : α
p : Filter ι
p' : Filter α
g : ι → α
⊢ UniformCauchySeqOn F p s ↔ UniformCauchySeqOnFilter F p (𝓟 s)

tactic: refine' forall₂_congr fun u hu => _
state_before: α : Type u
β : Type v
γ : Type w
ι : Type x
inst✝ : UniformSpace β
F : ι → α → β
f : α → β
s s' : Set α
x : α
p : Filter ι
p' : Filter α
g : ι → α
⊢ (∀ (u : Set (β × β)), u ∈ 𝓤 β → ∀ᶠ (m : ι × ι) in p ×ˢ p, ∀ (x : α), x ∈ s → (F m.fst x, F m.snd x) ∈ u) ↔
    ∀ (u : Set (β × β)), u ∈ 𝓤 β → ∀ᶠ (m : (ι × ι) × α) in (p ×ˢ p) ×ˢ 𝓟 s, (F m.fst.fst m.snd, F m.fst.snd m.snd) ∈ u

tactic: rw [eventually_prod_principal_iff]
state_before: α : Type u
β : Type v
γ : Type w
ι : Type x
inst✝ : UniformSpace β
F : ι → α → β
f : α → β
s s' : Set α
x : α
p : Filter ι
p' : Filter α
g : ι → α
u : Set (β × β)
hu : u ∈ 𝓤 β
⊢ (∀ᶠ (m : ι × ι) in p ×ˢ p, ∀ (x : α), x ∈ s → (F m.fst x, F m.snd x) ∈ u) ↔
    ∀ᶠ (m : (ι × ι) × α) in (p ×ˢ p) ×ˢ 𝓟 s, (F m.fst.fst m.snd, F m.fst.snd m.snd) ∈ u
Theorem: Nat.Linear.ExprCnstr.denote_toPoly
File: src/lean/Init/Data/Nat/Linear.lean

tactic: cases c
state_before: ctx : Context
c : ExprCnstr
⊢ PolyCnstr.denote ctx (toPoly c) = denote ctx c

tactic: rename_i eq lhs rhs
state_before: case mk
ctx : Context
eq✝ : Bool
lhs✝ rhs✝ : Expr
⊢ PolyCnstr.denote ctx (toPoly { eq := eq✝, lhs := lhs✝, rhs := rhs✝ }) =
    denote ctx { eq := eq✝, lhs := lhs✝, rhs := rhs✝ }

tactic: simp [ExprCnstr.denote, PolyCnstr.denote, ExprCnstr.toPoly]
state_before: case mk
ctx : Context
eq : Bool
lhs rhs : Expr
⊢ PolyCnstr.denote ctx (toPoly { eq := eq, lhs := lhs, rhs := rhs }) = denote ctx { eq := eq, lhs := lhs, rhs := rhs }

tactic: by_cases h : eq = true <;> simp [h]
state_before: case mk
ctx : Context
eq : Bool
lhs rhs : Expr
⊢ (bif eq then Poly.denote_eq ctx (Expr.toPoly lhs, Expr.toPoly rhs)
    else Poly.denote_le ctx (Expr.toPoly lhs, Expr.toPoly rhs)) =
    bif eq then Expr.denote ctx lhs = Expr.denote ctx rhs else Expr.denote ctx lhs ≤ Expr.denote ctx rhs

tactic: simp [Poly.denote_eq, Expr.toPoly]
state_before: case mk.inl
ctx : Context
eq : Bool
lhs rhs : Expr
h : eq = true
⊢ Poly.denote_eq ctx (Expr.toPoly lhs, Expr.toPoly rhs) = (Expr.denote ctx lhs = Expr.denote ctx rhs)

tactic: simp [Poly.denote_le, Expr.toPoly]
state_before: case mk.inr
ctx : Context
eq : Bool
lhs rhs : Expr
h : ¬eq = true
⊢ Poly.denote_le ctx (Expr.toPoly lhs, Expr.toPoly rhs) = (Expr.denote ctx lhs ≤ Expr.denote ctx rhs)
Theorem: LowerSet.compl_sSup
File: Mathlib/Order/UpperLower/Basic.lean

tactic: simp only [coe_compl, coe_sSup, compl_iUnion₂, UpperSet.coe_iSup₂]
state_before: α : Type u_1
β : Type ?u.87716
γ : Type ?u.87719
ι : Sort ?u.87722
κ : ι → Sort ?u.87727
inst✝ : LE α
s t : LowerSet α
a : α
S : Set (LowerSet α)
⊢ ↑(compl (sSup S)) = ↑(⨆ (s : LowerSet α) (_ : s ∈ S), compl s)
Theorem: Caratheodory.minCardFinsetOfMemConvexHull_nonempty
File: Mathlib/Analysis/Convex/Caratheodory.lean

tactic: rw [← Finset.coe_nonempty, ← @convexHull_nonempty_iff 𝕜]
state_before: 𝕜 : Type u_1
E : Type u
inst✝² : LinearOrderedField 𝕜
inst✝¹ : AddCommGroup E
inst✝ : Module 𝕜 E
s : Set E
x : E
hx : x ∈ ↑(convexHull 𝕜).toOrderHom s
⊢ Finset.Nonempty (minCardFinsetOfMemConvexHull hx)

tactic: exact ⟨x, mem_minCardFinsetOfMemConvexHull hx⟩
state_before: 𝕜 : Type u_1
E : Type u
inst✝² : LinearOrderedField 𝕜
inst✝¹ : AddCommGroup E
inst✝ : Module 𝕜 E
s : Set E
x : E
hx : x ∈ ↑(convexHull 𝕜).toOrderHom s
⊢ Set.Nonempty (↑(convexHull 𝕜).toOrderHom ↑(minCardFinsetOfMemConvexHull hx))
Theorem: Classical.em
File: src/lean/Init/Classical.lean

tactic: simp [hvf, hut, true_ne_false]
state_before: p : Prop
U : Prop → Prop := fun x => x = True ∨ p
V : Prop → Prop := fun x => x = False ∨ p
exU : ∃ x, U x
exV : ∃ x, V x
u : Prop := choose exU
v : Prop := choose exV
u_def : U u
v_def : V v
hut : u = True
hvf : v = False
⊢ u ≠ v

tactic: rw [hpred]
state_before: p : Prop
U : Prop → Prop := fun x => x = True ∨ p
V : Prop → Prop := fun x => x = False ∨ p
exU : ∃ x, U x
exV : ∃ x, V x
u : Prop := choose exU
v : Prop := choose exV
u_def : U u
v_def : V v
not_uv_or_p : u ≠ v ∨ p
hp : p
hpred : U = V
⊢ ∀ (exU : ∃ x, U x) (exV : ∃ x, V x), choose exU = choose exV

tactic: intros
state_before: p : Prop
U : Prop → Prop := fun x => x = True ∨ p
V : Prop → Prop := fun x => x = False ∨ p
exU : ∃ x, U x
exV : ∃ x, V x
u : Prop := choose exU
v : Prop := choose exV
u_def : U u
v_def : V v
not_uv_or_p : u ≠ v ∨ p
hp : p
hpred : U = V
⊢ ∀ (exU exV : ∃ x, V x), choose exU = choose exV

tactic: rfl
state_before: p : Prop
U : Prop → Prop := fun x => x = True ∨ p
V : Prop → Prop := fun x => x = False ∨ p
exU : ∃ x, U x
exV : ∃ x, V x
u : Prop := choose exU
v : Prop := choose exV
u_def : U u
v_def : V v
not_uv_or_p : u ≠ v ∨ p
hp : p
hpred : U = V
exU✝ exV✝ : ∃ x, V x
⊢ choose exU✝ = choose exV✝
Theorem: WithTop.coe_sSup
File: Mathlib/Order/ConditionallyCompleteLattice/Basic.lean

tactic: rw [coe_sSup' hb, sSup_image]
state_before: α : Type u_1
β : Type ?u.95088
γ : Type ?u.95091
ι : Sort ?u.95094
inst✝ : ConditionallyCompleteLinearOrderBot α
s : Set α
hb : BddAbove s
⊢ ↑(sSup s) = ⨆ (a : α) (_ : a ∈ s), ↑a
Theorem: Nat.max_eq_left
File: Std/Data/Nat/Lemmas.lean

tactic: rw [← Nat.max_comm b a]
state_before: a b : Nat
h : b ≤ a
⊢ max a b = a

tactic: exact Nat.max_eq_right h
state_before: a b : Nat
h : b ≤ a
⊢ max b a = a
Theorem: Set.mk_preimage_prod_left_eq_empty
File: Mathlib/Data/Set/Prod.lean

tactic: ext a
state_before: α : Type u_2
β : Type u_1
γ : Type ?u.26517
δ : Type ?u.26520
s s₁ s₂ : Set α
t t₁ t₂ : Set β
a : α
b : β
hb : ¬b ∈ t
⊢ (fun a => (a, b)) ⁻¹' s ×ˢ t = ∅

tactic: simp [hb]
state_before: case h
α : Type u_2
β : Type u_1
γ : Type ?u.26517
δ : Type ?u.26520
s s₁ s₂ : Set α
t t₁ t₂ : Set β
a✝ : α
b : β
hb : ¬b ∈ t
a : α
⊢ a ∈ (fun a => (a, b)) ⁻¹' s ×ˢ t ↔ a ∈ ∅
Theorem: Int.floor_eq_iff
File: Mathlib/Algebra/Order/Floor.lean

tactic: rw [le_antisymm_iff, le_floor, ← Int.lt_add_one_iff, floor_lt, Int.cast_add, Int.cast_one,
  and_comm]
state_before: F : Type ?u.139599
α : Type u_1
β : Type ?u.139605
inst✝¹ : LinearOrderedRing α
inst✝ : FloorRing α
z : ℤ
a : α
⊢ ⌊a⌋ = z ↔ ↑z ≤ a ∧ a < ↑z + 1
Theorem: List.singleton_sublist
File: Std/Data/List/Lemmas.lean

tactic: refine ⟨fun h => h.subset (mem_singleton_self _), fun h => ?_⟩
state_before: α : Type u_1
a : α
l : List α
⊢ [a] <+ l ↔ a ∈ l

tactic: obtain ⟨_, _, rfl⟩ := append_of_mem h
state_before: α : Type u_1
a : α
l : List α
h : a ∈ l
⊢ [a] <+ l

tactic: exact ((nil_sublist _).cons₂ _).trans (sublist_append_right ..)
state_before: case intro.intro
α : Type u_1
a : α
w✝¹ w✝ : List α
h : a ∈ w✝¹ ++ a :: w✝
⊢ [a] <+ w✝¹ ++ a :: w✝
Theorem: AddCommGroupCat.Colimits.cocone_naturality
File: Mathlib/Algebra/Category/GroupCat/Colimits.lean

tactic: ext
state_before: J : Type v
inst✝ : SmallCategory J
F : J ⥤ AddCommGroupCat
j j' : J
f : j ⟶ j'
⊢ F.map f ≫ coconeMorphism F j' = coconeMorphism F j

tactic: apply Quot.sound
state_before: case w
J : Type v
inst✝ : SmallCategory J
F : J ⥤ AddCommGroupCat
j j' : J
f : j ⟶ j'
x✝ : ↑(F.obj j)
⊢ ↑(F.map f ≫ coconeMorphism F j') x✝ = ↑(coconeMorphism F j) x✝

tactic: apply Relation.map
state_before: case w.a
J : Type v
inst✝ : SmallCategory J
F : J ⥤ AddCommGroupCat
j j' : J
f : j ⟶ j'
x✝ : ↑(F.obj j)
⊢ Setoid.r (Prequotient.of j' (↑(F.map f) x✝)) (Prequotient.of j x✝)
Theorem: String.join_eq
File: Std/Data/String/Lemmas.lean

tactic: simp
state_before: ss : List String
x✝ : List Char
⊢ List.foldl (fun x x_1 => x ++ x_1) { data := x✝ } [] = { data := x✝ ++ List.join (List.map data []) }

tactic: simp
state_before: ss✝ : List String
s : List Char
ss : List String
x✝ : List Char
⊢ { data := x✝ ++ s ++ List.join (List.map data ss) } =
    { data := x✝ ++ List.join (List.map data ({ data := s } :: ss)) }
Theorem: CommApplicative.commutative_map
File: Mathlib/Control/Basic.lean

tactic: simp [seq_map_assoc, map_seq, seq_assoc, seq_pure, map_map] <;> rfl
state_before: α✝ β✝ γ✝ : Type u
m✝ : ?m.20189
m : Type u → Type v
h : Applicative m
inst✝ : CommApplicative m
α β γ : Type u
a : m α
b : m β
f : α → β → γ
⊢ (Seq.seq (f <$> a) fun x => b) = (fun p => f p.fst p.snd) <$> Seq.seq (Prod.mk <$> a) fun x => b
Theorem: Polynomial.lt_natDegree_of_mem_eraseLead_support
File: Mathlib/Data/Polynomial/EraseLead.lean

tactic: rw [eraseLead_support, mem_erase] at h
state_before: R : Type u_1
inst✝ : Semiring R
f : R[X]
a : ℕ
h : a ∈ support (eraseLead f)
⊢ a < natDegree f

tactic: exact (le_natDegree_of_mem_supp a h.2).lt_of_ne h.1
state_before: R : Type u_1
inst✝ : Semiring R
f : R[X]
a : ℕ
h : a ≠ natDegree f ∧ a ∈ support f
⊢ a < natDegree f
Theorem: MvPolynomial.mem_ideal_span_monomial_image
File: Mathlib/RingTheory/MvPolynomial/Ideal.lean

tactic: refine' AddMonoidAlgebra.mem_ideal_span_of'_image.trans _
state_before: σ : Type u_1
R : Type u_2
inst✝ : CommSemiring R
x : MvPolynomial σ R
s : Set (σ →₀ ℕ)
⊢ x ∈ Ideal.span ((fun s => ↑(monomial s) 1) '' s) ↔ ∀ (xi : σ →₀ ℕ), xi ∈ support x → ∃ si, si ∈ s ∧ si ≤ xi

tactic: simp_rw [le_iff_exists_add, add_comm]
state_before: σ : Type u_1
R : Type u_2
inst✝ : CommSemiring R
x : MvPolynomial σ R
s : Set (σ →₀ ℕ)
⊢ (∀ (m : σ →₀ ℕ), m ∈ x.support → ∃ m', m' ∈ s ∧ ∃ d, m = d + m') ↔
    ∀ (xi : σ →₀ ℕ), xi ∈ support x → ∃ si, si ∈ s ∧ si ≤ xi

tactic: rfl
state_before: σ : Type u_1
R : Type u_2
inst✝ : CommSemiring R
x : MvPolynomial σ R
s : Set (σ →₀ ℕ)
⊢ (∀ (m : σ →₀ ℕ), m ∈ x.support → ∃ m', m' ∈ s ∧ ∃ d, m = m' + d) ↔
    ∀ (xi : σ →₀ ℕ), xi ∈ support x → ∃ si, si ∈ s ∧ ∃ c, xi = si + c
Theorem: Polynomial.X_pow_mem_lifts
File: Mathlib/Data/Polynomial/Lifts.lean

tactic: simp only [coe_mapRingHom, map_pow, Set.mem_univ, Subsemiring.coe_top, eq_self_iff_true,
  map_X, and_self_iff]
state_before: R : Type u
inst✝¹ : Semiring R
S : Type v
inst✝ : Semiring S
f✝ f : R →+* S
n : ℕ
⊢ ↑(mapRingHom f) (X ^ n) = X ^ n
Theorem: isConnected_setOf_sameRay
File: Mathlib/Analysis/Convex/Normed.lean

tactic: by_cases hx : x = 0
state_before: ι : Type ?u.49013
E : Type u_1
inst✝¹ : SeminormedAddCommGroup E
inst✝ : NormedSpace ℝ E
s t : Set E
x : E
⊢ IsConnected {y | SameRay ℝ x y}

tactic: simp_rw [← exists_nonneg_left_iff_sameRay hx]
state_before: case neg
ι : Type ?u.49013
E : Type u_1
inst✝¹ : SeminormedAddCommGroup E
inst✝ : NormedSpace ℝ E
s t : Set E
x : E
hx : ¬x = 0
⊢ IsConnected {y | SameRay ℝ x y}

tactic: exact isConnected_Ici.image _ (continuous_id.smul continuous_const).continuousOn
state_before: case neg
ι : Type ?u.49013
E : Type u_1
inst✝¹ : SeminormedAddCommGroup E
inst✝ : NormedSpace ℝ E
s t : Set E
x : E
hx : ¬x = 0
⊢ IsConnected {y | ∃ r, 0 ≤ r ∧ r • x = y}

tactic: simpa [hx] using isConnected_univ
state_before: case pos
ι : Type ?u.49013
E : Type u_1
inst✝¹ : SeminormedAddCommGroup E
inst✝ : NormedSpace ℝ E
s t : Set E
x : E
hx : x = 0
⊢ IsConnected {y | SameRay ℝ x y}
Theorem: Composition.index_embedding
File: Mathlib/Combinatorics/Composition.lean

tactic: symm
state_before: n : ℕ
c : Composition n
i : Fin (length c)
j : Fin (blocksFun c i)
⊢ index c (↑(embedding c i) j) = i

tactic: rw [← mem_range_embedding_iff']
state_before: n : ℕ
c : Composition n
i : Fin (length c)
j : Fin (blocksFun c i)
⊢ i = index c (↑(embedding c i) j)

tactic: apply Set.mem_range_self
state_before: n : ℕ
c : Composition n
i : Fin (length c)
j : Fin (blocksFun c i)
⊢ ↑(embedding c i) j ∈ Set.range ↑(embedding c i)
Theorem: Cubic.degree_of_b_eq_zero
File: Mathlib/Algebra/CubicDiscriminant.lean

tactic: simpa only [of_b_eq_zero ha hb] using degree_linear_le
state_before: R : Type u_1
S : Type ?u.580862
F : Type ?u.580865
K : Type ?u.580868
P Q : Cubic R
a b c d a' b' c' d' : R
inst✝ : Semiring R
ha : P.a = 0
hb : P.b = 0
⊢ degree (toPoly P) ≤ 1
Theorem: AffineEquiv.injective_pointReflection_left_of_module
File: Mathlib/LinearAlgebra/AffineSpace/AffineEquiv.lean

tactic: rwa [bit0, bit0, ← two_smul k x, ← two_smul k y,
  (isUnit_of_invertible (2 : k)).smul_left_cancel] at h
state_before: k : Type u_1
P₁ : Type u_2
P₂ : Type ?u.663302
P₃ : Type ?u.663305
P₄ : Type ?u.663308
V₁ : Type u_3
V₂ : Type ?u.663314
V₃ : Type ?u.663317
V₄ : Type ?u.663320
inst✝¹³ : Ring k
inst✝¹² : AddCommGroup V₁
inst✝¹¹ : Module k V₁
inst✝¹⁰ : AffineSpace V₁ P₁
inst✝⁹ : AddCommGroup V₂
inst✝⁸ : Module k V₂
inst✝⁷ : AffineSpace V₂ P₂
inst✝⁶ : AddCommGroup V₃
inst✝⁵ : Module k V₃
inst✝⁴ : AffineSpace V₃ P₃
inst✝³ : AddCommGroup V₄
inst✝² : Module k V₄
inst✝¹ : AffineSpace V₄ P₄
inst✝ : Invertible 2
x y : V₁
h : bit0 x = bit0 y
⊢ x = y
Theorem: MeasureTheory.ae_eq_set
File: Mathlib/MeasureTheory/Measure/MeasureSpaceDef.lean

tactic: simp [eventuallyLE_antisymm_iff, ae_le_set]
state_before: α : Type u_1
β : Type ?u.107971
γ : Type ?u.107974
δ : Type ?u.107977
ι : Type ?u.107980
inst✝ : MeasurableSpace α
μ μ₁ μ₂ : Measure α
s✝ s₁ s₂ t✝ s t : Set α
⊢ s =ᵐ[μ] t ↔ ↑↑μ (s \ t) = 0 ∧ ↑↑μ (t \ s) = 0
Theorem: FractionalIdeal.mul_right_le_iff
File: Mathlib/RingTheory/DedekindDomain/Ideal.lean

tactic: intro I I'
state_before: R : Type ?u.697823
A : Type u_1
K : Type u_2
inst✝⁶ : CommRing R
inst✝⁵ : CommRing A
inst✝⁴ : Field K
inst✝³ : IsDomain A
inst✝² : Algebra A K
inst✝¹ : IsFractionRing A K
inst✝ : IsDedekindDomain A
J : FractionalIdeal A⁰ K
hJ : J ≠ 0
⊢ ∀ {I I' : FractionalIdeal A⁰ K}, I * J ≤ I' * J ↔ I ≤ I'

tactic: constructor
state_before: R : Type ?u.697823
A : Type u_1
K : Type u_2
inst✝⁶ : CommRing R
inst✝⁵ : CommRing A
inst✝⁴ : Field K
inst✝³ : IsDomain A
inst✝² : Algebra A K
inst✝¹ : IsFractionRing A K
inst✝ : IsDedekindDomain A
J : FractionalIdeal A⁰ K
hJ : J ≠ 0
I I' : FractionalIdeal A⁰ K
⊢ I * J ≤ I' * J ↔ I ≤ I'

tactic: intro h
state_before: case mp
R : Type ?u.697823
A : Type u_1
K : Type u_2
inst✝⁶ : CommRing R
inst✝⁵ : CommRing A
inst✝⁴ : Field K
inst✝³ : IsDomain A
inst✝² : Algebra A K
inst✝¹ : IsFractionRing A K
inst✝ : IsDedekindDomain A
J : FractionalIdeal A⁰ K
hJ : J ≠ 0
I I' : FractionalIdeal A⁰ K
⊢ I * J ≤ I' * J → I ≤ I'

tactic: convert mul_right_mono J⁻¹ h <;> dsimp only <;>
rw [mul_assoc, FractionalIdeal.mul_inv_cancel hJ, mul_one]
state_before: case mp
R : Type ?u.697823
A : Type u_1
K : Type u_2
inst✝⁶ : CommRing R
inst✝⁵ : CommRing A
inst✝⁴ : Field K
inst✝³ : IsDomain A
inst✝² : Algebra A K
inst✝¹ : IsFractionRing A K
inst✝ : IsDedekindDomain A
J : FractionalIdeal A⁰ K
hJ : J ≠ 0
I I' : FractionalIdeal A⁰ K
h : I * J ≤ I' * J
⊢ I ≤ I'

tactic: exact fun h => mul_right_mono J h
state_before: case mpr
R : Type ?u.697823
A : Type u_1
K : Type u_2
inst✝⁶ : CommRing R
inst✝⁵ : CommRing A
inst✝⁴ : Field K
inst✝³ : IsDomain A
inst✝² : Algebra A K
inst✝¹ : IsFractionRing A K
inst✝ : IsDedekindDomain A
J : FractionalIdeal A⁰ K
hJ : J ≠ 0
I I' : FractionalIdeal A⁰ K
⊢ I ≤ I' → I * J ≤ I' * J
Theorem: Subgroup.set_mul_normal_comm
File: Mathlib/GroupTheory/Subgroup/Pointwise.lean

tactic: ext x
state_before: α : Type ?u.21855
G : Type u_1
A : Type ?u.21861
S : Type ?u.21864
inst✝¹ : Group G
inst✝ : AddGroup A
s✝ s : Set G
N : Subgroup G
hN : Normal N
⊢ s * ↑N = ↑N * s

tactic: refine (exists_congr fun y => ?_).trans exists_swap
state_before: case h
α : Type ?u.21855
G : Type u_1
A : Type ?u.21861
S : Type ?u.21864
inst✝¹ : Group G
inst✝ : AddGroup A
s✝ s : Set G
N : Subgroup G
hN : Normal N
x : G
⊢ x ∈ s * ↑N ↔ x ∈ ↑N * s

tactic: simp only [exists_and_left, @and_left_comm _ (y ∈ s), ← eq_inv_mul_iff_mul_eq (b := y),
  ← eq_mul_inv_iff_mul_eq  (c := y), exists_eq_right, SetLike.mem_coe, hN.mem_comm_iff]
state_before: case h
α : Type ?u.21855
G : Type u_1
A : Type ?u.21861
S : Type ?u.21864
inst✝¹ : Group G
inst✝ : AddGroup A
s✝ s : Set G
N : Subgroup G
hN : Normal N
x y : G
⊢ (∃ b, y ∈ s ∧ b ∈ ↑N ∧ (fun x x_1 => x * x_1) y b = x) ↔ ∃ y_1, y_1 ∈ ↑N ∧ y ∈ s ∧ (fun x x_1 => x * x_1) y_1 y = x
Theorem: Set.biUnion_diff_biUnion_eq
File: Mathlib/Data/Set/Pairwise/Lattice.lean

tactic: refine'
  (biUnion_diff_biUnion_subset f s t).antisymm
    (iUnion₂_subset fun i hi a ha => (mem_diff _).2 ⟨mem_biUnion hi.1 ha, _⟩)
state_before: α : Type u_2
β : Type ?u.3238
γ : Type ?u.3241
ι : Type u_1
ι' : Type ?u.3247
r p q : α → α → Prop
s t : Set ι
f : ι → Set α
h : PairwiseDisjoint (s ∪ t) f
⊢ ((⋃ (i : ι) (_ : i ∈ s), f i) \ ⋃ (i : ι) (_ : i ∈ t), f i) = ⋃ (i : ι) (_ : i ∈ s \ t), f i

tactic: rw [mem_iUnion₂]
state_before: α : Type u_2
β : Type ?u.3238
γ : Type ?u.3241
ι : Type u_1
ι' : Type ?u.3247
r p q : α → α → Prop
s t : Set ι
f : ι → Set α
h : PairwiseDisjoint (s ∪ t) f
i : ι
hi : i ∈ s \ t
a : α
ha : a ∈ f i
⊢ ¬a ∈ ⋃ (x : ι) (_ : x ∈ t), f x

tactic: rintro ⟨j, hj, haj⟩
state_before: α : Type u_2
β : Type ?u.3238
γ : Type ?u.3241
ι : Type u_1
ι' : Type ?u.3247
r p q : α → α → Prop
s t : Set ι
f : ι → Set α
h : PairwiseDisjoint (s ∪ t) f
i : ι
hi : i ∈ s \ t
a : α
ha : a ∈ f i
⊢ ¬∃ i j, a ∈ f i

tactic: exact (h (Or.inl hi.1) (Or.inr hj) (ne_of_mem_of_not_mem hj hi.2).symm).le_bot ⟨ha, haj⟩
state_before: case intro.intro
α : Type u_2
β : Type ?u.3238
γ : Type ?u.3241
ι : Type u_1
ι' : Type ?u.3247
r p q : α → α → Prop
s t : Set ι
f : ι → Set α
h : PairwiseDisjoint (s ∪ t) f
i : ι
hi : i ∈ s \ t
a : α
ha : a ∈ f i
j : ι
hj : j ∈ t
haj : a ∈ f j
⊢ False
Theorem: Nat.cast_choose_eq_pochhammer_div
File: Mathlib/Data/Nat/Choose/Cast.lean

tactic: rw [eq_div_iff_mul_eq (cast_ne_zero.2 b.factorial_ne_zero : (b ! : K) ≠ 0), ← cast_mul,
  mul_comm, ← descFactorial_eq_factorial_mul_choose, ← cast_descFactorial]
state_before: K : Type u_1
inst✝¹ : DivisionRing K
inst✝ : CharZero K
a b : ℕ
⊢ ↑(choose a b) = Polynomial.eval (↑(a - (b - 1))) (pochhammer K b) / ↑b !
Theorem: Real.sign_mul_nonneg
File: Mathlib/Data/Real/Sign.lean

tactic: obtain hn | rfl | hp := lt_trichotomy r (0 : ℝ)
state_before: r : ℝ
⊢ 0 ≤ sign r * r

tactic: rw [sign_of_neg hn]
state_before: case inl
r : ℝ
hn : r < 0
⊢ 0 ≤ sign r * r

tactic: exact mul_nonneg_of_nonpos_of_nonpos (by norm_num) hn.le
state_before: case inl
r : ℝ
hn : r < 0
⊢ 0 ≤ -1 * r

tactic: norm_num
state_before: r : ℝ
hn : r < 0
⊢ -1 ≤ 0

tactic: rw [mul_zero]
state_before: case inr.inl

⊢ 0 ≤ sign 0 * 0

tactic: rw [sign_of_pos hp, one_mul]
state_before: case inr.inr
r : ℝ
hp : 0 < r
⊢ 0 ≤ sign r * r

tactic: exact hp.le
state_before: case inr.inr
r : ℝ
hp : 0 < r
⊢ 0 ≤ r
Theorem: DirectSum.IsInternal.collectedBasis_orthonormal
File: Mathlib/Analysis/InnerProductSpace/Basic.lean

tactic: simpa only [hV_sum.collectedBasis_coe] using hV.orthonormal_sigma_orthonormal hv_family
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type ?u.3801506
inst✝⁶ : IsROrC 𝕜
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : InnerProductSpace 𝕜 E
inst✝³ : NormedAddCommGroup F
inst✝² : InnerProductSpace ℝ F
dec_E : DecidableEq E
ι : Type u_3
dec_ι : DecidableEq ι
G : ι → Type ?u.3801569
inst✝¹ : (i : ι) → NormedAddCommGroup (G i)
inst✝ : (i : ι) → InnerProductSpace 𝕜 (G i)
V✝ : (i : ι) → G i →ₗᵢ[𝕜] E
hV✝ : OrthogonalFamily 𝕜 G V✝
dec_V : (i : ι) → (x : G i) → Decidable (x ≠ 0)
V : ι → Submodule 𝕜 E
hV : OrthogonalFamily 𝕜 (fun i => { x // x ∈ V i }) fun i => Submodule.subtypeₗᵢ (V i)
hV_sum : IsInternal fun i => V i
α : ι → Type u_4
v_family : (i : ι) → Basis (α i) 𝕜 { x // x ∈ V i }
hv_family : ∀ (i : ι), Orthonormal 𝕜 ↑(v_family i)
⊢ Orthonormal 𝕜 ↑(collectedBasis hV_sum v_family)
Theorem: inner_add_add_self
File: Mathlib/Analysis/InnerProductSpace/Basic.lean

tactic: simp only [inner_add_left, inner_add_right]
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type ?u.1804599
inst✝⁴ : IsROrC 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : NormedAddCommGroup F
inst✝ : InnerProductSpace ℝ F
dec_E : DecidableEq E
x y : E
⊢ inner (x + y) (x + y) = inner x x + inner x y + inner y x + inner y y

tactic: ring
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type ?u.1804599
inst✝⁴ : IsROrC 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : NormedAddCommGroup F
inst✝ : InnerProductSpace ℝ F
dec_E : DecidableEq E
x y : E
⊢ inner x x + inner y x + (inner x y + inner y y) = inner x x + inner x y + inner y x + inner y y
Theorem: sq_le_sq
File: Mathlib/Algebra/GroupPower/Order.lean

tactic: simpa only [sq_abs] using
  (@strictMonoOn_pow R _ _ two_pos).le_iff_le (abs_nonneg x) (abs_nonneg y)
state_before: β : Type ?u.260389
A : Type ?u.260392
G : Type ?u.260395
M : Type ?u.260398
R : Type u_1
inst✝ : LinearOrderedRing R
x y : R
⊢ x ^ 2 ≤ y ^ 2 ↔ abs x ≤ abs y
Theorem: smul_neg_iff_of_neg
File: Mathlib/Algebra/Order/Module.lean

tactic: rw [← neg_neg c, neg_smul, neg_neg_iff_pos]
state_before: k : Type u_1
M : Type u_2
N : Type ?u.32115
inst✝³ : OrderedRing k
inst✝² : OrderedAddCommGroup M
inst✝¹ : Module k M
inst✝ : OrderedSMul k M
a b : M
c : k
hc : c < 0
⊢ c • a < 0 ↔ 0 < a

tactic: exact smul_pos_iff_of_pos (neg_pos_of_neg hc)
state_before: k : Type u_1
M : Type u_2
N : Type ?u.32115
inst✝³ : OrderedRing k
inst✝² : OrderedAddCommGroup M
inst✝¹ : Module k M
inst✝ : OrderedSMul k M
a b : M
c : k
hc : c < 0
⊢ 0 < -c • a ↔ 0 < a
Theorem: List.Ico.filter_lt
File: Mathlib/Data/List/Intervals.lean

tactic: cases' le_total m l with hml hlm
state_before: n m l : ℕ
⊢ filter (fun x => decide (x < l)) (Ico n m) = Ico n (min m l)

tactic: rw [min_eq_left hml, filter_lt_of_top_le hml]
state_before: case inl
n m l : ℕ
hml : m ≤ l
⊢ filter (fun x => decide (x < l)) (Ico n m) = Ico n (min m l)

tactic: rw [min_eq_right hlm, filter_lt_of_ge hlm]
state_before: case inr
n m l : ℕ
hlm : l ≤ m
⊢ filter (fun x => decide (x < l)) (Ico n m) = Ico n (min m l)
Theorem: Subalgebra.toSubring_injective
File: Mathlib/Algebra/Algebra/Subalgebra/Basic.lean

tactic: rw [← mem_toSubring, ← mem_toSubring, h]
state_before: R' : Type u'
R✝ : Type u
A✝ : Type v
B : Type w
C : Type w'
inst✝⁹ : CommSemiring R✝
inst✝⁸ : Semiring A✝
inst✝⁷ : Algebra R✝ A✝
inst✝⁶ : Semiring B
inst✝⁵ : Algebra R✝ B
inst✝⁴ : Semiring C
inst✝³ : Algebra R✝ C
S✝ : Subalgebra R✝ A✝
R : Type u
A : Type v
inst✝² : CommRing R
inst✝¹ : Ring A
inst✝ : Algebra R A
S T : Subalgebra R A
h : toSubring S = toSubring T
x : A
⊢ x ∈ S ↔ x ∈ T
Theorem: LiouvilleWith.add_nat_iff
File: Mathlib/NumberTheory/Liouville/LiouvilleWith.lean

tactic: rw [← Rat.cast_coe_nat n, add_rat_iff]
state_before: p q x y : ℝ
r : ℚ
m : ℤ
n : ℕ
⊢ LiouvilleWith p (x + ↑n) ↔ LiouvilleWith p x
Theorem: Equiv.Perm.Disjoint.mul_right
File: Mathlib/GroupTheory/Perm/Support.lean

tactic: rw [disjoint_comm]
state_before: α : Type u_1
f g h : Perm α
H1 : Disjoint f g
H2 : Disjoint f h
⊢ Disjoint f (g * h)

tactic: exact H1.symm.mul_left H2.symm
state_before: α : Type u_1
f g h : Perm α
H1 : Disjoint f g
H2 : Disjoint f h
⊢ Disjoint (g * h) f