tasksource/leandojo huggingface dataset:
Theorem: HomologicalComplex.isZero_zero
File: Mathlib/Algebra/Homology/HomologicalComplex.lean

tactic: refine' ⟨fun X => ⟨⟨⟨0⟩, fun f => _⟩⟩, fun X => ⟨⟨⟨0⟩, fun f => _⟩⟩⟩
state_before: ι : Type u_1
V : Type u
inst✝² : Category V
inst✝¹ : HasZeroMorphisms V
c : ComplexShape ι
C : HomologicalComplex V c
inst✝ : HasZeroObject V
⊢ IsZero zero

tactic: all_goals
  ext
  dsimp [zero]
  apply Subsingleton.elim
state_before: case refine'_1
ι : Type u_1
V : Type u
inst✝² : Category V
inst✝¹ : HasZeroMorphisms V
c : ComplexShape ι
C : HomologicalComplex V c
inst✝ : HasZeroObject V
X : HomologicalComplex V c
f : zero ⟶ X
⊢ f = default

case refine'_2
ι : Type u_1
V : Type u
inst✝² : Category V
inst✝¹ : HasZeroMorphisms V
c : ComplexShape ι
C : HomologicalComplex V c
inst✝ : HasZeroObject V
X : HomologicalComplex V c
f : X ⟶ zero
⊢ f = default

tactic: ext
state_before: case refine'_2
ι : Type u_1
V : Type u
inst✝² : Category V
inst✝¹ : HasZeroMorphisms V
c : ComplexShape ι
C : HomologicalComplex V c
inst✝ : HasZeroObject V
X : HomologicalComplex V c
f : X ⟶ zero
⊢ f = default

tactic: dsimp [zero]
state_before: case refine'_2.h
ι : Type u_1
V : Type u
inst✝² : Category V
inst✝¹ : HasZeroMorphisms V
c : ComplexShape ι
C : HomologicalComplex V c
inst✝ : HasZeroObject V
X : HomologicalComplex V c
f : X ⟶ zero
i✝ : ι
⊢ Hom.f f i✝ = Hom.f default i✝

tactic: apply Subsingleton.elim
state_before: case refine'_2.h
ι : Type u_1
V : Type u
inst✝² : Category V
inst✝¹ : HasZeroMorphisms V
c : ComplexShape ι
C : HomologicalComplex V c
inst✝ : HasZeroObject V
X : HomologicalComplex V c
f : X ⟶ zero
i✝ : ι
⊢ Hom.f f i✝ = 0
Theorem: MeasureTheory.Integrable.induction
File: Mathlib/MeasureTheory/Function/SimpleFuncDenseLp.lean

tactic: simp only [← memℒp_one_iff_integrable] at *
state_before: α : Type u_1
β : Type ?u.3384233
ι : Type ?u.3384236
E : Type u_2
F : Type ?u.3384242
𝕜 : Type ?u.3384245
inst✝¹ : MeasurableSpace α
inst✝ : NormedAddCommGroup E
f : α → E
p : ℝ≥0∞
μ : Measure α
P : (α → E) → Prop
h_ind : ∀ (c : E) ⦃s : Set α⦄, MeasurableSet s → ↑↑μ s < ⊤ → P (indicator s fun x => c)
h_add : ∀ ⦃f g : α → E⦄, Disjoint (support f) (support g) → Integrable f → Integrable g → P f → P g → P (f + g)
h_closed : IsClosed {f | P ↑↑f}
h_ae : ∀ ⦃f g : α → E⦄, f =ᵐ[μ] g → Integrable f → P f → P g
⊢ ∀ ⦃f : α → E⦄, Integrable f → P f

tactic: exact Memℒp.induction one_ne_top (P := P) h_ind h_add h_closed h_ae
state_before: α : Type u_1
β : Type ?u.3384233
ι : Type ?u.3384236
E : Type u_2
F : Type ?u.3384242
𝕜 : Type ?u.3384245
inst✝¹ : MeasurableSpace α
inst✝ : NormedAddCommGroup E
f : α → E
p : ℝ≥0∞
μ : Measure α
P : (α → E) → Prop
h_ind : ∀ (c : E) ⦃s : Set α⦄, MeasurableSet s → ↑↑μ s < ⊤ → P (indicator s fun x => c)
h_closed : IsClosed {f | P ↑↑f}
h_add : ∀ ⦃f g : α → E⦄, Disjoint (support f) (support g) → Memℒp f 1 → Memℒp g 1 → P f → P g → P (f + g)
h_ae : ∀ ⦃f g : α → E⦄, f =ᵐ[μ] g → Memℒp f 1 → P f → P g
⊢ ∀ ⦃f : α → E⦄, Memℒp f 1 → P f
Theorem: LinearIndependent.insert
File: Mathlib/LinearAlgebra/LinearIndependent.lean

