tasksource/leandojo huggingface dataset:
Theorem: Prod.image_mk_openSegment_left
File: Mathlib/Analysis/Convex/Segment.lean

tactic: ext ⟨x', y'⟩
state_before: 𝕜 : Type u_3
E : Type u_1
F : Type u_2
G : Type ?u.343510
ι : Type ?u.343513
π : ι → Type ?u.343518
inst✝⁴ : OrderedSemiring 𝕜
inst✝³ : AddCommMonoid E
inst✝² : AddCommMonoid F
inst✝¹ : Module 𝕜 E
inst✝ : Module 𝕜 F
x₁ x₂ : E
y : F
⊢ (fun x => (x, y)) '' openSegment 𝕜 x₁ x₂ = openSegment 𝕜 (x₁, y) (x₂, y)

tactic: simp_rw [Set.mem_image, openSegment, Set.mem_setOf, Prod.smul_mk, Prod.mk_add_mk, Prod.mk.inj_iff,
  ← exists_and_right, @exists_comm E, exists_eq_left']
state_before: case h.mk
𝕜 : Type u_3
E : Type u_1
F : Type u_2
G : Type ?u.343510
ι : Type ?u.343513
π : ι → Type ?u.343518
inst✝⁴ : OrderedSemiring 𝕜
inst✝³ : AddCommMonoid E
inst✝² : AddCommMonoid F
inst✝¹ : Module 𝕜 E
inst✝ : Module 𝕜 F
x₁ x₂ : E
y : F
x' : E
y' : F
⊢ (x', y') ∈ (fun x => (x, y)) '' openSegment 𝕜 x₁ x₂ ↔ (x', y') ∈ openSegment 𝕜 (x₁, y) (x₂, y)

tactic: refine' exists₅_congr fun a b ha hb hab => _
state_before: case h.mk
𝕜 : Type u_3
E : Type u_1
F : Type u_2
G : Type ?u.343510
ι : Type ?u.343513
π : ι → Type ?u.343518
inst✝⁴ : OrderedSemiring 𝕜
inst✝³ : AddCommMonoid E
inst✝² : AddCommMonoid F
inst✝¹ : Module 𝕜 E
inst✝ : Module 𝕜 F
x₁ x₂ : E
y : F
x' : E
y' : F
⊢ (∃ b b_1 h h h, b • x₁ + b_1 • x₂ = x' ∧ y = y') ↔ ∃ a b h h h, a • x₁ + b • x₂ = x' ∧ a • y + b • y = y'

tactic: rw [Convex.combo_self hab]
state_before: case h.mk
𝕜 : Type u_3
E : Type u_1
F : Type u_2
G : Type ?u.343510
ι : Type ?u.343513
π : ι → Type ?u.343518
inst✝⁴ : OrderedSemiring 𝕜
inst✝³ : AddCommMonoid E
inst✝² : AddCommMonoid F
inst✝¹ : Module 𝕜 E
inst✝ : Module 𝕜 F
x₁ x₂ : E
y : F
x' : E
y' : F
a b : 𝕜
ha : 0 < a
hb : 0 < b
hab : a + b = 1
⊢ a • x₁ + b • x₂ = x' ∧ y = y' ↔ a • x₁ + b • x₂ = x' ∧ a • y + b • y = y'
Theorem: Sym2.card_subtype_not_diag
File: Mathlib/Data/Sym/Card.lean

tactic: convert card_image_offDiag (univ : Finset α)
state_before: α : Type u_1
β : Type ?u.100368
inst✝¹ : DecidableEq α
inst✝ : Fintype α
⊢ Fintype.card { a // ¬IsDiag a } = Nat.choose (Fintype.card α) 2

tactic: simp_rw [Quotient.mk', ← Quotient.mk''_eq_mk]
state_before: case h.e'_2
α : Type u_1
β : Type ?u.100368
inst✝¹ : DecidableEq α
inst✝ : Fintype α
⊢ Fintype.card { a // ¬IsDiag a } = Finset.card (image Quotient.mk' (offDiag univ))

tactic: rw [Fintype.card_of_subtype, ← filter_image_quotient_mk''_not_isDiag]
state_before: case h.e'_2
α : Type u_1
β : Type ?u.100368
inst✝¹ : DecidableEq α
inst✝ : Fintype α
⊢ Fintype.card { a // ¬IsDiag a } = Finset.card (image (fun a => Quotient.mk'' a) (offDiag univ))

tactic: rintro x
state_before: case h.e'_2.H
α : Type u_1
β : Type ?u.100368
inst✝¹ : DecidableEq α
inst✝ : Fintype α
⊢ ∀ (x : Sym2 α), x ∈ filter (fun a => ¬IsDiag a) (image Quotient.mk'' (univ ×ˢ univ)) ↔ ¬IsDiag x

tactic: rw [mem_filter, univ_product_univ, mem_image]
state_before: case h.e'_2.H
α : Type u_1
β : Type ?u.100368
inst✝¹ : DecidableEq α
inst✝ : Fintype α
x : Sym2 α
⊢ x ∈ filter (fun a => ¬IsDiag a) (image Quotient.mk'' (univ ×ˢ univ)) ↔ ¬IsDiag x

tactic: obtain ⟨a, ha⟩ := Quotient.exists_rep x
state_before: case h.e'_2.H
α : Type u_1
β : Type ?u.100368
inst✝¹ : DecidableEq α
inst✝ : Fintype α
x : Sym2 α
⊢ (∃ a, a ∈ univ ∧ Quotient.mk'' a = x) ∧ ¬IsDiag x ↔ ¬IsDiag x

tactic: exact and_iff_right ⟨a, mem_univ _, ha⟩
state_before: case h.e'_2.H.intro
α : Type u_1
β : Type ?u.100368
inst✝¹ : DecidableEq α
inst✝ : Fintype α
x : Sym2 α
a : α × α
ha : Quotient.mk (Rel.setoid α) a = x
⊢ (∃ a, a ∈ univ ∧ Quotient.mk'' a = x) ∧ ¬IsDiag x ↔ ¬IsDiag x
Theorem: thickening_closedBall
File: Mathlib/Analysis/NormedSpace/Pointwise.lean

tactic: rw [← cthickening_singleton _ hδ, thickening_cthickening hε hδ, thickening_singleton]
state_before: 𝕜 : Type ?u.340066
E : Type u_1
inst✝³ : NormedField 𝕜
inst✝² : SeminormedAddCommGroup E
inst✝¹ : NormedSpace 𝕜 E
inst✝ : NormedSpace ℝ E
x✝ y z : E
δ ε : ℝ
hε : 0 < ε
hδ : 0 ≤ δ
x : E
⊢ thickening ε (Metric.closedBall x δ) = Metric.ball x (ε + δ)
Theorem: Int.mul_lt_mul_of_neg_right
File: Std/Data/Int/Lemmas.lean

tactic: rwa [← Int.neg_mul_eq_mul_neg, ← Int.neg_mul_eq_mul_neg] at this
state_before: a b c : Int
h : b < a
hc : c < 0
this✝ : -c > 0
this : b * -c < a * -c
⊢ -(b * c) < -(a * c)
Theorem: TsirelsonInequality.tsirelson_inequality_aux
File: Mathlib/Algebra/Star/CHSH.lean

tactic: ring_nf
state_before: R : Type u
⊢ Real.sqrt 2 * Real.sqrt 2 ^ 3 = Real.sqrt 2 * (2 * (Real.sqrt 2)⁻¹ + 4 * ((Real.sqrt 2)⁻¹ * 2⁻¹))

tactic: rw [mul_inv_cancel (ne_of_gt (Real.sqrt_pos.2 (show (2 : ℝ) > 0 by norm_num)))]
state_before: R : Type u
⊢ Real.sqrt 2 ^ 4 = Real.sqrt 2 * (Real.sqrt 2)⁻¹ * 4

tactic: norm_num
state_before: R : Type u
⊢ 2 > 0

tactic: norm_num
state_before: R : Type u
⊢ 0 ≤ 2
Theorem: toIcoMod_add_right'
File: Mathlib/Algebra/Order/ToIntervalMod.lean

tactic: simpa only [one_zsmul] using toIcoMod_add_zsmul' hp a b 1
state_before: α : Type u_1
inst✝ : LinearOrderedAddCommGroup α
hα : Archimedean α
p : α
hp : 0 < p
a✝ b✝ c : α
n : ℤ
a b : α
⊢ toIcoMod hp (a + p) b = toIcoMod hp a b + p
Theorem: Set.mk_preimage_prod_right_eq_empty
File: Mathlib/Data/Set/Prod.lean

tactic: ext b
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.27167
δ : Type ?u.27170
s s₁ s₂ : Set α
t t₁ t₂ : Set β
a : α
b : β
ha : ¬a ∈ s
⊢ Prod.mk a ⁻¹' s ×ˢ t = ∅

tactic: simp [ha]
state_before: case h
α : Type u_1
β : Type u_2
γ : Type ?u.27167
δ : Type ?u.27170
s s₁ s₂ : Set α
t t₁ t₂ : Set β
a : α
b✝ : β
ha : ¬a ∈ s
b : β
⊢ b ∈ Prod.mk a ⁻¹' s ×ˢ t ↔ b ∈ ∅
Theorem: Real.volume_ball
File: Mathlib/MeasureTheory/Measure/Lebesgue/Basic.lean

tactic: rw [ball_eq_Ioo, volume_Ioo, ← sub_add, add_sub_cancel', two_mul]
state_before: ι : Type ?u.130013
inst✝ : Fintype ι
a r : ℝ
⊢ ↑↑volume (Metric.ball a r) = ofReal (2 * r)
Theorem: List.eraseP_append_right
File: Std/Data/List/Lemmas.lean

tactic: simp [(forall_mem_cons.1 h).1, eraseP_append_right _ (forall_mem_cons.1 h).2]
state_before: α : Type u_1
p : α → Bool
x : α
xs l₂ : List α
h : ∀ (b : α), b ∈ x :: xs → ¬p b = true
⊢ eraseP p (x :: xs ++ l₂) = x :: xs ++ eraseP p l₂
Theorem: Fintype.card_subtype
File: Mathlib/Data/Fintype/Card.lean

tactic: refine' Fintype.card_of_subtype _ _
state_before: α : Type u_1
β : Type ?u.55899
γ : Type ?u.55902
inst✝¹ : Fintype α
p : α → Prop
inst✝ : DecidablePred p
⊢ card { x // p x } = Finset.card (filter p univ)

tactic: simp
state_before: α : Type u_1
β : Type ?u.55899
γ : Type ?u.55902
inst✝¹ : Fintype α
p : α → Prop
inst✝ : DecidablePred p
⊢ ∀ (x : α), x ∈ filter p univ ↔ p x
Theorem: Algebra.toSubmodule_bot
File: Mathlib/Algebra/Algebra/Subalgebra/Basic.lean

tactic: ext x
state_before: R : Type u
A : Type v
B : Type w
inst✝⁴ : CommSemiring R
inst✝³ : Semiring A
inst✝² : Algebra R A
inst✝¹ : Semiring B
inst✝ : Algebra R B
⊢ ↑Subalgebra.toSubmodule ⊥ = Submodule.span R {1}

tactic: simp [mem_bot, Submodule.mem_span_singleton, Algebra.smul_def]
state_before: case h
R : Type u
A : Type v
B : Type w
inst✝⁴ : CommSemiring R
inst✝³ : Semiring A
inst✝² : Algebra R A
inst✝¹ : Semiring B
inst✝ : Algebra R B
x : A
⊢ x ∈ ↑Subalgebra.toSubmodule ⊥ ↔ x ∈ Submodule.span R {1}
Theorem: ZNum.cast_le
File: Mathlib/Data/Num/Lemmas.lean

tactic: rw [← not_lt]
state_before: α : Type u_1
inst✝ : LinearOrderedRing α
m n : ZNum
⊢ ↑m ≤ ↑n ↔ m ≤ n

tactic: exact not_congr cast_lt
state_before: α : Type u_1
inst✝ : LinearOrderedRing α
m n : ZNum
⊢ ¬↑n < ↑m ↔ m ≤ n
Theorem: Complex.iter_deriv_exp
File: Mathlib/Analysis/SpecialFunctions/ExpDeriv.lean

tactic: rw [iterate_succ_apply, deriv_exp, iter_deriv_exp n]
state_before: 𝕜 : Type ?u.7221
inst✝¹ : NontriviallyNormedField 𝕜
inst✝ : NormedAlgebra 𝕜 ℂ
n : ℕ
⊢ (deriv^[n + 1]) exp = exp
Theorem: CategoryTheory.Mat.id_apply_of_ne
File: Mathlib/CategoryTheory/Preadditive/Mat.lean

tactic: simp [id_apply, h]
state_before: C : Type u₁
inst✝² : Category C
inst✝¹ : Preadditive C
R : Type u
inst✝ : Semiring R
M : Mat R
i j : ↑M
h : i ≠ j
⊢ 𝟙 M i j = 0
Theorem: BoxIntegral.IntegrationParams.exists_memBaseSet_isPartition
File: Mathlib/Analysis/BoxIntegral/Partition/Filter.lean

tactic: rw [← Prepartition.distortion_top] at hc
state_before: ι : Type u_1
inst✝ : Fintype ι
I✝ J : Box ι
c c₁ c₂ : ℝ≥0
r✝ r₁ r₂ : (ι → ℝ) → ↑(Set.Ioi 0)
π π₁ π₂ : TaggedPrepartition I✝
l✝ l₁ l₂ l : IntegrationParams
I : Box ι
hc : Box.distortion I ≤ c
r : (ι → ℝ) → ↑(Set.Ioi 0)
⊢ ∃ π, MemBaseSet l I c r π ∧ IsPartition π

tactic: have hc' : (⊤ : Prepartition I).compl.distortion ≤ c := by simp
state_before: ι : Type u_1
inst✝ : Fintype ι
I✝ J : Box ι
c c₁ c₂ : ℝ≥0
r✝ r₁ r₂ : (ι → ℝ) → ↑(Set.Ioi 0)
π π₁ π₂ : TaggedPrepartition I✝
l✝ l₁ l₂ l : IntegrationParams
I : Box ι
hc : Prepartition.distortion ⊤ ≤ c
r : (ι → ℝ) → ↑(Set.Ioi 0)
⊢ ∃ π, MemBaseSet l I c r π ∧ IsPartition π

tactic: simpa [isPartition_iff_iUnion_eq] using l.exists_memBaseSet_le_iUnion_eq ⊤ hc hc' r
state_before: ι : Type u_1
inst✝ : Fintype ι
I✝ J : Box ι
c c₁ c₂ : ℝ≥0
r✝ r₁ r₂ : (ι → ℝ) → ↑(Set.Ioi 0)
π π₁ π₂ : TaggedPrepartition I✝
l✝ l₁ l₂ l : IntegrationParams
I : Box ι
hc : Prepartition.distortion ⊤ ≤ c
r : (ι → ℝ) → ↑(Set.Ioi 0)
hc' : Prepartition.distortion (Prepartition.compl ⊤) ≤ c
⊢ ∃ π, MemBaseSet l I c r π ∧ IsPartition π

tactic: simp
state_before: ι : Type u_1
inst✝ : Fintype ι
I✝ J : Box ι
c c₁ c₂ : ℝ≥0
r✝ r₁ r₂ : (ι → ℝ) → ↑(Set.Ioi 0)
π π₁ π₂ : TaggedPrepartition I✝
l✝ l₁ l₂ l : IntegrationParams
I : Box ι
hc : Prepartition.distortion ⊤ ≤ c
r : (ι → ℝ) → ↑(Set.Ioi 0)
⊢ Prepartition.distortion (Prepartition.compl ⊤) ≤ c
Theorem: MvPolynomial.C_dvd_iff_map_hom_eq_zero
File: Mathlib/Data/MvPolynomial/Basic.lean

tactic: rw [C_dvd_iff_dvd_coeff, MvPolynomial.ext_iff]
state_before: R : Type u
S₁ : Type v
S₂ : Type w
S₃ : Type x
σ : Type u_1
a a' a₁ a₂ : R
e : ℕ
n m : σ
s : σ →₀ ℕ
inst✝¹ : CommSemiring R
inst✝ : CommSemiring S₁
p q✝ : MvPolynomial σ R
f q : R →+* S₁
r : R
hr : ∀ (r' : R), ↑q r' = 0 ↔ r ∣ r'
φ : MvPolynomial σ R
⊢ ↑C r ∣ φ ↔ ↑(map q) φ = 0

tactic: simp only [coeff_map, coeff_zero, hr]
state_before: R : Type u
S₁ : Type v
S₂ : Type w
S₃ : Type x
σ : Type u_1
a a' a₁ a₂ : R
e : ℕ
n m : σ
s : σ →₀ ℕ
inst✝¹ : CommSemiring R
inst✝ : CommSemiring S₁
p q✝ : MvPolynomial σ R
f q : R →+* S₁
r : R
hr : ∀ (r' : R), ↑q r' = 0 ↔ r ∣ r'
φ : MvPolynomial σ R
⊢ (∀ (i : σ →₀ ℕ), r ∣ coeff i φ) ↔ ∀ (m : σ →₀ ℕ), coeff m (↑(map q) φ) = coeff m 0
Theorem: volume_setOf_liouville
File: Mathlib/NumberTheory/Liouville/Measure.lean

tactic: simpa only [ae_iff, Classical.not_not] using ae_not_liouville
state_before: ⊢ ↑↑volume {x | Liouville x} = 0
Theorem: MvPowerSeries.eq_inv_iff_mul_eq_one
File: Mathlib/RingTheory/PowerSeries/Basic.lean

tactic: rw [← MvPowerSeries.eq_mul_inv_iff_mul_eq h, one_mul]
state_before: σ : Type u_1
R : Type ?u.1908912
k : Type u_2
inst✝ : Field k
φ ψ : MvPowerSeries σ k
h : ↑(constantCoeff σ k) ψ ≠ 0
⊢ φ = ψ⁻¹ ↔ φ * ψ = 1
Theorem: Polynomial.degree_normalize
File: Mathlib/Data/Polynomial/FieldDivision.lean

tactic: simp
state_before: R : Type u
S : Type v
k : Type y
A : Type z
a b : R
n : ℕ
inst✝ : Field R
p q : R[X]
⊢ degree (↑normalize p) = degree p
Theorem: Sum.elim_map
File: Mathlib/Data/Sum/Basic.lean

tactic: cases x <;> rfl
state_before: α✝ : Type u
α' : Type w
β✝ : Type v
β' : Type x
γ✝ : Type ?u.12562
δ✝ : Type ?u.12565
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ε : Sort u_5
f₁ : α → β
f₂ : β → ε
g₁ : γ → δ
g₂ : δ → ε
x : α ⊕ γ
⊢ Sum.elim f₂ g₂ (Sum.map f₁ g₁ x) = Sum.elim (f₂ ∘ f₁) (g₂ ∘ g₁) x
Theorem: summable_sum_mul_range_of_summable_mul
File: Mathlib/Topology/Algebra/InfiniteSum/Ring.lean

tactic: simp_rw [← Nat.sum_antidiagonal_eq_sum_range_succ fun k l => f k * g l]
state_before: ι : Type ?u.33257
κ : Type ?u.33260
R : Type ?u.33263
α : Type u_1
inst✝³ : TopologicalSpace α
inst✝² : NonUnitalNonAssocSemiring α
f g : ℕ → α
inst✝¹ : T3Space α
inst✝ : TopologicalSemiring α
h : Summable fun x => f x.fst * g x.snd
⊢ Summable fun n => ∑ k in range (n + 1), f k * g (n - k)

tactic: exact summable_sum_mul_antidiagonal_of_summable_mul h
state_before: ι : Type ?u.33257
κ : Type ?u.33260
R : Type ?u.33263
α : Type u_1
inst✝³ : TopologicalSpace α
inst✝² : NonUnitalNonAssocSemiring α
f g : ℕ → α
inst✝¹ : T3Space α
inst✝ : TopologicalSemiring α
h : Summable fun x => f x.fst * g x.snd
⊢ Summable fun n => ∑ ij in Nat.antidiagonal n, f ij.fst * g ij.snd
Theorem: cross_anticomm
File: Mathlib/LinearAlgebra/CrossProduct.lean

tactic: simp [cross_apply, mul_comm]
state_before: R : Type u_1
inst✝ : CommRing R
v w : Fin 3 → R
⊢ -↑(↑crossProduct v) w = ↑(↑crossProduct w) v
Theorem: InnerProductGeometry.angle_sub_eq_arctan_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
h0 : x ≠ 0
⊢ angle x (x - y) = Real.arctan (‖y‖ / ‖x‖)

tactic: rw [sub_eq_add_neg, angle_add_eq_arctan_of_inner_eq_zero h h0, norm_neg]
state_before: V : Type u_1
inst✝¹ : NormedAddCommGroup V
inst✝ : InnerProductSpace ℝ V
x y : V
h : inner x (-y) = 0
h0 : x ≠ 0
⊢ angle x (x - y) = Real.arctan (‖y‖ / ‖x‖)
Theorem: Set.mulIndicator_mul
File: Mathlib/Algebra/IndicatorFunction.lean

tactic: funext
state_before: α : Type u_1
β : Type ?u.53297
ι : Type ?u.53300
M : Type u_2
N : Type ?u.53306
inst✝ : MulOneClass M
s✝ t : Set α
f✝ g✝ : α → M
a : α
s : Set α
f g : α → M
⊢ (mulIndicator s fun a => f a * g a) = fun a => mulIndicator s f a * mulIndicator s g a

tactic: simp only [mulIndicator]
state_before: case h
α : Type u_1
β : Type ?u.53297
ι : Type ?u.53300
M : Type u_2
N : Type ?u.53306
inst✝ : MulOneClass M
s✝ t : Set α
f✝ g✝ : α → M
a : α
s : Set α
f g : α → M
x✝ : α
⊢ mulIndicator s (fun a => f a * g a) x✝ = mulIndicator s f x✝ * mulIndicator s g x✝

tactic: split_ifs
state_before: case h
α : Type u_1
β : Type ?u.53297
ι : Type ?u.53300
M : Type u_2
N : Type ?u.53306
inst✝ : MulOneClass M
s✝ t : Set α
f✝ g✝ : α → M
a : α
s : Set α
f g : α → M
x✝ : α
⊢ (if x✝ ∈ s then f x✝ * g x✝ else 1) = (if x✝ ∈ s then f x✝ else 1) * if x✝ ∈ s then g x✝ else 1

tactic: rw [mul_one]
state_before: case h.inr
α : Type u_1
β : Type ?u.53297
ι : Type ?u.53300
M : Type u_2
N : Type ?u.53306
inst✝ : MulOneClass M
s✝ t : Set α
f✝ g✝ : α → M
a : α
s : Set α
f g : α → M
x✝ : α
h✝ : ¬x✝ ∈ s
⊢ 1 = 1 * 1

tactic: rfl
state_before: case h.inl
α : Type u_1
β : Type ?u.53297
ι : Type ?u.53300
M : Type u_2
N : Type ?u.53306
inst✝ : MulOneClass M
s✝ t : Set α
f✝ g✝ : α → M
a : α
s : Set α
f g : α → M
x✝ : α
h✝ : x✝ ∈ s
⊢ f x✝ * g x✝ = f x✝ * g x✝
Theorem: Finset.finite_toSet_toFinset
File: Mathlib/Data/Set/Finite.lean

tactic: ext
state_before: α : Type u
β : Type v
ι : Sort w
γ : Type x
s : Finset α
⊢ Finite.toFinset (_ : Set.Finite ↑s) = s

tactic: rw [Set.Finite.mem_toFinset, mem_coe]
state_before: case a
α : Type u
β : Type v
ι : Sort w
γ : Type x
s : Finset α
a✝ : α
⊢ a✝ ∈ Finite.toFinset (_ : Set.Finite ↑s) ↔ a✝ ∈ s
Theorem: Module.rank_le_one_iff_top_isPrincipal
File: Mathlib/LinearAlgebra/Dimension.lean

tactic: rw [← Submodule.rank_le_one_iff_isPrincipal, rank_top]
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.1083536
inst✝⁶ : DivisionRing K
inst✝⁵ : AddCommGroup V
inst✝⁴ : Module K V
inst✝³ : AddCommGroup V₁
inst✝² : Module K V₁
inst✝¹ : AddCommGroup V'
inst✝ : Module K V'
⊢ Module.rank K V ≤ 1 ↔ IsPrincipal ⊤
Theorem: CompositionSeries.append_natAdd
File: Mathlib/Order/JordanHolder.lean

tactic: rw [coe_append, append_natAdd_aux _ _ i]
state_before: X : Type u
inst✝¹ : Lattice X
inst✝ : JordanHolderLattice X
s₁ s₂ : CompositionSeries X
h : top s₁ = bot s₂
i : Fin s₂.length
⊢ series (append s₁ s₂ h) (↑Fin.castSucc (↑(Fin.natAdd s₁.length) i)) = series s₂ (↑Fin.castSucc i)
Theorem: mul_mem_ball_iff_norm
File: Mathlib/Analysis/Normed/Group/Basic.lean

tactic: rw [mem_ball_iff_norm'', mul_div_cancel''']
state_before: 𝓕 : Type ?u.741114
𝕜 : Type ?u.741117
α : Type ?u.741120
ι : Type ?u.741123
κ : Type ?u.741126
E : Type u_1
F : Type ?u.741132
G : Type ?u.741135
inst✝¹ : SeminormedCommGroup E
inst✝ : SeminormedCommGroup F
a a₁ a₂ b b₁ b₂ : E
r r₁ r₂ : ℝ
⊢ a * b ∈ ball a r ↔ ‖b‖ < r
Theorem: wellFounded_lt_exact_sequence
File: Mathlib/Order/ModularLattice.lean

tactic: simp only [Prod.lex_def, lt_iff_le_not_le, ← gci.l_le_l_iff, ← gi.u_le_u_iff, hf, hg,
  le_antisymm_iff]
state_before: α : Type u_3
inst✝³ : Lattice α
inst✝² : IsModularLattice α
x y z : α
β : Type u_1
γ : Type u_2
inst✝¹ : PartialOrder β
inst✝ : Preorder γ
h₁ : WellFounded fun x x_1 => x < x_1
h₂ : WellFounded fun x x_1 => x < x_1
K : α
f₁ : β → α
f₂ : α → β
g₁ : γ → α
g₂ : α → γ
gci : GaloisCoinsertion f₁ f₂
gi : GaloisInsertion g₂ g₁
hf : ∀ (a : α), f₁ (f₂ a) = a ⊓ K
hg : ∀ (a : α), g₁ (g₂ a) = a ⊔ K
A B : α
hAB : A < B
⊢ Prod.Lex (fun x x_1 => x < x_1) (fun x x_1 => x < x_1) (f₂ A, g₂ A) (f₂ B, g₂ B)

tactic: simp only [gci.l_le_l_iff, gi.u_le_u_iff, ← lt_iff_le_not_le, ← le_antisymm_iff]
state_before: α : Type u_3
inst✝³ : Lattice α
inst✝² : IsModularLattice α
x y z : α
β : Type u_1
γ : Type u_2
inst✝¹ : PartialOrder β
inst✝ : Preorder γ
h₁ : WellFounded fun x x_1 => x < x_1
h₂ : WellFounded fun x x_1 => x < x_1
K : α
f₁ : β → α
f₂ : α → β
g₁ : γ → α
g₂ : α → γ
gci : GaloisCoinsertion f₁ f₂
gi : GaloisInsertion g₂ g₁
hf : ∀ (a : α), f₁ (f₂ a) = a ⊓ K
hg : ∀ (a : α), g₁ (g₂ a) = a ⊔ K
A B : α
hAB : A < B
⊢ A ⊓ K ≤ B ⊓ K ∧ ¬B ⊓ K ≤ A ⊓ K ∨ (A ⊓ K ≤ B ⊓ K ∧ B ⊓ K ≤ A ⊓ K) ∧ A ⊔ K ≤ B ⊔ K ∧ ¬B ⊔ K ≤ A ⊔ K

tactic: cases' lt_or_eq_of_le (inf_le_inf_right K (le_of_lt hAB)) with h h
state_before: α : Type u_3
inst✝³ : Lattice α
inst✝² : IsModularLattice α
x y z : α
β : Type u_1
γ : Type u_2
inst✝¹ : PartialOrder β
inst✝ : Preorder γ
h₁ : WellFounded fun x x_1 => x < x_1
h₂ : WellFounded fun x x_1 => x < x_1
K : α
f₁ : β → α
f₂ : α → β
g₁ : γ → α
g₂ : α → γ
gci : GaloisCoinsertion f₁ f₂
gi : GaloisInsertion g₂ g₁
hf : ∀ (a : α), f₁ (f₂ a) = a ⊓ K
hg : ∀ (a : α), g₁ (g₂ a) = a ⊔ K
A B : α
hAB : A < B
⊢ A ⊓ K < B ⊓ K ∨ A ⊓ K = B ⊓ K ∧ A ⊔ K < B ⊔ K

tactic: exact Or.inl h
state_before: case inl
α : Type u_3
inst✝³ : Lattice α
inst✝² : IsModularLattice α
x y z : α
β : Type u_1
γ : Type u_2
inst✝¹ : PartialOrder β
inst✝ : Preorder γ
h₁ : WellFounded fun x x_1 => x < x_1
h₂ : WellFounded fun x x_1 => x < x_1
K : α
f₁ : β → α
f₂ : α → β
g₁ : γ → α
g₂ : α → γ
gci : GaloisCoinsertion f₁ f₂
gi : GaloisInsertion g₂ g₁
hf : ∀ (a : α), f₁ (f₂ a) = a ⊓ K
hg : ∀ (a : α), g₁ (g₂ a) = a ⊔ K
A B : α
hAB : A < B
h : A ⊓ K < B ⊓ K
⊢ A ⊓ K < B ⊓ K ∨ A ⊓ K = B ⊓ K ∧ A ⊔ K < B ⊔ K

tactic: exact Or.inr ⟨h, sup_lt_sup_of_lt_of_inf_le_inf hAB (le_of_eq h.symm)⟩
state_before: case inr
α : Type u_3
inst✝³ : Lattice α
inst✝² : IsModularLattice α
x y z : α
β : Type u_1
γ : Type u_2
inst✝¹ : PartialOrder β
inst✝ : Preorder γ
h₁ : WellFounded fun x x_1 => x < x_1
h₂ : WellFounded fun x x_1 => x < x_1
K : α
f₁ : β → α
f₂ : α → β
g₁ : γ → α
g₂ : α → γ
gci : GaloisCoinsertion f₁ f₂
gi : GaloisInsertion g₂ g₁
hf : ∀ (a : α), f₁ (f₂ a) = a ⊓ K
hg : ∀ (a : α), g₁ (g₂ a) = a ⊔ K
A B : α
hAB : A < B
h : A ⊓ K = B ⊓ K
⊢ A ⊓ K < B ⊓ K ∨ A ⊓ K = B ⊓ K ∧ A ⊔ K < B ⊔ K
Theorem: String.Iterator.ValidFor.toEnd'
File: Std/Data/String/Lemmas.lean

tactic: simp [Iterator.toEnd]
state_before: it : Iterator
⊢ ValidFor (List.reverse it.s.data) [] (Iterator.toEnd it)

tactic: exact .of_eq _ (by simp [List.reverseAux_eq]) (by simp [endPos, utf8ByteSize])
state_before: it : Iterator
⊢ ValidFor (List.reverse it.s.data) [] { s := it.s, i := endPos it.s }

tactic: simp [List.reverseAux_eq]
state_before: it : Iterator
⊢ { s := it.s, i := endPos it.s }.s.data = List.reverseAux (List.reverse it.s.data) []

tactic: simp [endPos, utf8ByteSize]
state_before: it : Iterator
⊢ { s := it.s, i := endPos it.s }.i.byteIdx = utf8Len (List.reverse it.s.data)
Theorem: Cardinal.bsup_lt_ord_of_isRegular
File: Mathlib/SetTheory/Cardinal/Cofinality.lean

tactic: rwa [hc.cof_eq]
state_before: α : Type ?u.160087
r : α → α → Prop
o : Ordinal
f : (a : Ordinal) → a < o → Ordinal
c : Cardinal
hc : IsRegular c
hι : card o < c
⊢ card o < Ordinal.cof (ord c)
Theorem: ContDiffBump.neg
File: Mathlib/Analysis/Calculus/BumpFunctionInner.lean

tactic: simp_rw [← zero_sub, f.sub, zero_add]
state_before: E : Type u_1
X : Type ?u.78048
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedSpace ℝ E
inst✝² : NormedAddCommGroup X
inst✝¹ : NormedSpace ℝ X
inst✝ : HasContDiffBump E
c : E
f✝ : ContDiffBump c
x✝ : E
n : ℕ∞
f : ContDiffBump 0
x : E
⊢ ↑f (-x) = ↑f x
Theorem: Monoid.image_closure
File: Mathlib/Deprecated/Submonoid.lean

tactic: rintro _ ⟨x, hx, rfl⟩
state_before: M : Type u_2
inst✝² : Monoid M
s✝ : Set M
A✝ : Type ?u.63949
inst✝¹ : AddMonoid A✝
t : Set A✝
A : Type u_1
inst✝ : Monoid A
f : M → A
hf : IsMonoidHom f
s : Set M
⊢ f '' Closure s ≤ Closure (f '' s)

tactic: induction' hx with z hz
state_before: case intro.intro
M : Type u_2
inst✝² : Monoid M
s✝ : Set M
A✝ : Type ?u.63949
inst✝¹ : AddMonoid A✝
t : Set A✝
A : Type u_1
inst✝ : Monoid A
f : M → A
hf : IsMonoidHom f
s : Set M
x : M
hx : x ∈ Closure s
⊢ f x ∈ Closure (f '' s)

tactic: solve_by_elim [subset_closure, Set.mem_image_of_mem]
state_before: case intro.intro.basic
M : Type u_2
inst✝² : Monoid M
s✝ : Set M
A✝ : Type ?u.63949
inst✝¹ : AddMonoid A✝
t : Set A✝
A : Type u_1
inst✝ : Monoid A
f : M → A
hf : IsMonoidHom f
s : Set M
x z : M
hz : z ∈ s
⊢ f z ∈ Closure (f '' s)

tactic: rw [hf.map_one]
state_before: case intro.intro.one
M : Type u_2
inst✝² : Monoid M
s✝ : Set M
A✝ : Type ?u.63949
inst✝¹ : AddMonoid A✝
t : Set A✝
A : Type u_1
inst✝ : Monoid A
f : M → A
hf : IsMonoidHom f
s : Set M
x : M
⊢ f 1 ∈ Closure (f '' s)

tactic: apply IsSubmonoid.one_mem (closure.isSubmonoid (f '' s))
state_before: case intro.intro.one
M : Type u_2
inst✝² : Monoid M
s✝ : Set M
A✝ : Type ?u.63949
inst✝¹ : AddMonoid A✝
t : Set A✝
A : Type u_1
inst✝ : Monoid A
f : M → A
hf : IsMonoidHom f
s : Set M
x : M
⊢ 1 ∈ Closure (f '' s)

tactic: rw [hf.map_mul]
state_before: case intro.intro.mul
M : Type u_2
inst✝² : Monoid M
s✝ : Set M
A✝ : Type ?u.63949
inst✝¹ : AddMonoid A✝
t : Set A✝
A : Type u_1
inst✝ : Monoid A
f : M → A
hf : IsMonoidHom f
s : Set M
x a✝² b✝ : M
a✝¹ : InClosure s a✝²
a✝ : InClosure s b✝
a_ih✝¹ : f a✝² ∈ Closure (f '' s)
a_ih✝ : f b✝ ∈ Closure (f '' s)
⊢ f (a✝² * b✝) ∈ Closure (f '' s)

tactic: solve_by_elim [(closure.isSubmonoid _).mul_mem]
state_before: case intro.intro.mul
M : Type u_2
inst✝² : Monoid M
s✝ : Set M
A✝ : Type ?u.63949
inst✝¹ : AddMonoid A✝
t : Set A✝
A : Type u_1
inst✝ : Monoid A
f : M → A
hf : IsMonoidHom f
s : Set M
x a✝² b✝ : M
a✝¹ : InClosure s a✝²
a✝ : InClosure s b✝
a_ih✝¹ : f a✝² ∈ Closure (f '' s)
a_ih✝ : f b✝ ∈ Closure (f '' s)
⊢ f a✝² * f b✝ ∈ Closure (f '' s)
Theorem: Set.Intersecting.disjoint_map_compl
File: Mathlib/Combinatorics/SetFamily/Intersecting.lean

tactic: rw [Finset.disjoint_left]
state_before: α : Type u_1
inst✝ : BooleanAlgebra α
s : Finset α
hs : Intersecting ↑s
⊢ Disjoint s (map { toFun := compl, inj' := (_ : Function.Injective compl) } s)

tactic: rintro x hx hxc
state_before: α : Type u_1
inst✝ : BooleanAlgebra α
s : Finset α
hs : Intersecting ↑s
⊢ ∀ ⦃a : α⦄, a ∈ s → ¬a ∈ map { toFun := compl, inj' := (_ : Function.Injective compl) } s

tactic: obtain ⟨x, hx', rfl⟩ := mem_map.mp hxc
state_before: α : Type u_1
inst✝ : BooleanAlgebra α
s : Finset α
hs : Intersecting ↑s
x : α
hx : x ∈ s
hxc : x ∈ map { toFun := compl, inj' := (_ : Function.Injective compl) } s
⊢ False

tactic: exact hs.not_compl_mem hx' hx
state_before: case intro.intro
α : Type u_1
inst✝ : BooleanAlgebra α
s : Finset α
hs : Intersecting ↑s
x : α
hx' : x ∈ s
hx : ↑{ toFun := compl, inj' := (_ : Function.Injective compl) } x ∈ s
hxc :
  ↑{ toFun := compl, inj' := (_ : Function.Injective compl) } x ∈
    map { toFun := compl, inj' := (_ : Function.Injective compl) } s
⊢ False