tasksource/leandojo huggingface dataset:
Theorem: MeasureTheory.Set.mulIndicator_ae_eq_one
File: Mathlib/MeasureTheory/Measure/MeasureSpaceDef.lean

tactic: simpa [Filter.EventuallyEq, ae_iff] using h
state_before: α : Type u_2
β : Type ?u.132859
γ : Type ?u.132862
δ : Type ?u.132865
ι : Type ?u.132868
inst✝¹ : MeasurableSpace α
μ μ₁ μ₂ : Measure α
s✝ s₁ s₂ t : Set α
M : Type u_1
inst✝ : One M
f : α → M
s : Set α
h : mulIndicator s f =ᵐ[μ] 1
⊢ ↑↑μ (s ∩ mulSupport f) = 0
Theorem: Nat.div_eq
File: src/lean/Init/Data/Nat/Div.lean

tactic: show Nat.div x y = _
state_before: x y : Nat
⊢ x / y = ite (0 < y ∧ y ≤ x) ((x - y) / y + 1) 0

tactic: rw [Nat.div]
state_before: x y : Nat
⊢ Nat.div x y = ite (0 < y ∧ y ≤ x) ((x - y) / y + 1) 0

tactic: rfl
state_before: x y : Nat
⊢ ite (0 < y ∧ y ≤ x) (Nat.div (x - y) y + 1) 0 = ite (0 < y ∧ y ≤ x) ((x - y) / y + 1) 0
Theorem: MvPolynomial.degrees_map
File: Mathlib/Data/MvPolynomial/Variables.lean

tactic: classical
dsimp only [degrees]
apply Multiset.subset_of_le
apply Finset.sup_mono
apply MvPolynomial.support_map_subset
state_before: R : Type u
S : Type v
σ : Type u_1
τ : Type ?u.52567
r : R
e : ℕ
n m : σ
s : σ →₀ ℕ
inst✝¹ : CommSemiring R
p✝ q : MvPolynomial σ R
inst✝ : CommSemiring S
p : MvPolynomial σ R
f : R →+* S
⊢ degrees (↑(map f) p) ⊆ degrees p

tactic: dsimp only [degrees]
state_before: R : Type u
S : Type v
σ : Type u_1
τ : Type ?u.52567
r : R
e : ℕ
n m : σ
s : σ →₀ ℕ
inst✝¹ : CommSemiring R
p✝ q : MvPolynomial σ R
inst✝ : CommSemiring S
p : MvPolynomial σ R
f : R →+* S
⊢ degrees (↑(map f) p) ⊆ degrees p

tactic: apply Multiset.subset_of_le
state_before: R : Type u
S : Type v
σ : Type u_1
τ : Type ?u.52567
r : R
e : ℕ
n m : σ
s : σ →₀ ℕ
inst✝¹ : CommSemiring R
p✝ q : MvPolynomial σ R
inst✝ : CommSemiring S
p : MvPolynomial σ R
f : R →+* S
⊢ (Finset.sup (support (↑(map f) p)) fun s => ↑toMultiset s) ⊆ Finset.sup (support p) fun s => ↑toMultiset s

tactic: apply Finset.sup_mono
state_before: case a
R : Type u
S : Type v
σ : Type u_1
τ : Type ?u.52567
r : R
e : ℕ
n m : σ
s : σ →₀ ℕ
inst✝¹ : CommSemiring R
p✝ q : MvPolynomial σ R
inst✝ : CommSemiring S
p : MvPolynomial σ R
f : R →+* S
⊢ (Finset.sup (support (↑(map f) p)) fun s => ↑toMultiset s) ≤ Finset.sup (support p) fun s => ↑toMultiset s

tactic: apply MvPolynomial.support_map_subset
state_before: case a.h
R : Type u
S : Type v
σ : Type u_1
τ : Type ?u.52567
r : R
e : ℕ
n m : σ
s : σ →₀ ℕ
inst✝¹ : CommSemiring R
p✝ q : MvPolynomial σ R
inst✝ : CommSemiring S
p : MvPolynomial σ R
f : R →+* S
⊢ support (↑(map f) p) ⊆ support p
Theorem: Real.sin_pi_div_two_sub
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Basic.lean

tactic: simp [sub_eq_add_neg, sin_add]
state_before: x : ℝ
⊢ sin (π / 2 - x) = cos x
Theorem: AddCommGroupCat.image.fac
File: Mathlib/Algebra/Category/GroupCat/Images.lean