tactic: rw [← union_singleton]
state_before: ι : Type u'
ι' : Type ?u.1209871
R : Type ?u.1209874
K : Type u_1
M : Type ?u.1209880
M' : Type ?u.1209883
M'' : Type ?u.1209886
V : Type u
V' : Type ?u.1209891
inst✝⁴ : DivisionRing K
inst✝³ : AddCommGroup V
inst✝² : AddCommGroup V'
inst✝¹ : Module K V
inst✝ : Module K V'
v : ι → V
s t : Set V
x y z : V
hs : LinearIndependent K fun b => ↑b
hx : ¬x ∈ span K s
⊢ LinearIndependent K fun b => ↑b

tactic: have x0 : x ≠ 0 := mt (by rintro rfl; apply zero_mem (span K s)) hx
state_before: ι : Type u'
ι' : Type ?u.1209871
R : Type ?u.1209874
K : Type u_1
M : Type ?u.1209880
M' : Type ?u.1209883
M'' : Type ?u.1209886
V : Type u
V' : Type ?u.1209891
inst✝⁴ : DivisionRing K
inst✝³ : AddCommGroup V
inst✝² : AddCommGroup V'
inst✝¹ : Module K V
inst✝ : Module K V'
v : ι → V
s t : Set V
x y z : V
hs : LinearIndependent K fun b => ↑b
hx : ¬x ∈ span K s
⊢ LinearIndependent K fun b => ↑b

tactic: apply hs.union (linearIndependent_singleton x0)
state_before: ι : Type u'
ι' : Type ?u.1209871
R : Type ?u.1209874
K : Type u_1
M : Type ?u.1209880
M' : Type ?u.1209883
M'' : Type ?u.1209886
V : Type u
V' : Type ?u.1209891
inst✝⁴ : DivisionRing K
inst✝³ : AddCommGroup V
inst✝² : AddCommGroup V'
inst✝¹ : Module K V
inst✝ : Module K V'
v : ι → V
s t : Set V
x y z : V
hs : LinearIndependent K fun b => ↑b
hx : ¬x ∈ span K s
x0 : x ≠ 0
⊢ LinearIndependent K fun b => ↑b