tactic: ext
state_before: G H : AddCommGroupCat
f : G ⟶ H
⊢ factorThruImage f ≫ ι f = f

tactic: rfl
state_before: case w
G H : AddCommGroupCat
f : G ⟶ H
x✝ : ↑G
⊢ ↑(factorThruImage f ≫ ι f) x✝ = ↑f x✝
Theorem: AddCircle.finite_setOf_add_order_eq
File: Mathlib/Topology/Instances/AddCircle.lean

tactic: simpa only [coe_setOf, card_addOrderOf_eq_totient p] using (Nat.totient_pos hn).ne'
state_before: 𝕜 : Type u_1
B : Type ?u.298327
inst✝² : LinearOrderedField 𝕜
inst✝¹ : TopologicalSpace 𝕜
inst✝ : OrderTopology 𝕜
p q : 𝕜
hp : Fact (0 < p)
n : ℕ
hn : 0 < n
⊢ Nat.card ↑{u | addOrderOf u = n} ≠ 0
Theorem: Rel.preimage_univ
File: Mathlib/Data/Rel.lean

tactic: rw [preimage, image_univ, codom_inv]
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.19926
r : Rel α β
⊢ preimage r Set.univ = dom r
Theorem: CategoryTheory.Presieve.FamilyOfElements.comp_of_compatible
File: Mathlib/CategoryTheory/Sites/SheafOfTypes.lean

tactic: simpa using t (𝟙 _) g (S.downward_closed hf g) hf (id_comp _)
state_before: C : Type u₁
inst✝ : Category C
P Q U : Cᵒᵖ ⥤ Type w
X Y : C
S✝ : Sieve X
R : Presieve X
J J₂ : GrothendieckTopology C
S : Sieve X
x : FamilyOfElements P S.arrows
t : Compatible x
f : Y ⟶ X
hf : S.arrows f
Z : C
g : Z ⟶ Y
⊢ x (g ≫ f) (_ : S.arrows (g ≫ f)) = P.map g.op (x f hf)
Theorem: Set.Nontrivial.ne_singleton
File: Mathlib/Data/Set/Basic.lean

tactic: rw [H] at hs
state_before: α : Type u
β : Type v
γ : Type w
ι : Sort x
a b : α
s s₁ s₂ t t₁ t₂ u : Set α
x : α
hs : Set.Nontrivial s
H : s = {x}
⊢ False

tactic: exact not_nontrivial_singleton hs
state_before: α : Type u
β : Type v
γ : Type w
ι : Sort x
a b : α
s s₁ s₂ t t₁ t₂ u : Set α
x : α
hs : Set.Nontrivial {x}
H : s = {x}
⊢ False
Theorem: Cardinal.mk_bounded_set_le
File: Mathlib/SetTheory/Cardinal/Ordinal.lean