tactic: rwa [disjoint_span_singleton' x0]
state_before: ι : Type u'
ι' : Type ?u.1209871
R : Type ?u.1209874
K : Type u_1
M : Type ?u.1209880
M' : Type ?u.1209883
M'' : Type ?u.1209886
V : Type u
V' : Type ?u.1209891
inst✝⁴ : DivisionRing K
inst✝³ : AddCommGroup V
inst✝² : AddCommGroup V'
inst✝¹ : Module K V
inst✝ : Module K V'
v : ι → V
s t : Set V
x y z : V
hs : LinearIndependent K fun b => ↑b
hx : ¬x ∈ span K s
x0 : x ≠ 0
⊢ Disjoint (span K s) (span K {x})

tactic: rintro rfl
state_before: ι : Type u'
ι' : Type ?u.1209871
R : Type ?u.1209874
K : Type u_1
M : Type ?u.1209880
M' : Type ?u.1209883
M'' : Type ?u.1209886
V : Type u
V' : Type ?u.1209891
inst✝⁴ : DivisionRing K
inst✝³ : AddCommGroup V
inst✝² : AddCommGroup V'
inst✝¹ : Module K V
inst✝ : Module K V'
v : ι → V
s t : Set V
x y z : V
hs : LinearIndependent K fun b => ↑b
hx : ¬x ∈ span K s
⊢ x = 0 → x ∈ span K s

tactic: apply zero_mem (span K s)
state_before: ι : Type u'
ι' : Type ?u.1209871
R : Type ?u.1209874
K : Type u_1
M : Type ?u.1209880
M' : Type ?u.1209883
M'' : Type ?u.1209886
V : Type u
V' : Type ?u.1209891
inst✝⁴ : DivisionRing K
inst✝³ : AddCommGroup V
inst✝² : AddCommGroup V'
inst✝¹ : Module K V
inst✝ : Module K V'
v : ι → V
s t : Set V
y z : V
hs : LinearIndependent K fun b => ↑b
hx : ¬0 ∈ span K s
⊢ 0 ∈ span K s
Theorem: Polynomial.eraseLead_add_of_natDegree_lt_left
File: Mathlib/Data/Polynomial/EraseLead.lean

tactic: ext n
state_before: R : Type u_1
inst✝ : Semiring R
f p q : R[X]
pq : natDegree q < natDegree p
⊢ eraseLead (p + q) = eraseLead p + q

tactic: by_cases nd : n = p.natDegree
state_before: case a
R : Type u_1
inst✝ : Semiring R
f p q : R[X]
pq : natDegree q < natDegree p
n : ℕ
⊢ coeff (eraseLead (p + q)) n = coeff (eraseLead p + q) n

tactic: rw [nd, eraseLead_coeff, if_pos (natDegree_add_eq_left_of_natDegree_lt pq).symm]
state_before: case pos
R : Type u_1
inst✝ : Semiring R
f p q : R[X]
pq : natDegree q < natDegree p
n : ℕ
nd : n = natDegree p
⊢ coeff (eraseLead (p + q)) n = coeff (eraseLead p + q) n

tactic: simpa using (coeff_eq_zero_of_natDegree_lt pq).symm
state_before: case pos
R : Type u_1
inst✝ : Semiring R
f p q : R[X]
pq : natDegree q < natDegree p
n : ℕ
nd : n = natDegree p
⊢ 0 = coeff (eraseLead p + q) (natDegree p)

tactic: rw [eraseLead_coeff, coeff_add, coeff_add, eraseLead_coeff, if_neg, if_neg nd]
state_before: case neg
R : Type u_1
inst✝ : Semiring R
f p q : R[X]
pq : natDegree q < natDegree p
n : ℕ
nd : ¬n = natDegree p
⊢ coeff (eraseLead (p + q)) n = coeff (eraseLead p + q) n

tactic: rintro rfl
state_before: case neg.hnc
R : Type u_1
inst✝ : Semiring R
f p q : R[X]
pq : natDegree q < natDegree p
n : ℕ
nd : ¬n = natDegree p
⊢ ¬n = natDegree (p + q)

tactic: exact nd (natDegree_add_eq_left_of_natDegree_lt pq)
state_before: case neg.hnc
R : Type u_1
inst✝ : Semiring R
f p q : R[X]
pq : natDegree q < natDegree p
nd : ¬natDegree (p + q) = natDegree p
⊢ False
Theorem: Polynomial.taylor_zero
File: Mathlib/Data/Polynomial/Taylor.lean

tactic: rw [taylor_zero', LinearMap.id_apply]
state_before: R : Type u_1
inst✝ : Semiring R
r : R
f✝ f : R[X]
⊢ ↑(taylor 0) f = f
Theorem: conformalAt_iff'
File: Mathlib/Analysis/Calculus/Conformal/InnerProduct.lean

tactic: rw [conformalAt_iff_isConformalMap_fderiv, isConformalMap_iff]
state_before: E : Type u_1
F : Type u_2
inst✝³ : NormedAddCommGroup E
inst✝² : NormedAddCommGroup F
inst✝¹ : InnerProductSpace ℝ E
inst✝ : InnerProductSpace ℝ F
f : E → F
x : E
⊢ ConformalAt f x ↔ ∃ c, 0 < c ∧ ∀ (u v : E), inner (↑(fderiv ℝ f x) u) (↑(fderiv ℝ f x) v) = c * inner u v
Theorem: Finset.prod_Ico_eq_mul_inv
File: Mathlib/Algebra/BigOperators/Intervals.lean

tactic: (rw [mul_comm]; exact prod_range_mul_prod_Ico f h)
state_before: α : Type u
β : Type v
γ : Type w
s₂ s₁ s : Finset α
a : α
g f✝ : α → β
inst✝¹ : CommMonoid β
δ : Type u_1
inst✝ : CommGroup δ
f : ℕ → δ
m n : ℕ
h : m ≤ n
⊢ (∏ k in Ico m n, f k) * ∏ k in range m, f k = ∏ k in range n, f k

tactic: rw [mul_comm]
state_before: α : Type u
β : Type v
γ : Type w
s₂ s₁ s : Finset α
a : α
g f✝ : α → β
inst✝¹ : CommMonoid β
δ : Type u_1
inst✝ : CommGroup δ
f : ℕ → δ
m n : ℕ
h : m ≤ n
⊢ (∏ k in Ico m n, f k) * ∏ k in range m, f k = ∏ k in range n, f k

tactic: exact prod_range_mul_prod_Ico f h
state_before: α : Type u
β : Type v
γ : Type w
s₂ s₁ s : Finset α
a : α
g f✝ : α → β
inst✝¹ : CommMonoid β
δ : Type u_1
inst✝ : CommGroup δ
f : ℕ → δ
m n : ℕ
h : m ≤ n
⊢ (∏ k in range m, f k) * ∏ k in Ico m n, f k = ∏ k in range n, f k
Theorem: PSigma.lex_iff
File: Mathlib/Data/Sigma/Lex.lean

tactic: constructor
state_before: ι : Sort u_1
α : ι → Sort u_2
r r₁ r₂ : ι → ι → Prop
s s₁ s₂ : (i : ι) → α i → α i → Prop
a b : (i : ι) ×' α i
⊢ Lex r s a b ↔ r a.fst b.fst ∨ ∃ h, s b.fst (h ▸ a.snd) b.snd

tactic: rintro (⟨a, b, hij⟩ | ⟨i, hab⟩)
state_before: case mp
ι : Sort u_1
α : ι → Sort u_2
r r₁ r₂ : ι → ι → Prop
s s₁ s₂ : (i : ι) → α i → α i → Prop
a b : (i : ι) ×' α i
⊢ Lex r s a b → r a.fst b.fst ∨ ∃ h, s b.fst (h ▸ a.snd) b.snd

tactic: exact Or.inl hij
state_before: case mp.left
ι : Sort u_1
α : ι → Sort u_2
r r₁ r₂ : ι → ι → Prop
s s₁ s₂ : (i : ι) → α i → α i → Prop
a₁✝ : ι
a : α a₁✝
a₂✝ : ι
b : α a₂✝
hij : r a₁✝ a₂✝
⊢ r { fst := a₁✝, snd := a }.fst { fst := a₂✝, snd := b }.fst ∨
    ∃ h, s { fst := a₂✝, snd := b }.fst (h ▸ { fst := a₁✝, snd := a }.snd) { fst := a₂✝, snd := b }.snd

tactic: exact Or.inr ⟨rfl, hab⟩
state_before: case mp.right
ι : Sort u_1
α : ι → Sort u_2
r r₁ r₂ : ι → ι → Prop
s s₁ s₂ : (i : ι) → α i → α i → Prop
i : ι
b₁✝ b₂✝ : α i
hab : s i b₁✝ b₂✝
⊢ r { fst := i, snd := b₁✝ }.fst { fst := i, snd := b₂✝ }.fst ∨
    ∃ h, s { fst := i, snd := b₂✝ }.fst (h ▸ { fst := i, snd := b₁✝ }.snd) { fst := i, snd := b₂✝ }.snd

tactic: obtain ⟨i, a⟩ := a
state_before: case mpr
ι : Sort u_1
α : ι → Sort u_2
r r₁ r₂ : ι → ι → Prop
s s₁ s₂ : (i : ι) → α i → α i → Prop
a b : (i : ι) ×' α i
⊢ (r a.fst b.fst ∨ ∃ h, s b.fst (h ▸ a.snd) b.snd) → Lex r s a b

tactic: obtain ⟨j, b⟩ := b
state_before: case mpr.mk
ι : Sort u_1
α : ι → Sort u_2
r r₁ r₂ : ι → ι → Prop
s s₁ s₂ : (i : ι) → α i → α i → Prop
b : (i : ι) ×' α i
i : ι
a : α i
⊢ (r { fst := i, snd := a }.fst b.fst ∨ ∃ h, s b.fst (h ▸ { fst := i, snd := a }.snd) b.snd) →
    Lex r s { fst := i, snd := a } b

tactic: dsimp only
state_before: case mpr.mk.mk
ι : Sort u_1
α : ι → Sort u_2
r r₁ r₂ : ι → ι → Prop
s s₁ s₂ : (i : ι) → α i → α i → Prop
i : ι
a : α i
j : ι
b : α j
⊢ (r { fst := i, snd := a }.fst { fst := j, snd := b }.fst ∨
      ∃ h, s { fst := j, snd := b }.fst (h ▸ { fst := i, snd := a }.snd) { fst := j, snd := b }.snd) →
    Lex r s { fst := i, snd := a } { fst := j, snd := b }

tactic: rintro (h | ⟨rfl, h⟩)
state_before: case mpr.mk.mk
ι : Sort u_1
α : ι → Sort u_2
r r₁ r₂ : ι → ι → Prop
s s₁ s₂ : (i : ι) → α i → α i → Prop
i : ι
a : α i
j : ι
b : α j
⊢ (r i j ∨ ∃ h, s j (h ▸ a) b) → Lex r s { fst := i, snd := a } { fst := j, snd := b }

tactic: exact Lex.left _ _ h
state_before: case mpr.mk.mk.inl
ι : Sort u_1
α : ι → Sort u_2
r r₁ r₂ : ι → ι → Prop
s s₁ s₂ : (i : ι) → α i → α i → Prop
i : ι
a : α i
j : ι
b : α j
h : r i j
⊢ Lex r s { fst := i, snd := a } { fst := j, snd := b }

tactic: exact Lex.right _ h
state_before: case mpr.mk.mk.inr.intro
ι : Sort u_1
α : ι → Sort u_2
r r₁ r₂ : ι → ι → Prop
s s₁ s₂ : (i : ι) → α i → α i → Prop
i : ι
a b : α i
h : s i ((_ : i = i) ▸ a) b
⊢ Lex r s { fst := i, snd := a } { fst := i, snd := b }
Theorem: MeasureTheory.hasFiniteIntegral_iff_norm
File: Mathlib/MeasureTheory/Function/L1Space.lean

tactic: simp only [HasFiniteIntegral, ofReal_norm_eq_coe_nnnorm]
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.699389
δ : Type ?u.699392
m : MeasurableSpace α
μ ν : Measure α
inst✝² : MeasurableSpace δ
inst✝¹ : NormedAddCommGroup β
inst✝ : NormedAddCommGroup γ
f : α → β
⊢ HasFiniteIntegral f ↔ (∫⁻ (a : α), ENNReal.ofReal ‖f a‖ ∂μ) < ⊤
Theorem: surjective_of_nonzero_of_finrank_eq_one
File: Mathlib/LinearAlgebra/FiniteDimensional.lean

tactic: change Surjective (f.restrictScalars K)
state_before: K : Type u
V : Type v
inst✝⁸ : DivisionRing K
inst✝⁷ : AddCommGroup V
inst✝⁶ : Module K V
W : Type u_1
A : Type u_2
inst✝⁵ : Semiring A
inst✝⁴ : Module A V
inst✝³ : AddCommGroup W
inst✝² : Module K W
inst✝¹ : Module A W
inst✝ : LinearMap.CompatibleSMul V W K A
h : finrank K W = 1
f : V →ₗ[A] W
w : f ≠ 0
⊢ Surjective ↑f

tactic: obtain ⟨v, n⟩ := FunLike.ne_iff.mp w
state_before: K : Type u
V : Type v
inst✝⁸ : DivisionRing K
inst✝⁷ : AddCommGroup V
inst✝⁶ : Module K V
W : Type u_1
A : Type u_2
inst✝⁵ : Semiring A
inst✝⁴ : Module A V
inst✝³ : AddCommGroup W
inst✝² : Module K W
inst✝¹ : Module A W
inst✝ : LinearMap.CompatibleSMul V W K A
h : finrank K W = 1
f : V →ₗ[A] W
w : f ≠ 0
⊢ Surjective ↑(↑K f)

tactic: intro z
state_before: case intro
K : Type u
V : Type v
inst✝⁸ : DivisionRing K
inst✝⁷ : AddCommGroup V
inst✝⁶ : Module K V
W : Type u_1
A : Type u_2
inst✝⁵ : Semiring A
inst✝⁴ : Module A V
inst✝³ : AddCommGroup W
inst✝² : Module K W
inst✝¹ : Module A W
inst✝ : LinearMap.CompatibleSMul V W K A
h : finrank K W = 1
f : V →ₗ[A] W
w : f ≠ 0
v : ?m.1001733
n : ↑f v ≠ ↑0 v
⊢ Surjective ↑(↑K f)

tactic: obtain ⟨c, rfl⟩ := (finrank_eq_one_iff_of_nonzero' (f v) n).mp h z
state_before: case intro
K : Type u
V : Type v
inst✝⁸ : DivisionRing K
inst✝⁷ : AddCommGroup V
inst✝⁶ : Module K V
W : Type u_1
A : Type u_2
inst✝⁵ : Semiring A
inst✝⁴ : Module A V
inst✝³ : AddCommGroup W
inst✝² : Module K W
inst✝¹ : Module A W
inst✝ : LinearMap.CompatibleSMul V W K A
h : finrank K W = 1
f : V →ₗ[A] W
w : f ≠ 0
v : ?m.1001733
n : ↑f v ≠ ↑0 v
z : W
⊢ ∃ a, ↑(↑K f) a = z

tactic: exact ⟨c • v, by simp⟩
state_before: case intro.intro
K : Type u
V : Type v
inst✝⁸ : DivisionRing K
inst✝⁷ : AddCommGroup V
inst✝⁶ : Module K V
W : Type u_1
A : Type u_2
inst✝⁵ : Semiring A
inst✝⁴ : Module A V
inst✝³ : AddCommGroup W
inst✝² : Module K W
inst✝¹ : Module A W
inst✝ : LinearMap.CompatibleSMul V W K A
h : finrank K W = 1
f : V →ₗ[A] W
w : f ≠ 0
v : V
n : ↑f v ≠ ↑0 v
c : K
⊢ ∃ a, ↑(↑K f) a = c • ↑f v

tactic: simp
state_before: K : Type u
V : Type v
inst✝⁸ : DivisionRing K
inst✝⁷ : AddCommGroup V
inst✝⁶ : Module K V
W : Type u_1
A : Type u_2
inst✝⁵ : Semiring A
inst✝⁴ : Module A V
inst✝³ : AddCommGroup W
inst✝² : Module K W
inst✝¹ : Module A W
inst✝ : LinearMap.CompatibleSMul V W K A
h : finrank K W = 1
f : V →ₗ[A] W
w : f ≠ 0
v : V
n : ↑f v ≠ ↑0 v
c : K
⊢ ↑(↑K f) (c • v) = c • ↑f v
Theorem: Ordnode.Sized.rotateL
File: Mathlib/Data/Ordmap/Ordset.lean

tactic: cases r
state_before: α : Type u_1
l : Ordnode α
x : α
r : Ordnode α
hl : Sized l
hr : Sized r
⊢ Sized (Ordnode.rotateL l x r)

tactic: rw [rotateL]
state_before: case node
α : Type u_1
l : Ordnode α
x : α
hl : Sized l
size✝ : ℕ
l✝ : Ordnode α
x✝ : α
r✝ : Ordnode α
hr : Sized (node size✝ l✝ x✝ r✝)
⊢ Sized (Ordnode.rotateL l x (node size✝ l✝ x✝ r✝))

tactic: split_ifs
state_before: case node
α : Type u_1
l : Ordnode α
x : α
hl : Sized l
size✝ : ℕ
l✝ : Ordnode α
x✝ : α
r✝ : Ordnode α
hr : Sized (node size✝ l✝ x✝ r✝)
⊢ Sized (if size l✝ < ratio * size r✝ then Ordnode.node3L l x l✝ x✝ r✝ else Ordnode.node4L l x l✝ x✝ r✝)

tactic: exact hl.node' hr
state_before: case nil
α : Type u_1
l : Ordnode α
x : α
hl : Sized l
hr : Sized nil
⊢ Sized (Ordnode.rotateL l x nil)

tactic: exact hl.node3L hr.2.1 hr.2.2
state_before: case node.inl
α : Type u_1
l : Ordnode α
x : α
hl : Sized l
size✝ : ℕ
l✝ : Ordnode α
x✝ : α
r✝ : Ordnode α
hr : Sized (node size✝ l✝ x✝ r✝)
h✝ : size l✝ < ratio * size r✝
⊢ Sized (Ordnode.node3L l x l✝ x✝ r✝)

tactic: exact hl.node4L hr.2.1 hr.2.2
state_before: case node.inr
α : Type u_1
l : Ordnode α
x : α
hl : Sized l
size✝ : ℕ
l✝ : Ordnode α
x✝ : α
r✝ : Ordnode α
hr : Sized (node size✝ l✝ x✝ r✝)
h✝ : ¬size l✝ < ratio * size r✝
⊢ Sized (Ordnode.node4L l x l✝ x✝ r✝)
Theorem: StarSubalgebra.iInf_toSubalgebra
File: Mathlib/Algebra/Star/Subalgebra.lean

tactic: simp
state_before: F : Type ?u.695010
R : Type u_2
A : Type u_3
B : Type ?u.695019
inst✝⁹ : CommSemiring R
inst✝⁸ : StarRing R
inst✝⁷ : Semiring A
inst✝⁶ : Algebra R A
inst✝⁵ : StarRing A
inst✝⁴ : StarModule R A
inst✝³ : Semiring B
inst✝² : Algebra R B
inst✝¹ : StarRing B
inst✝ : StarModule R B
ι : Sort u_1
S : ι → StarSubalgebra R A
⊢ ↑(⨅ (i : ι), S i).toSubalgebra = ↑(⨅ (i : ι), (S i).toSubalgebra)
Theorem: AddCommGroup.ModEq.sub_iff_right
File: Mathlib/Algebra/ModEq.lean

tactic: simp [sub_sub_sub_comm, hm, sub_smul, ModEq]
state_before: α : Type u_1
inst✝ : AddCommGroup α
p a a₁ a₂ b b₁ b₂ c : α
n : ℕ
z : ℤ
x✝ : a₂ ≡ b₂ [PMOD p]
m : ℤ
hm : b₂ - a₂ = m • p
⊢ (∃ b, b₁ - b₂ - (a₁ - a₂) = ↑(Equiv.subRight m).symm.symm b • p) ↔ a₁ ≡ b₁ [PMOD p]
Theorem: Finsupp.neLocus_sub_right
File: Mathlib/Data/Finsupp/NeLocus.lean

tactic: simpa only [sub_eq_add_neg] using neLocus_add_right _ _ _
state_before: α : Type u_1
M : Type ?u.30419
N : Type u_2
P : Type ?u.30425
inst✝² : DecidableEq α
inst✝¹ : DecidableEq N
inst✝ : AddGroup N
f f₁ f₂ g g₁ g₂ : α →₀ N
⊢ neLocus (f₁ - g) (f₂ - g) = neLocus f₁ f₂
Theorem: Finset.card_insert_le
File: Mathlib/Data/Finset/Card.lean

tactic: by_cases h : a ∈ s
state_before: α : Type u_1
β : Type ?u.4838
s✝ t : Finset α
a✝ b : α
inst✝ : DecidableEq α
a : α
s : Finset α
⊢ card (insert a s) ≤ card s + 1

tactic: rw [insert_eq_of_mem h]
state_before: case pos
α : Type u_1
β : Type ?u.4838
s✝ t : Finset α
a✝ b : α
inst✝ : DecidableEq α
a : α
s : Finset α
h : a ∈ s
⊢ card (insert a s) ≤ card s + 1

tactic: exact Nat.le_succ _
state_before: case pos
α : Type u_1
β : Type ?u.4838
s✝ t : Finset α
a✝ b : α
inst✝ : DecidableEq α
a : α
s : Finset α
h : a ∈ s
⊢ card s ≤ card s + 1

tactic: rw [card_insert_of_not_mem h]
state_before: case neg
α : Type u_1
β : Type ?u.4838
s✝ t : Finset α
a✝ b : α
inst✝ : DecidableEq α
a : α
s : Finset α
h : ¬a ∈ s
⊢ card (insert a s) ≤ card s + 1
Theorem: IsSubgroup.center_normal
File: Mathlib/Deprecated/Subgroup.lean

tactic: simp [center]
state_before: G : Type u_1
H : Type ?u.40911
A : Type ?u.40914
a a₁ a₂ b c : G
inst✝ : Group G
⊢ 1 ∈ center G

tactic: rw [← mul_assoc, mem_center.2 ha g, mul_assoc, mem_center.2 hb g, ← mul_assoc]
state_before: G : Type u_1
H : Type ?u.40911
A : Type ?u.40914
a a₁ a₂ b c : G
inst✝ : Group G
a✝ b✝ : G
ha : a✝ ∈ center G
hb : b✝ ∈ center G
g : G
⊢ g * (a✝ * b✝) = a✝ * b✝ * g

tactic: simp [ha g]
state_before: G : Type u_1
H : Type ?u.40911
A : Type ?u.40914
a✝ a₁ a₂ b c : G
inst✝ : Group G
a : G
ha : a ∈ center G
g : G
⊢ g * a⁻¹ = a⁻¹ * (g * a) * a⁻¹

tactic: rw [← mul_assoc, mul_assoc]
state_before: G : Type u_1
H : Type ?u.40911
A : Type ?u.40914
a✝ a₁ a₂ b c : G
inst✝ : Group G
a : G
ha : a ∈ center G
g : G
⊢ a⁻¹ * (g * a) * a⁻¹ = a⁻¹ * g

tactic: simp
state_before: G : Type u_1
H : Type ?u.40911
A : Type ?u.40914
a✝ a₁ a₂ b c : G
inst✝ : Group G
a : G
ha : a ∈ center G
g : G
⊢ a⁻¹ * g * (a * a⁻¹) = a⁻¹ * g

tactic: simp [ha g, mul_assoc]
state_before: G : Type u_1
H : Type ?u.40911
A : Type ?u.40914
a a₁ a₂ b c : G
inst✝ : Group G
n : G
ha : n ∈ center G
g h : G
⊢ h * (g * n * g⁻¹) = h * n

tactic: rw [ha h]
state_before: G : Type u_1
H : Type ?u.40911
A : Type ?u.40914
a a₁ a₂ b c : G
inst✝ : Group G
n : G
ha : n ∈ center G
g h : G
⊢ h * n = g * g⁻¹ * n * h

tactic: simp
state_before: G : Type u_1
H : Type ?u.40911
A : Type ?u.40914
a a₁ a₂ b c : G
inst✝ : Group G
n : G
ha : n ∈ center G
g h : G
⊢ n * h = g * g⁻¹ * n * h

tactic: rw [mul_assoc g, ha g⁻¹, ← mul_assoc]
state_before: G : Type u_1
H : Type ?u.40911
A : Type ?u.40914
a a₁ a₂ b c : G
inst✝ : Group G
n : G
ha : n ∈ center G
g h : G
⊢ g * g⁻¹ * n * h = g * n * g⁻¹ * h
Theorem: le_induced_generateFrom
File: Mathlib/Topology/Order.lean

tactic: rw [induced_generateFrom_eq]
state_before: α✝ : Type u
β✝ : Type v
α : Type u_1
β : Type u_2
t : TopologicalSpace α
b : Set (Set β)
f : α → β
h : ∀ (a : Set β), a ∈ b → IsOpen (f ⁻¹' a)
⊢ t ≤ induced f (generateFrom b)

tactic: apply le_generateFrom
state_before: α✝ : Type u
β✝ : Type v
α : Type u_1
β : Type u_2
t : TopologicalSpace α
b : Set (Set β)
f : α → β
h : ∀ (a : Set β), a ∈ b → IsOpen (f ⁻¹' a)
⊢ t ≤ generateFrom (preimage f '' b)

tactic: simp only [mem_image, and_imp, forall_apply_eq_imp_iff₂, exists_imp]
state_before: case h
α✝ : Type u
β✝ : Type v
α : Type u_1
β : Type u_2
t : TopologicalSpace α
b : Set (Set β)
f : α → β
h : ∀ (a : Set β), a ∈ b → IsOpen (f ⁻¹' a)
⊢ ∀ (s : Set α), s ∈ preimage f '' b → IsOpen s

tactic: exact h
state_before: case h
α✝ : Type u
β✝ : Type v
α : Type u_1
β : Type u_2
t : TopologicalSpace α
b : Set (Set β)
f : α → β
h : ∀ (a : Set β), a ∈ b → IsOpen (f ⁻¹' a)
⊢ ∀ (a : Set β), a ∈ b → IsOpen (f ⁻¹' a)
Theorem: NonUnitalSubsemiring.closure_addSubmonoid_closure
File: Mathlib/RingTheory/NonUnitalSubsemiring/Basic.lean

tactic: ext x
state_before: R : Type u
S : Type v
T : Type w
inst✝² : NonUnitalNonAssocSemiring R
M : Subsemigroup R
inst✝¹ : NonUnitalNonAssocSemiring S
inst✝ : NonUnitalNonAssocSemiring T
s : Set R
⊢ closure ↑(AddSubmonoid.closure s) = closure s

tactic: refine' ⟨fun hx => _, fun hx => closure_mono AddSubmonoid.subset_closure hx⟩
state_before: case h
R : Type u
S : Type v
T : Type w
inst✝² : NonUnitalNonAssocSemiring R
M : Subsemigroup R
inst✝¹ : NonUnitalNonAssocSemiring S
inst✝ : NonUnitalNonAssocSemiring T
s : Set R
x : R
⊢ x ∈ closure ↑(AddSubmonoid.closure s) ↔ x ∈ closure s

tactic: rintro - ⟨H, rfl⟩
state_before: case h
R : Type u
S : Type v
T : Type w
inst✝² : NonUnitalNonAssocSemiring R
M : Subsemigroup R
inst✝¹ : NonUnitalNonAssocSemiring S
inst✝ : NonUnitalNonAssocSemiring T
s : Set R
x : R
hx : x ∈ closure ↑(AddSubmonoid.closure s)
⊢ x ∈ closure s

tactic: rintro - ⟨J, rfl⟩
state_before: case h.intro
R : Type u
S : Type v
T : Type w
inst✝² : NonUnitalNonAssocSemiring R
M : Subsemigroup R
inst✝¹ : NonUnitalNonAssocSemiring S
inst✝ : NonUnitalNonAssocSemiring T
s : Set R
x : R
hx : x ∈ closure ↑(AddSubmonoid.closure s)
H : NonUnitalSubsemiring R
⊢ x ∈ (fun t => ⋂ (_ : t ∈ {S | s ⊆ ↑S}), ↑t) H

tactic: refine' (AddSubmonoid.mem_closure.mp (mem_closure_iff.mp hx)) H.toAddSubmonoid fun y hy => _
state_before: case h.intro.intro
R : Type u
S : Type v
T : Type w
inst✝² : NonUnitalNonAssocSemiring R
M : Subsemigroup R
inst✝¹ : NonUnitalNonAssocSemiring S
inst✝ : NonUnitalNonAssocSemiring T
s : Set R
x : R
hx : x ∈ closure ↑(AddSubmonoid.closure s)
H : NonUnitalSubsemiring R
J : H ∈ {S | s ⊆ ↑S}
⊢ x ∈ (fun h => ↑H) J

tactic: refine' (Subsemigroup.mem_closure.mp hy) H.toSubsemigroup fun z hz => _
state_before: case h.intro.intro
R : Type u
S : Type v
T : Type w
inst✝² : NonUnitalNonAssocSemiring R
M : Subsemigroup R
inst✝¹ : NonUnitalNonAssocSemiring S
inst✝ : NonUnitalNonAssocSemiring T
s : Set R
x : R
hx : x ∈ closure ↑(AddSubmonoid.closure s)
H : NonUnitalSubsemiring R
J : H ∈ {S | s ⊆ ↑S}
y : R
hy : y ∈ ↑(Subsemigroup.closure ↑(AddSubmonoid.closure s))
⊢ y ∈ ↑H.toAddSubmonoid

tactic: exact (AddSubmonoid.mem_closure.mp hz) H.toAddSubmonoid fun w hw => J hw
state_before: case h.intro.intro
R : Type u
S : Type v
T : Type w
inst✝² : NonUnitalNonAssocSemiring R
M : Subsemigroup R
inst✝¹ : NonUnitalNonAssocSemiring S
inst✝ : NonUnitalNonAssocSemiring T
s : Set R
x : R
hx : x ∈ closure ↑(AddSubmonoid.closure s)
H : NonUnitalSubsemiring R
J : H ∈ {S | s ⊆ ↑S}
y : R
hy : y ∈ ↑(Subsemigroup.closure ↑(AddSubmonoid.closure s))
z : R
hz : z ∈ ↑(AddSubmonoid.closure s)
⊢ z ∈ ↑(toSubsemigroup H)
Theorem: Set.image_compl_subset
File: Mathlib/Data/Set/Image.lean

tactic: simp [disjoint_iff_inf_le, ←image_inter H]
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.45893
ι : Sort ?u.45896
ι' : Sort ?u.45899
f✝ : α → β
s✝ t : Set α
f : α → β
s : Set α
H : Injective f
⊢ Disjoint (f '' s) (f '' sᶜ)
Theorem: Nat.bit0_mod_bit0
File: Mathlib/Data/Nat/Parity.lean

tactic: rw [bit0_eq_two_mul n, bit0_eq_two_mul m, bit0_eq_two_mul (n % m), Nat.mul_mod_mul_left]
state_before: m n : ℕ
⊢ bit0 n % bit0 m = bit0 (n % m)