tactic: trans #{ t : Set (Sum (ULift.{u} ℕ) α) // (#t) ≤ c }
state_before: α : Type u
c : Cardinal
⊢ (#{ t // (#↑t) ≤ c }) ≤ max (#α) ℵ₀ ^ c

tactic: apply (mk_bounded_set_le_of_infinite (Sum (ULift.{u} ℕ) α) c).trans
state_before: α : Type u
c : Cardinal
⊢ (#{ t // (#↑t) ≤ c }) ≤ max (#α) ℵ₀ ^ c

tactic: rw [max_comm, ← add_eq_max] <;> rfl
state_before: α : Type u
c : Cardinal
⊢ (#ULift ℕ ⊕ α) ^ c ≤ max (#α) ℵ₀ ^ c

tactic: refine' ⟨Embedding.subtypeMap _ _⟩
state_before: α : Type u
c : Cardinal
⊢ (#{ t // (#↑t) ≤ c }) ≤ (#{ t // (#↑t) ≤ c })

tactic: apply Embedding.image
state_before: case refine'_1
α : Type u
c : Cardinal
⊢ Set α ↪ Set (ULift ℕ ⊕ α)

case refine'_2
α : Type u
c : Cardinal
⊢ ∀ ⦃x : Set α⦄, (#↑x) ≤ c → (#↑(↑?refine'_1 x)) ≤ c

tactic: use Sum.inr
state_before: case refine'_1.f
α : Type u
c : Cardinal
⊢ α ↪ ULift ℕ ⊕ α

case refine'_2
α : Type u
c : Cardinal
⊢ ∀ ⦃x : Set α⦄, (#↑x) ≤ c → (#↑(↑(Embedding.image ?refine'_1.f) x)) ≤ c

tactic: apply Sum.inr.inj
state_before: case refine'_1.f
α : Type u
c : Cardinal
⊢ Injective Sum.inr

case refine'_2
α : Type u
c : Cardinal
⊢ ∀ ⦃x : Set α⦄, (#↑x) ≤ c → (#↑(↑(Embedding.image { toFun := Sum.inr, inj' := ?refine'_1.f }) x)) ≤ c

tactic: intro s hs
state_before: case refine'_2
α : Type u
c : Cardinal
⊢ ∀ ⦃x : Set α⦄,
    (#↑x) ≤ c →
      (#↑(↑(Embedding.image
                  { toFun := Sum.inr, inj' := (_ : ∀ {val val_1 : α}, Sum.inr val = Sum.inr val_1 → val = val_1) })
              x)) ≤
        c

tactic: exact mk_image_le.trans hs
state_before: case refine'_2
α : Type u
c : Cardinal
s : Set α
hs : (#↑s) ≤ c
⊢ (#↑(↑(Embedding.image
              { toFun := Sum.inr, inj' := (_ : ∀ {val val_1 : α}, Sum.inr val = Sum.inr val_1 → val = val_1) })
          s)) ≤
    c
Theorem: Basis.total_repr
File: Mathlib/LinearAlgebra/Basis.lean

tactic: rw [← b.coe_repr_symm]
state_before: ι : Type u_2
ι' : Type ?u.52430
R : Type u_3
R₂ : Type ?u.52436
K : Type ?u.52439
M : Type u_1
M' : Type ?u.52445
M'' : Type ?u.52448
V : Type u
V' : Type ?u.52453
inst✝⁴ : Semiring R
inst✝³ : AddCommMonoid M
inst✝² : Module R M
inst✝¹ : AddCommMonoid M'
inst✝ : Module R M'
b b₁ : Basis ι R M
i : ι
c : R
x : M
⊢ ↑(Finsupp.total ι M R ↑b) (↑b.repr x) = x

tactic: exact b.repr.symm_apply_apply x
state_before: ι : Type u_2
ι' : Type ?u.52430
R : Type u_3
R₂ : Type ?u.52436
K : Type ?u.52439
M : Type u_1
M' : Type ?u.52445
M'' : Type ?u.52448
V : Type u
V' : Type ?u.52453
inst✝⁴ : Semiring R
inst✝³ : AddCommMonoid M
inst✝² : Module R M
inst✝¹ : AddCommMonoid M'
inst✝ : Module R M'
b b₁ : Basis ι R M
i : ι
c : R
x : M
⊢ ↑↑(LinearEquiv.symm b.repr) (↑b.repr x) = x
Theorem: real_inner_mul_inner_self_le
File: Mathlib/Analysis/InnerProductSpace/Basic.lean

tactic: rw [real_inner_comm y, ← norm_mul]
state_before: 𝕜 : Type ?u.1881062
E : Type ?u.1881065
F : Type u_1
inst✝⁴ : IsROrC 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : NormedAddCommGroup F
inst✝ : InnerProductSpace ℝ F
dec_E : DecidableEq E
x y : F
⊢ inner x y * inner x y ≤ ‖inner x y‖ * ‖inner y x‖

tactic: exact le_abs_self _
state_before: 𝕜 : Type ?u.1881062
E : Type ?u.1881065
F : Type u_1
inst✝⁴ : IsROrC 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : NormedAddCommGroup F
inst✝ : InnerProductSpace ℝ F
dec_E : DecidableEq E
x y : F
⊢ inner y x * inner y x ≤ ‖inner y x * inner y x‖
Theorem: CategoryTheory.Limits.IsLimit.hom_ext
File: Mathlib/CategoryTheory/Limits/IsLimit.lean

tactic: rw [h.hom_lift f, h.hom_lift f']
state_before: J : Type u₁
inst✝² : Category J
K : Type u₂
inst✝¹ : Category K
C : Type u₃
inst✝ : Category C
F : J ⥤ C
t : Cone F
h : IsLimit t
W : C
f f' : W ⟶ t.pt
w : ∀ (j : J), f ≫ t.π.app j = f' ≫ t.π.app j
⊢ f = f'

tactic: congr
state_before: J : Type u₁
inst✝² : Category J
K : Type u₂
inst✝¹ : Category K
C : Type u₃
inst✝ : Category C
F : J ⥤ C
t : Cone F
h : IsLimit t
W : C
f f' : W ⟶ t.pt
w : ∀ (j : J), f ≫ t.π.app j = f' ≫ t.π.app j
⊢ lift h { pt := W, π := NatTrans.mk fun b => f ≫ t.π.app b } =
    lift h { pt := W, π := NatTrans.mk fun b => f' ≫ t.π.app b }

tactic: exact funext w
state_before: case h.e_8.h.e_π.e_app
J : Type u₁
inst✝² : Category J
K : Type u₂
inst✝¹ : Category K
C : Type u₃
inst✝ : Category C
F : J ⥤ C
t : Cone F
h : IsLimit t
W : C
f f' : W ⟶ t.pt
w : ∀ (j : J), f ≫ t.π.app j = f' ≫ t.π.app j
⊢ (fun b => f ≫ t.π.app b) = fun b => f' ≫ t.π.app b
Theorem: smul_le_smul_of_nonneg
File: Mathlib/Algebra/Order/SMul.lean

tactic: rcases h₁.eq_or_lt with (rfl | hab)
state_before: ι : Type ?u.20016
𝕜 : Type ?u.20019
R : Type u_2
M : Type u_1
N : Type ?u.20028
inst✝³ : OrderedSemiring R
inst✝² : OrderedAddCommMonoid M
inst✝¹ : SMulWithZero R M
inst✝ : OrderedSMul R M
s : Set M
a b : M
c : R
h₁ : a ≤ b
h₂ : 0 ≤ c
⊢ c • a ≤ c • b

tactic: rfl
state_before: case inl
ι : Type ?u.20016
𝕜 : Type ?u.20019
R : Type u_2
M : Type u_1
N : Type ?u.20028
inst✝³ : OrderedSemiring R
inst✝² : OrderedAddCommMonoid M
inst✝¹ : SMulWithZero R M
inst✝ : OrderedSMul R M
s : Set M
a : M
c : R
h₂ : 0 ≤ c
h₁ : a ≤ a
⊢ c • a ≤ c • a

tactic: rcases h₂.eq_or_lt with (rfl | hc)
state_before: case inr
ι : Type ?u.20016
𝕜 : Type ?u.20019
R : Type u_2
M : Type u_1
N : Type ?u.20028
inst✝³ : OrderedSemiring R
inst✝² : OrderedAddCommMonoid M
inst✝¹ : SMulWithZero R M
inst✝ : OrderedSMul R M
s : Set M
a b : M
c : R
h₁ : a ≤ b
h₂ : 0 ≤ c
hab : a < b
⊢ c • a ≤ c • b

tactic: rw [zero_smul, zero_smul]
state_before: case inr.inl
ι : Type ?u.20016
𝕜 : Type ?u.20019
R : Type u_2
M : Type u_1
N : Type ?u.20028
inst✝³ : OrderedSemiring R
inst✝² : OrderedAddCommMonoid M
inst✝¹ : SMulWithZero R M
inst✝ : OrderedSMul R M
s : Set M
a b : M
h₁ : a ≤ b
hab : a < b
h₂ : 0 ≤ 0
⊢ 0 • a ≤ 0 • b

tactic: exact (smul_lt_smul_of_pos hab hc).le
state_before: case inr.inr
ι : Type ?u.20016
𝕜 : Type ?u.20019
R : Type u_2
M : Type u_1
N : Type ?u.20028
inst✝³ : OrderedSemiring R
inst✝² : OrderedAddCommMonoid M
inst✝¹ : SMulWithZero R M
inst✝ : OrderedSMul R M
s : Set M
a b : M
c : R
h₁ : a ≤ b
h₂ : 0 ≤ c
hab : a < b
hc : 0 < c
⊢ c • a ≤ c • b
Theorem: mulRothNumber_map_mul_right
File: Mathlib/Combinatorics/Additive/SalemSpencer.lean

tactic: rw [← mul_left_embedding_eq_mul_right_embedding, mulRothNumber_map_mul_left s a]
state_before: F : Type ?u.148022
α : Type u_1
β : Type ?u.148028
𝕜 : Type ?u.148031
E : Type ?u.148034
inst✝¹ : DecidableEq α
inst✝ : CancelCommMonoid α
s : Finset α
a : α
⊢ ↑mulRothNumber (map (mulRightEmbedding a) s) = ↑mulRothNumber s
Theorem: Basis.noZeroSMulDivisors
File: Mathlib/LinearAlgebra/Basis.lean

tactic: exact or_iff_not_imp_right.mpr fun hx => by
  rw [← b.total_repr x, ← LinearMap.map_smul] at hcx
  have := linearIndependent_iff.mp b.linearIndependent (c • b.repr x) hcx
  rw [smul_eq_zero] at this
  exact this.resolve_right fun hr => hx (b.repr.map_eq_zero_iff.mp hr)
state_before: ι : Type u_2
ι' : Type ?u.592022
R : Type u_1
R₂ : Type ?u.592028
K : Type ?u.592031
M : Type u_3
M' : Type ?u.592037
M'' : Type ?u.592040
V : Type u
V' : Type ?u.592045
inst✝⁵ : Semiring R
inst✝⁴ : AddCommMonoid M
inst✝³ : Module R M
inst✝² : AddCommMonoid M'
inst✝¹ : Module R M'
b✝ b₁ : Basis ι R M
i : ι
c✝ : R
x✝ : M
inst✝ : NoZeroDivisors R
b : Basis ι R M
c : R
x : M
hcx : c • x = 0
⊢ c = 0 ∨ x = 0

tactic: rw [← b.total_repr x, ← LinearMap.map_smul] at hcx
state_before: ι : Type u_2
ι' : Type ?u.592022
R : Type u_1
R₂ : Type ?u.592028
K : Type ?u.592031
M : Type u_3
M' : Type ?u.592037
M'' : Type ?u.592040
V : Type u
V' : Type ?u.592045
inst✝⁵ : Semiring R
inst✝⁴ : AddCommMonoid M
inst✝³ : Module R M
inst✝² : AddCommMonoid M'
inst✝¹ : Module R M'
b✝ b₁ : Basis ι R M
i : ι
c✝ : R
x✝ : M
inst✝ : NoZeroDivisors R
b : Basis ι R M
c : R
x : M
hcx : c • x = 0
hx : ¬x = 0
⊢ c = 0

tactic: have := linearIndependent_iff.mp b.linearIndependent (c • b.repr x) hcx
state_before: ι : Type u_2
ι' : Type ?u.592022
R : Type u_1
R₂ : Type ?u.592028
K : Type ?u.592031
M : Type u_3
M' : Type ?u.592037
M'' : Type ?u.592040
V : Type u
V' : Type ?u.592045
inst✝⁵ : Semiring R
inst✝⁴ : AddCommMonoid M
inst✝³ : Module R M
inst✝² : AddCommMonoid M'
inst✝¹ : Module R M'
b✝ b₁ : Basis ι R M
i : ι
c✝ : R
x✝ : M
inst✝ : NoZeroDivisors R
b : Basis ι R M
c : R
x : M
hcx : ↑(Finsupp.total ι M R ↑b) (c • ↑b.repr x) = 0
hx : ¬x = 0
⊢ c = 0

tactic: rw [smul_eq_zero] at this
state_before: ι : Type u_2
ι' : Type ?u.592022
R : Type u_1
R₂ : Type ?u.592028
K : Type ?u.592031
M : Type u_3
M' : Type ?u.592037
M'' : Type ?u.592040
V : Type u
V' : Type ?u.592045
inst✝⁵ : Semiring R
inst✝⁴ : AddCommMonoid M
inst✝³ : Module R M
inst✝² : AddCommMonoid M'
inst✝¹ : Module R M'
b✝ b₁ : Basis ι R M
i : ι
c✝ : R
x✝ : M
inst✝ : NoZeroDivisors R
b : Basis ι R M
c : R
x : M
hcx : ↑(Finsupp.total ι M R ↑b) (c • ↑b.repr x) = 0
hx : ¬x = 0
this : c • ↑b.repr x = 0
⊢ c = 0

tactic: exact this.resolve_right fun hr => hx (b.repr.map_eq_zero_iff.mp hr)
state_before: ι : Type u_2
ι' : Type ?u.592022
R : Type u_1
R₂ : Type ?u.592028
K : Type ?u.592031
M : Type u_3
M' : Type ?u.592037
M'' : Type ?u.592040
V : Type u
V' : Type ?u.592045
inst✝⁵ : Semiring R
inst✝⁴ : AddCommMonoid M
inst✝³ : Module R M
inst✝² : AddCommMonoid M'
inst✝¹ : Module R M'
b✝ b₁ : Basis ι R M
i : ι
c✝ : R
x✝ : M
inst✝ : NoZeroDivisors R
b : Basis ι R M
c : R
x : M
hcx : ↑(Finsupp.total ι M R ↑b) (c • ↑b.repr x) = 0
hx : ¬x = 0
this : c = 0 ∨ ↑b.repr x = 0
⊢ c = 0
Theorem: Rat.div_num_den
File: Mathlib/Data/Rat/Defs.lean

tactic: have hr' : r = 0 := zero_of_num_zero hr
state_before: a b c q r : ℚ
hr : r.num = 0
⊢ q / r = q.num * ↑r.den /. (↑q.den * r.num)

tactic: simp [*]
state_before: a b c q r : ℚ
hr : r.num = 0
hr' : r = 0
⊢ q / r = q.num * ↑r.den /. (↑q.den * r.num)

tactic: simp [num_den]
state_before: a b c q r : ℚ
hr : ¬r.num = 0
⊢ q * r⁻¹ = q.num /. ↑q.den * (r.num /. ↑r.den)⁻¹

tactic: rw [inv_def']
state_before: a b c q r : ℚ
hr : ¬r.num = 0
⊢ q.num /. ↑q.den * (r.num /. ↑r.den)⁻¹ = q.num /. ↑q.den * (↑r.den /. r.num)

tactic: simpa using den_nz q
state_before: a b c q r : ℚ
hr : ¬r.num = 0
⊢ ↑q.den ≠ 0
Theorem: le_div_iff_of_neg'
File: Mathlib/Algebra/Order/Field/Basic.lean

tactic: rw [mul_comm, le_div_iff_of_neg hc]
state_before: ι : Type ?u.146538
α : Type u_1
β : Type ?u.146544
inst✝ : LinearOrderedField α
a b c d : α
n : ℤ
hc : c < 0
⊢ a ≤ b / c ↔ b ≤ c * a
Theorem: Partrec₂.unpaired
File: Mathlib/Computability/Partrec.lean

tactic: simpa using Partrec.comp (g := fun p : ℕ × ℕ => (p.1, p.2)) h Primrec₂.pair.to_comp
state_before: α : Type u_1
β : Type ?u.82494
γ : Type ?u.82497
δ : Type ?u.82500
σ : Type ?u.82503
inst✝⁴ : Primcodable α
inst✝³ : Primcodable β
inst✝² : Primcodable γ
inst✝¹ : Primcodable δ
inst✝ : Primcodable σ
f : ℕ → ℕ →. α
h : Partrec (Nat.unpaired f)
⊢ Partrec₂ f
Theorem: YoungDiagram.mk_mem_row_iff
File: Mathlib/Combinatorics/Young/YoungDiagram.lean

tactic: simp [row]
state_before: μ : YoungDiagram
i j : ℕ
⊢ (i, j) ∈ row μ i ↔ (i, j) ∈ μ
Theorem: List.nthLe_zero
File: Mathlib/Data/List/Basic.lean

tactic: cases L
state_before: ι : Type ?u.87426
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α
inst✝ : Inhabited α
L : List α
h : 0 < length L
⊢ nthLe L 0 h = head! L

tactic: cases h
state_before: case nil
ι : Type ?u.87426
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α
inst✝ : Inhabited α
h : 0 < length []
⊢ nthLe [] 0 h = head! []

case cons
ι : Type ?u.87426
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α
inst✝ : Inhabited α
head✝ : α
tail✝ : List α
h : 0 < length (head✝ :: tail✝)
⊢ nthLe (head✝ :: tail✝) 0 h = head! (head✝ :: tail✝)

tactic: simp [nthLe]
state_before: case cons
ι : Type ?u.87426
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α
inst✝ : Inhabited α
head✝ : α
tail✝ : List α
h : 0 < length (head✝ :: tail✝)
⊢ nthLe (head✝ :: tail✝) 0 h = head! (head✝ :: tail✝)
Theorem: Behrend.div_lt_floor
File: Mathlib/Combinatorics/Additive/Behrend.lean

tactic: apply lt_of_le_of_lt _ (sub_one_lt_floor _)
state_before: α : Type ?u.696433
β : Type ?u.696436
n d k N : ℕ
x✝ : Fin n → ℕ
x : ℝ
hx : 2 / (1 - 2 / exp 1) ≤ x
⊢ x / exp 1 < ↑⌊x / 2⌋₊

tactic: have : 0 < 1 - 2 / exp 1 := by
  rw [sub_pos, div_lt_one (exp_pos _)]
  exact lt_of_le_of_lt (by norm_num) exp_one_gt_d9
state_before: α : Type ?u.696433
β : Type ?u.696436
n d k N : ℕ
x✝ : Fin n → ℕ
x : ℝ
hx : 2 / (1 - 2 / exp 1) ≤ x
⊢ x / exp 1 ≤ x / 2 - 1

tactic: rwa [le_sub_comm, div_eq_mul_one_div x, div_eq_mul_one_div x, ← mul_sub, div_sub', ←
  div_eq_mul_one_div, mul_div_assoc', one_le_div, ← div_le_iff this]
state_before: α : Type ?u.696433
β : Type ?u.696436
n d k N : ℕ
x✝ : Fin n → ℕ
x : ℝ
hx : 2 / (1 - 2 / exp 1) ≤ x
this : 0 < 1 - 2 / exp 1
⊢ x / exp 1 ≤ x / 2 - 1

tactic: rw [sub_pos, div_lt_one (exp_pos _)]
state_before: α : Type ?u.696433
β : Type ?u.696436
n d k N : ℕ
x✝ : Fin n → ℕ
x : ℝ
hx : 2 / (1 - 2 / exp 1) ≤ x
⊢ 0 < 1 - 2 / exp 1

tactic: exact lt_of_le_of_lt (by norm_num) exp_one_gt_d9
state_before: α : Type ?u.696433
β : Type ?u.696436
n d k N : ℕ
x✝ : Fin n → ℕ
x : ℝ
hx : 2 / (1 - 2 / exp 1) ≤ x
⊢ 2 < exp 1

tactic: norm_num
state_before: α : Type ?u.696433
β : Type ?u.696436
n d k N : ℕ
x✝ : Fin n → ℕ
x : ℝ
hx : 2 / (1 - 2 / exp 1) ≤ x
⊢ 2 ≤ 2.7182818283

tactic: exact zero_lt_two
state_before: α : Type ?u.696433
β : Type ?u.696436
n d k N : ℕ
x✝ : Fin n → ℕ
x : ℝ
hx : 2 / (1 - 2 / exp 1) ≤ x
this : 0 < 1 - 2 / exp 1
⊢ 0 < 2

tactic: exact two_ne_zero
state_before: case hc
α : Type ?u.696433
β : Type ?u.696436
n d k N : ℕ
x✝ : Fin n → ℕ
x : ℝ
hx : 2 / (1 - 2 / exp 1) ≤ x
this : 0 < 1 - 2 / exp 1
⊢ 2 ≠ 0
Theorem: List.Ico.nodup
File: Mathlib/Data/List/Intervals.lean

tactic: dsimp [Ico]
state_before: n m : ℕ
⊢ Nodup (Ico n m)

tactic: simp only [nodup_range']
state_before: n m : ℕ
⊢ Nodup (range' n (m - n))
Theorem: Nat.pow_mod
File: Mathlib/Data/Nat/Pow.lean

tactic: induction' b with b ih
state_before: a b n : ℕ
⊢ a ^ b % n = (a % n) ^ b % n

tactic: rfl
state_before: case zero
a n : ℕ
⊢ a ^ zero % n = (a % n) ^ zero % n

case succ
a n b : ℕ
ih : a ^ b % n = (a % n) ^ b % n
⊢ a ^ succ b % n = (a % n) ^ succ b % n

tactic: simp [pow_succ, Nat.mul_mod, ih]
state_before: case succ
a n b : ℕ
ih : a ^ b % n = (a % n) ^ b % n
⊢ a ^ succ b % n = (a % n) ^ succ b % n
Theorem: MvPolynomial.eval₂Hom_eq_zero
File: Mathlib/Data/MvPolynomial/Basic.lean

tactic: rw [φ.as_sum, map_sum]
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
inst✝¹ : Algebra R S₁
inst✝ : CommSemiring S₂
f✝ : σ → S₁
f : R →+* S₂
g : σ → S₂
φ : MvPolynomial σ R
h : ∀ (d : σ →₀ ℕ), coeff d φ ≠ 0 → ∃ i, i ∈ d.support ∧ g i = 0
⊢ ↑(eval₂Hom f g) φ = 0

tactic: refine Finset.sum_eq_zero fun d hd => ?_
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
inst✝¹ : Algebra R S₁
inst✝ : CommSemiring S₂
f✝ : σ → S₁
f : R →+* S₂
g : σ → S₂
φ : MvPolynomial σ R
h : ∀ (d : σ →₀ ℕ), coeff d φ ≠ 0 → ∃ i, i ∈ d.support ∧ g i = 0
⊢ ∑ x in support φ, ↑(eval₂Hom f g) (↑(monomial x) (coeff x φ)) = 0

tactic: obtain ⟨i, hi, hgi⟩ : ∃ i ∈ d.support, g i = 0 := h d (Finsupp.mem_support_iff.mp hd)
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
inst✝¹ : Algebra R S₁
inst✝ : CommSemiring S₂
f✝ : σ → S₁
f : R →+* S₂
g : σ → S₂
φ : MvPolynomial σ R
h : ∀ (d : σ →₀ ℕ), coeff d φ ≠ 0 → ∃ i, i ∈ d.support ∧ g i = 0
d : σ →₀ ℕ
hd : d ∈ support φ
⊢ ↑(eval₂Hom f g) (↑(monomial d) (coeff d φ)) = 0

tactic: rw [eval₂Hom_monomial, Finsupp.prod, Finset.prod_eq_zero hi, MulZeroClass.mul_zero]
state_before: case intro.intro
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
inst✝¹ : Algebra R S₁
inst✝ : CommSemiring S₂
f✝ : σ → S₁
f : R →+* S₂
g : σ → S₂
φ : MvPolynomial σ R
h : ∀ (d : σ →₀ ℕ), coeff d φ ≠ 0 → ∃ i, i ∈ d.support ∧ g i = 0
d : σ →₀ ℕ
hd : d ∈ support φ
i : σ
hi : i ∈ d.support
hgi : g i = 0
⊢ ↑(eval₂Hom f g) (↑(monomial d) (coeff d φ)) = 0

tactic: rw [hgi, zero_pow]
state_before: case intro.intro
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
inst✝¹ : Algebra R S₁
inst✝ : CommSemiring S₂
f✝ : σ → S₁
f : R →+* S₂
g : σ → S₂
φ : MvPolynomial σ R
h : ∀ (d : σ →₀ ℕ), coeff d φ ≠ 0 → ∃ i, i ∈ d.support ∧ g i = 0
d : σ →₀ ℕ
hd : d ∈ support φ
i : σ
hi : i ∈ d.support
hgi : g i = 0
⊢ g i ^ ↑d i = 0

tactic: rwa [pos_iff_ne_zero, ← Finsupp.mem_support_iff]
state_before: case intro.intro
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
inst✝¹ : Algebra R S₁
inst✝ : CommSemiring S₂
f✝ : σ → S₁
f : R →+* S₂
g : σ → S₂
φ : MvPolynomial σ R
h : ∀ (d : σ →₀ ℕ), coeff d φ ≠ 0 → ∃ i, i ∈ d.support ∧ g i = 0
d : σ →₀ ℕ
hd : d ∈ support φ
i : σ
hi : i ∈ d.support
hgi : g i = 0
⊢ 0 < ↑d i
Theorem: MeasureTheory.Measure.join_map_map
File: Mathlib/MeasureTheory/Measure/GiryMonad.lean

tactic: ext1 s hs
state_before: α : Type u_1
β : Type u_2
inst✝¹ : MeasurableSpace α
inst✝ : MeasurableSpace β
f : α → β
hf : Measurable f
μ : Measure (Measure α)
⊢ join (map (map f) μ) = map f (join μ)

tactic: rw [join_apply hs, map_apply hf hs, join_apply (hf hs),
  lintegral_map (measurable_coe hs) (measurable_map f hf)]
state_before: case h
α : Type u_1
β : Type u_2
inst✝¹ : MeasurableSpace α
inst✝ : MeasurableSpace β
f : α → β
hf : Measurable f
μ : Measure (Measure α)
s : Set β
hs : MeasurableSet s
⊢ ↑↑(join (map (map f) μ)) s = ↑↑(map f (join μ)) s

tactic: simp_rw [map_apply hf hs]
state_before: case h
α : Type u_1
β : Type u_2
inst✝¹ : MeasurableSpace α
inst✝ : MeasurableSpace β
f : α → β
hf : Measurable f
μ : Measure (Measure α)
s : Set β
hs : MeasurableSet s
⊢ (∫⁻ (a : Measure α), ↑↑(map f a) s ∂μ) = ∫⁻ (μ : Measure α), ↑↑μ (f ⁻¹' s) ∂μ