tasksource/leandojo huggingface dataset:
Theorem: Multiset.replicate_inter
File: Mathlib/Data/Multiset/Basic.lean

tactic: ext y
state_before: α : Type u_1
β : Type ?u.422106
γ : Type ?u.422109
inst✝ : DecidableEq α
n : ℕ
x : α
s : Multiset α
⊢ replicate n x ∩ s = replicate (min n (count x s)) x

tactic: rw [count_inter, count_replicate, count_replicate]
state_before: case a
α : Type u_1
β : Type ?u.422106
γ : Type ?u.422109
inst✝ : DecidableEq α
n : ℕ
x : α
s : Multiset α
y : α
⊢ count y (replicate n x ∩ s) = count y (replicate (min n (count x s)) x)

tactic: by_cases h : y = x
state_before: case a
α : Type u_1
β : Type ?u.422106
γ : Type ?u.422109
inst✝ : DecidableEq α
n : ℕ
x : α
s : Multiset α
y : α
⊢ min (if y = x then n else 0) (count y s) = if y = x then min n (count x s) else 0

tactic: simp only [h, if_true]
state_before: case pos
α : Type u_1
β : Type ?u.422106
γ : Type ?u.422109
inst✝ : DecidableEq α
n : ℕ
x : α
s : Multiset α
y : α
h : y = x
⊢ min (if y = x then n else 0) (count y s) = if y = x then min n (count x s) else 0

tactic: simp only [h, if_false, zero_min]
state_before: case neg
α : Type u_1
β : Type ?u.422106
γ : Type ?u.422109
inst✝ : DecidableEq α
n : ℕ
x : α
s : Multiset α
y : α
h : ¬y = x
⊢ min (if y = x then n else 0) (count y s) = if y = x then min n (count x s) else 0
Theorem: Nat.coprime.coprime_dvd_left
File: Std/Data/Nat/Gcd.lean

tactic: apply eq_one_of_dvd_one
state_before: m k n : Nat
H1 : m ∣ k
H2 : coprime k n
⊢ coprime m n

tactic: rw [coprime] at H2
state_before: case H
m k n : Nat
H1 : m ∣ k
H2 : coprime k n
⊢ gcd m n ∣ 1

tactic: have := Nat.gcd_dvd_gcd_of_dvd_left n H1
state_before: case H
m k n : Nat
H1 : m ∣ k
H2 : gcd k n = 1
⊢ gcd m n ∣ 1

tactic: rwa [← H2]
state_before: case H
m k n : Nat
H1 : m ∣ k
H2 : gcd k n = 1
this : gcd m n ∣ gcd k n
⊢ gcd m n ∣ 1
Theorem: RatFunc.eval_zero
File: Mathlib/FieldTheory/RatFunc.lean

tactic: simp [eval]
state_before: K : Type u
inst✝¹ : Field K
L : Type u_1
inst✝ : Field L
f : K →+* L
a : L
⊢ eval f a 0 = 0
Theorem: Nat.WithBot.one_le_iff_zero_lt
File: Mathlib/Data/Nat/WithBot.lean

tactic: refine' ⟨fun h => lt_of_lt_of_le (WithBot.coe_lt_coe.mpr zero_lt_one) h, fun h => _⟩
state_before: x : WithBot ℕ
⊢ 1 ≤ x ↔ 0 < x

tactic: induction x using WithBot.recBotCoe
state_before: x : WithBot ℕ
h : 0 < x
⊢ 1 ≤ x

tactic: exact (not_lt_bot h).elim
state_before: case bot
h : 0 < ⊥
⊢ 1 ≤ ⊥

tactic: exact WithBot.coe_le_coe.mpr (Nat.succ_le_iff.mpr (WithBot.coe_lt_coe.mp h))
state_before: case coe
a✝ : ℕ
h : 0 < ↑a✝
⊢ 1 ≤ ↑a✝
Theorem: Unitization.inr_star
File: Mathlib/Algebra/Algebra/Unitization.lean

tactic: simp only [fst_star, star_zero, fst_inr]
state_before: R : Type u_1
A : Type u_2
inst✝² : AddMonoid R
inst✝¹ : StarAddMonoid R
inst✝ : Star A
a : A
⊢ fst ↑(star a) = fst (star ↑a)
Theorem: Stream'.Seq.dropn_tail
File: Mathlib/Data/Seq/Seq.lean

tactic: rw [add_comm]
state_before: α : Type u
β : Type v
γ : Type w
s : Seq α
n : ℕ
⊢ drop (tail s) n = drop s (n + 1)

tactic: symm
state_before: α : Type u
β : Type v
γ : Type w
s : Seq α
n : ℕ
⊢ drop (tail s) n = drop s (1 + n)

tactic: apply dropn_add
state_before: α : Type u
β : Type v
γ : Type w
s : Seq α
n : ℕ
⊢ drop s (1 + n) = drop (tail s) n
Theorem: DiscreteValuationRing.addVal_le_iff_dvd
File: Mathlib/RingTheory/DiscreteValuationRing/Basic.lean

tactic: have hp := Classical.choose_spec (exists_prime R)
state_before: R : Type u_1
inst✝² : CommRing R
inst✝¹ : IsDomain R
inst✝ : DiscreteValuationRing R
a b : R
⊢ ↑(addVal R) a ≤ ↑(addVal R) b ↔ a ∣ b

tactic: constructor <;> intro h
state_before: R : Type u_1
inst✝² : CommRing R
inst✝¹ : IsDomain R
inst✝ : DiscreteValuationRing R
a b : R
hp : Prime (choose (_ : ∃ ϖ, Prime ϖ))
⊢ ↑(addVal R) a ≤ ↑(addVal R) b ↔ a ∣ b

tactic: by_cases ha0 : a = 0
state_before: case mp
R : Type u_1
inst✝² : CommRing R
inst✝¹ : IsDomain R
inst✝ : DiscreteValuationRing R
a b : R
hp : Prime (choose (_ : ∃ ϖ, Prime ϖ))
h : ↑(addVal R) a ≤ ↑(addVal R) b
⊢ a ∣ b

tactic: obtain ⟨n, ha⟩ := associated_pow_irreducible ha0 hp.irreducible
state_before: case neg
R : Type u_1
inst✝² : CommRing R
inst✝¹ : IsDomain R
inst✝ : DiscreteValuationRing R
a b : R
hp : Prime (choose (_ : ∃ ϖ, Prime ϖ))
h : ↑(addVal R) a ≤ ↑(addVal R) b
ha0 : ¬a = 0
⊢ a ∣ b

tactic: rw [addVal, addValuation_apply, addValuation_apply, multiplicity_le_multiplicity_iff] at h
state_before: case neg.intro
R : Type u_1
inst✝² : CommRing R
inst✝¹ : IsDomain R
inst✝ : DiscreteValuationRing R
a b : R
hp : Prime (choose (_ : ∃ ϖ, Prime ϖ))
h : ↑(addVal R) a ≤ ↑(addVal R) b
ha0 : ¬a = 0
n : ℕ
ha : Associated a (choose (_ : ∃ ϖ, Prime ϖ) ^ n)
⊢ a ∣ b

tactic: exact ha.dvd.trans (h n ha.symm.dvd)
state_before: case neg.intro
R : Type u_1
inst✝² : CommRing R
inst✝¹ : IsDomain R
inst✝ : DiscreteValuationRing R
a b : R
hp : Prime (choose (_ : ∃ ϖ, Prime ϖ))
h : ∀ (n : ℕ), choose (_ : ∃ ϖ, Prime ϖ) ^ n ∣ a → choose (_ : ∃ ϖ, Prime ϖ) ^ n ∣ b
ha0 : ¬a = 0
n : ℕ
ha : Associated a (choose (_ : ∃ ϖ, Prime ϖ) ^ n)
⊢ a ∣ b

tactic: rw [ha0, addVal_zero, top_le_iff, addVal_eq_top_iff] at h
state_before: case pos
R : Type u_1
inst✝² : CommRing R
inst✝¹ : IsDomain R
inst✝ : DiscreteValuationRing R
a b : R
hp : Prime (choose (_ : ∃ ϖ, Prime ϖ))
h : ↑(addVal R) a ≤ ↑(addVal R) b
ha0 : a = 0
⊢ a ∣ b

tactic: rw [h]
state_before: case pos
R : Type u_1
inst✝² : CommRing R
inst✝¹ : IsDomain R
inst✝ : DiscreteValuationRing R
a b : R
hp : Prime (choose (_ : ∃ ϖ, Prime ϖ))
h : b = 0
ha0 : a = 0
⊢ a ∣ b

tactic: apply dvd_zero
state_before: case pos
R : Type u_1
inst✝² : CommRing R
inst✝¹ : IsDomain R
inst✝ : DiscreteValuationRing R
a b : R
hp : Prime (choose (_ : ∃ ϖ, Prime ϖ))
h : b = 0
ha0 : a = 0
⊢ a ∣ 0

tactic: rw [addVal, addValuation_apply, addValuation_apply]
state_before: case mpr
R : Type u_1
inst✝² : CommRing R
inst✝¹ : IsDomain R
inst✝ : DiscreteValuationRing R
a b : R
hp : Prime (choose (_ : ∃ ϖ, Prime ϖ))
h : a ∣ b
⊢ ↑(addVal R) a ≤ ↑(addVal R) b

tactic: exact multiplicity_le_multiplicity_of_dvd_right h
state_before: case mpr
R : Type u_1
inst✝² : CommRing R
inst✝¹ : IsDomain R
inst✝ : DiscreteValuationRing R
a b : R
hp : Prime (choose (_ : ∃ ϖ, Prime ϖ))
h : a ∣ b
⊢ multiplicity (choose (_ : ∃ ϖ, Prime ϖ)) a ≤ multiplicity (choose (_ : ∃ ϖ, Prime ϖ)) b
Theorem: constant_of_has_deriv_right_zero
File: Mathlib/Analysis/Calculus/MeanValue.lean

tactic: have : ∀ x ∈ Icc a b, ‖f x - f a‖ ≤ 0 * (x - a) := fun x hx =>
  norm_image_sub_le_of_norm_deriv_right_le_segment hcont hderiv (fun _ _ => norm_zero.le) x hx
state_before: E : Type u_1
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace ℝ E
F : Type ?u.46649
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℝ F
f : ℝ → E
a b : ℝ
hcont : ContinuousOn f (Icc a b)
hderiv : ∀ (x : ℝ), x ∈ Ico a b → HasDerivWithinAt f 0 (Ici x) x
⊢ ∀ (x : ℝ), x ∈ Icc a b → f x = f a

tactic: simpa only [zero_mul, norm_le_zero_iff, sub_eq_zero] using this
state_before: E : Type u_1
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace ℝ E
F : Type ?u.46649
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℝ F
f : ℝ → E
a b : ℝ
hcont : ContinuousOn f (Icc a b)
hderiv : ∀ (x : ℝ), x ∈ Ico a b → HasDerivWithinAt f 0 (Ici x) x
this : ∀ (x : ℝ), x ∈ Icc a b → ‖f x - f a‖ ≤ 0 * (x - a)
⊢ ∀ (x : ℝ), x ∈ Icc a b → f x = f a
Theorem: Filter.prod_eq_bot
File: Mathlib/Order/Filter/Prod.lean

tactic: simp_rw [← empty_mem_iff_bot, mem_prod_iff, subset_empty_iff, prod_eq_empty_iff, ← exists_prop,
  Subtype.exists', exists_or, exists_const, Subtype.exists, exists_prop, exists_eq_right]
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.45152
δ : Type ?u.45155
ι : Sort ?u.45158
s : Set α
t : Set β
f✝ : Filter α
g✝ : Filter β
f : Filter α
g : Filter β
⊢ f ×ˢ g = ⊥ ↔ f = ⊥ ∨ g = ⊥
Theorem: eventually_mapsTo_of_isOpen_of_omegaLimit_subset
File: Mathlib/Dynamics/OmegaLimit.lean

tactic: rcases eventually_closure_subset_of_isOpen_of_omegaLimit_subset f ϕ s hv₁ hv₂ with ⟨u, hu_mem, hu⟩
state_before: τ : Type u_2
α : Type u_3
β : Type u_1
ι : Type ?u.74055
inst✝¹ : TopologicalSpace β
f : Filter τ
ϕ : τ → α → β
s s₁ s₂ : Set α
inst✝ : CompactSpace β
v : Set β
hv₁ : IsOpen v
hv₂ : ω f ϕ s ⊆ v
⊢ ∀ᶠ (t : τ) in f, MapsTo (ϕ t) s v

tactic: refine' mem_of_superset hu_mem fun t ht x hx ↦ _
state_before: case intro.intro
τ : Type u_2
α : Type u_3
β : Type u_1
ι : Type ?u.74055
inst✝¹ : TopologicalSpace β
f : Filter τ
ϕ : τ → α → β
s s₁ s₂ : Set α
inst✝ : CompactSpace β
v : Set β
hv₁ : IsOpen v
hv₂ : ω f ϕ s ⊆ v
u : Set τ
hu_mem : u ∈ f
hu : closure (image2 ϕ u s) ⊆ v
⊢ ∀ᶠ (t : τ) in f, MapsTo (ϕ t) s v

tactic: exact hu (subset_closure <| mem_image2_of_mem ht hx)
state_before: case intro.intro
τ : Type u_2
α : Type u_3
β : Type u_1
ι : Type ?u.74055
inst✝¹ : TopologicalSpace β
f : Filter τ
ϕ : τ → α → β
s s₁ s₂ : Set α
inst✝ : CompactSpace β
v : Set β
hv₁ : IsOpen v
hv₂ : ω f ϕ s ⊆ v
u : Set τ
hu_mem : u ∈ f
hu : closure (image2 ϕ u s) ⊆ v
t : τ
ht : t ∈ u
x : α
hx : x ∈ s
⊢ ϕ t x ∈ v
Theorem: QuaternionGroup.a_one_pow_n
File: Mathlib/GroupTheory/SpecificGroups/Quaternion.lean

tactic: rw [a_one_pow, one_def]
state_before: n : ℕ
⊢ a 1 ^ (2 * n) = 1

tactic: congr 1
state_before: n : ℕ
⊢ a ↑(2 * n) = a 0

tactic: exact ZMod.nat_cast_self _
state_before: case e_a
n : ℕ
⊢ ↑(2 * n) = 0
Theorem: Cubic.degree_of_c_ne_zero
File: Mathlib/Algebra/CubicDiscriminant.lean

tactic: rw [of_b_eq_zero ha hb, degree_linear hc]
state_before: R : Type u_1
S : Type ?u.582471
F : Type ?u.582474
K : Type ?u.582477
P Q : Cubic R
a b c d a' b' c' d' : R
inst✝ : Semiring R
ha : P.a = 0
hb : P.b = 0
hc : P.c ≠ 0
⊢ degree (toPoly P) = 1
Theorem: Associates.FactorSet.unique
File: Mathlib/RingTheory/UniqueFactorizationDomain.lean

tactic: induction p using WithTop.recTopCoe <;> induction q using WithTop.recTopCoe
state_before: α : Type u_1
inst✝² : CancelCommMonoidWithZero α
dec_irr : (p : Associates α) → Decidable (Irreducible p)
inst✝¹ : UniqueFactorizationMonoid α
inst✝ : Nontrivial α
p q : FactorSet α
h : prod p = prod q
⊢ p = q

tactic: rfl
state_before: case top.top
α : Type u_1
inst✝² : CancelCommMonoidWithZero α
dec_irr : (p : Associates α) → Decidable (Irreducible p)
inst✝¹ : UniqueFactorizationMonoid α
inst✝ : Nontrivial α
h : prod ⊤ = prod ⊤
⊢ ⊤ = ⊤

tactic: rw [eq_comm, ← FactorSet.prod_eq_zero_iff, ← h, Associates.prod_top]
state_before: case top.coe
α : Type u_1
inst✝² : CancelCommMonoidWithZero α
dec_irr : (p : Associates α) → Decidable (Irreducible p)
inst✝¹ : UniqueFactorizationMonoid α
inst✝ : Nontrivial α
a✝ : Multiset { a // Irreducible a }
h : prod ⊤ = prod ↑a✝
⊢ ⊤ = ↑a✝

tactic: rw [← FactorSet.prod_eq_zero_iff, h, Associates.prod_top]
state_before: case coe.top
α : Type u_1
inst✝² : CancelCommMonoidWithZero α
dec_irr : (p : Associates α) → Decidable (Irreducible p)
inst✝¹ : UniqueFactorizationMonoid α
inst✝ : Nontrivial α
a✝ : Multiset { a // Irreducible a }
h : prod ↑a✝ = prod ⊤
⊢ ↑a✝ = ⊤

tactic: congr 1
state_before: case coe.coe
α : Type u_1
inst✝² : CancelCommMonoidWithZero α
dec_irr : (p : Associates α) → Decidable (Irreducible p)
inst✝¹ : UniqueFactorizationMonoid α
inst✝ : Nontrivial α
a✝¹ a✝ : Multiset { a // Irreducible a }
h : prod ↑a✝¹ = prod ↑a✝
⊢ ↑a✝¹ = ↑a✝

tactic: rw [← Multiset.map_eq_map Subtype.coe_injective]
state_before: case coe.coe.e_a
α : Type u_1
inst✝² : CancelCommMonoidWithZero α
dec_irr : (p : Associates α) → Decidable (Irreducible p)
inst✝¹ : UniqueFactorizationMonoid α
inst✝ : Nontrivial α
a✝¹ a✝ : Multiset { a // Irreducible a }
h : prod ↑a✝¹ = prod ↑a✝
⊢ a✝¹ = a✝

tactic: intro a ha
state_before: α : Type u_1
inst✝² : CancelCommMonoidWithZero α
dec_irr : (p : Associates α) → Decidable (Irreducible p)
inst✝¹ : UniqueFactorizationMonoid α
inst✝ : Nontrivial α
a✝¹ a✝ : Multiset { a // Irreducible a }
h : prod ↑a✝¹ = prod ↑a✝
⊢ ∀ (a : Associates α), a ∈ map Subtype.val a✝ → Irreducible a

tactic: obtain ⟨⟨a', irred⟩, -, rfl⟩ := Multiset.mem_map.mp ha
state_before: α : Type u_1
inst✝² : CancelCommMonoidWithZero α
dec_irr : (p : Associates α) → Decidable (Irreducible p)
inst✝¹ : UniqueFactorizationMonoid α
inst✝ : Nontrivial α
a✝¹ a✝ : Multiset { a // Irreducible a }
h : prod ↑a✝¹ = prod ↑a✝
a : Associates α
ha : a ∈ map Subtype.val a✝
⊢ Irreducible a

tactic: rwa [Subtype.coe_mk]
state_before: case intro.mk.intro
α : Type u_1
inst✝² : CancelCommMonoidWithZero α
dec_irr : (p : Associates α) → Decidable (Irreducible p)
inst✝¹ : UniqueFactorizationMonoid α
inst✝ : Nontrivial α
a✝¹ a✝ : Multiset { a // Irreducible a }
h : prod ↑a✝¹ = prod ↑a✝
a' : Associates α
irred : Irreducible a'
ha : ↑{ val := a', property := irred } ∈ map Subtype.val a✝
⊢ Irreducible ↑{ val := a', property := irred }
Theorem: OrderIso.image_Iic
File: Mathlib/Data/Set/Intervals/OrderIso.lean

tactic: rw [e.image_eq_preimage, e.symm.preimage_Iic, e.symm_symm]
state_before: α : Type u_1
β : Type u_2
inst✝¹ : Preorder α
inst✝ : Preorder β
e : α ≃o β
a : α
⊢ ↑e '' Iic a = Iic (↑e a)
Theorem: T_pos
File: Mathlib/NumberTheory/Padics/Hensel.lean

tactic: rw [T_def]
state_before: p : ℕ
inst✝ : Fact (Nat.Prime p)
F : Polynomial ℤ_[p]
a : ℤ_[p]
hnorm : ‖Polynomial.eval a F‖ < ‖Polynomial.eval a (↑Polynomial.derivative F)‖ ^ 2
hnsol : Polynomial.eval a F ≠ 0
⊢ T_gen p F a > 0

tactic: exact div_pos (norm_pos_iff.2 hnsol) (deriv_sq_norm_pos hnorm)
state_before: p : ℕ
inst✝ : Fact (Nat.Prime p)
F : Polynomial ℤ_[p]
a : ℤ_[p]
hnorm : ‖Polynomial.eval a F‖ < ‖Polynomial.eval a (↑Polynomial.derivative F)‖ ^ 2
hnsol : Polynomial.eval a F ≠ 0
⊢ ‖Polynomial.eval a F‖ / ‖Polynomial.eval a (↑Polynomial.derivative F)‖ ^ 2 > 0
Theorem: Nat.ArithmeticFunction.moebius_ne_zero_iff_eq_or
File: Mathlib/NumberTheory/ArithmeticFunction.lean

tactic: constructor <;> intro h
state_before: R : Type ?u.586134
n : ℕ
⊢ ↑μ n ≠ 0 ↔ ↑μ n = 1 ∨ ↑μ n = -1

tactic: rw [moebius_ne_zero_iff_squarefree] at h
state_before: case mp
R : Type ?u.586134
n : ℕ
h : ↑μ n ≠ 0
⊢ ↑μ n = 1 ∨ ↑μ n = -1

tactic: rw [moebius_apply_of_squarefree h]
state_before: case mp
R : Type ?u.586134
n : ℕ
h : Squarefree n
⊢ ↑μ n = 1 ∨ ↑μ n = -1

tactic: apply neg_one_pow_eq_or
state_before: case mp
R : Type ?u.586134
n : ℕ
h : Squarefree n
⊢ (-1) ^ ↑Ω n = 1 ∨ (-1) ^ ↑Ω n = -1

tactic: rcases h with (h | h) <;> simp [h]
state_before: case mpr
R : Type ?u.586134
n : ℕ
h : ↑μ n = 1 ∨ ↑μ n = -1
⊢ ↑μ n ≠ 0
Theorem: ZFSet.toSet_empty
File: Mathlib/SetTheory/ZFC/Basic.lean

tactic: simp [toSet]
state_before: ⊢ toSet ∅ = ∅
Theorem: CategoryTheory.Limits.Cofork.coequalizer_ext
File: Mathlib/CategoryTheory/Limits/Shapes/Equalizers.lean

tactic: simp only [s.app_zero_eq_comp_π_left, Category.assoc, h]
state_before: C : Type u
inst✝ : Category C
X Y : C
f g : X ⟶ Y
s : Cofork f g
W : C
k l : s.pt ⟶ W
h : π s ≫ k = π s ≫ l
⊢ s.ι.app zero ≫ k = s.ι.app zero ≫ l
Theorem: ZMod.val_neg_one
File: Mathlib/Data/ZMod/Basic.lean

tactic: dsimp [val, Fin.coe_neg]
state_before: n : ℕ
⊢ val (-1) = n

tactic: cases n
state_before: n : ℕ
⊢ ↑(-1) = n

tactic: simp [Nat.mod_one]
state_before: case zero

⊢ ↑(-1) = Nat.zero

tactic: dsimp [ZMod, ZMod.cast]
state_before: case succ
n✝ : ℕ
⊢ ↑(-1) = Nat.succ n✝

tactic: rw [Fin.coe_neg_one]
state_before: case succ
n✝ : ℕ
⊢ ↑(-1) = Nat.succ n✝
Theorem: Finset.prod_fiberwise_of_maps_to
File: Mathlib/Algebra/BigOperators/Basic.lean

tactic: rw [← prod_disjiUnion, disjiUnion_filter_eq_of_maps_to h]
state_before: ι : Type ?u.319435
β : Type u
α : Type v
γ : Type w
s✝ s₁ s₂ : Finset α
a : α
f✝ g✝ : α → β
inst✝¹ : CommMonoid β
inst✝ : DecidableEq γ
s : Finset α
t : Finset γ
g : α → γ
h : ∀ (x : α), x ∈ s → g x ∈ t
f : α → β
⊢ ∏ y in t, ∏ x in filter (fun x => g x = y) s, f x = ∏ x in s, f x
Theorem: MeasurableEmbedding.integrable_map_iff
File: Mathlib/MeasureTheory/Function/L1Space.lean

tactic: simp_rw [← memℒp_one_iff_integrable]
state_before: α : Type u_1
β : Type u_3
γ : Type ?u.859095
δ : Type u_2
m : MeasurableSpace α
μ ν : Measure α
inst✝² : MeasurableSpace δ
inst✝¹ : NormedAddCommGroup β
inst✝ : NormedAddCommGroup γ
f : α → δ
hf : MeasurableEmbedding f
g : δ → β
⊢ Integrable g ↔ Integrable (g ∘ f)

tactic: exact hf.memℒp_map_measure_iff
state_before: α : Type u_1
β : Type u_3
γ : Type ?u.859095
δ : Type u_2
m : MeasurableSpace α
μ ν : Measure α
inst✝² : MeasurableSpace δ
inst✝¹ : NormedAddCommGroup β
inst✝ : NormedAddCommGroup γ
f : α → δ
hf : MeasurableEmbedding f
g : δ → β
⊢ Memℒp g 1 ↔ Memℒp (g ∘ f) 1
Theorem: QuadraticForm.map_add_self
File: Mathlib/LinearAlgebra/QuadraticForm/Basic.lean

tactic: rw [← one_smul R x, ← add_smul, map_smul]
state_before: S : Type ?u.122615
R : Type u_1
R₁ : Type ?u.122621
M : Type u_2
inst✝² : Semiring R
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
Q : QuadraticForm R M
x : M
⊢ ↑Q (x + x) = 4 * ↑Q x

tactic: norm_num
state_before: S : Type ?u.122615
R : Type u_1
R₁ : Type ?u.122621
M : Type u_2
inst✝² : Semiring R
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
Q : QuadraticForm R M
x : M
⊢ (1 + 1) * (1 + 1) * ↑Q x = 4 * ↑Q (1 • x)
Theorem: IsLowerSet.memberSubfamily_subset_nonMemberSubfamily
File: Mathlib/Combinatorics/SetFamily/HarrisKleitman.lean

tactic: rw [mem_memberSubfamily, mem_nonMemberSubfamily]
state_before: α : Type u_1
inst✝ : DecidableEq α
𝒜 ℬ : Finset (Finset α)
s✝ : Finset α
a : α
h : IsLowerSet ↑𝒜
s : Finset α
⊢ s ∈ Finset.memberSubfamily a 𝒜 → s ∈ Finset.nonMemberSubfamily a 𝒜

tactic: exact And.imp_left (h <| subset_insert _ _)
state_before: α : Type u_1
inst✝ : DecidableEq α
𝒜 ℬ : Finset (Finset α)
s✝ : Finset α
a : α
h : IsLowerSet ↑𝒜
s : Finset α
⊢ insert a s ∈ 𝒜 ∧ ¬a ∈ s → s ∈ 𝒜 ∧ ¬a ∈ s
Theorem: Ordinal.lt_nadd_iff
File: Mathlib/SetTheory/Ordinal/NaturalOps.lean

tactic: rw [nadd_def]
state_before: a b c : Ordinal
⊢ a < b ♯ c ↔ (∃ b', b' < b ∧ a ≤ b' ♯ c) ∨ ∃ c', c' < c ∧ a ≤ b ♯ c'

tactic: simp [lt_blsub_iff]
state_before: a b c : Ordinal
⊢ a < max (blsub b fun a' x => a' ♯ c) (blsub c fun b' x => b ♯ b') ↔
    (∃ b', b' < b ∧ a ≤ b' ♯ c) ∨ ∃ c', c' < c ∧ a ≤ b ♯ c'
Theorem: WellFounded.wellFounded_iff_has_min
File: Mathlib/Order/WellFounded.lean

tactic: refine ⟨fun h => h.has_min, fun h => ⟨fun x => ?_⟩⟩
state_before: α : Type u_1
r : α → α → Prop
⊢ WellFounded r ↔ ∀ (s : Set α), Set.Nonempty s → ∃ m, m ∈ s ∧ ∀ (x : α), x ∈ s → ¬r x m

tactic: by_contra hx
state_before: α : Type u_1
r : α → α → Prop
h : ∀ (s : Set α), Set.Nonempty s → ∃ m, m ∈ s ∧ ∀ (x : α), x ∈ s → ¬r x m
x : α
⊢ Acc r x

tactic: obtain ⟨m, hm, hm'⟩ := h {x | ¬Acc r x} ⟨x, hx⟩
state_before: α : Type u_1
r : α → α → Prop
h : ∀ (s : Set α), Set.Nonempty s → ∃ m, m ∈ s ∧ ∀ (x : α), x ∈ s → ¬r x m
x : α
hx : ¬Acc r x
⊢ False

tactic: refine' hm ⟨_, fun y hy => _⟩
state_before: case intro.intro
α : Type u_1
r : α → α → Prop
h : ∀ (s : Set α), Set.Nonempty s → ∃ m, m ∈ s ∧ ∀ (x : α), x ∈ s → ¬r x m
x : α
hx : ¬Acc r x
m : α
hm : m ∈ {x | ¬Acc r x}
hm' : ∀ (x : α), x ∈ {x | ¬Acc r x} → ¬r x m
⊢ False

tactic: by_contra hy'
state_before: case intro.intro
α : Type u_1
r : α → α → Prop
h : ∀ (s : Set α), Set.Nonempty s → ∃ m, m ∈ s ∧ ∀ (x : α), x ∈ s → ¬r x m
x : α
hx : ¬Acc r x
m : α
hm : m ∈ {x | ¬Acc r x}
hm' : ∀ (x : α), x ∈ {x | ¬Acc r x} → ¬r x m
y : α
hy : r y m
⊢ Acc r y

tactic: exact hm' y hy' hy
state_before: case intro.intro
α : Type u_1
r : α → α → Prop
h : ∀ (s : Set α), Set.Nonempty s → ∃ m, m ∈ s ∧ ∀ (x : α), x ∈ s → ¬r x m
x : α
hx : ¬Acc r x
m : α
hm : m ∈ {x | ¬Acc r x}
hm' : ∀ (x : α), x ∈ {x | ¬Acc r x} → ¬r x m
y : α
hy : r y m
hy' : ¬Acc r y
⊢ False
Theorem: nhdsWithin_Ico_eq_nhdsWithin_Iio
File: Mathlib/Topology/Order/Basic.lean

tactic: simpa only [dual_Ioc] using nhdsWithin_Ioc_eq_nhdsWithin_Ioi h.dual
state_before: α : Type u
β : Type v
γ : Type w
inst✝³ : TopologicalSpace α
inst✝² : LinearOrder α
inst✝¹ : OrderClosedTopology α
a✝ b✝ : α
inst✝ : TopologicalSpace γ
a b : α
h : a < b
⊢ 𝓝[Ico a b] b = 𝓝[Iio b] b
Theorem: List.alternatingProd_cons'
File: Mathlib/Data/List/BigOperators/Basic.lean

tactic: rw [alternatingProd_nil, inv_one, mul_one, alternatingProd_singleton]
state_before: ι : Type ?u.164493
α : Type u_1
M : Type ?u.164499
N : Type ?u.164502
P : Type ?u.164505
M₀ : Type ?u.164508
G : Type ?u.164511
R : Type ?u.164514
inst✝ : CommGroup α
a : α
⊢ alternatingProd [a] = a * (alternatingProd [])⁻¹

tactic: rw [alternatingProd_cons_cons', alternatingProd_cons' b l, mul_inv, inv_inv, mul_assoc]
state_before: ι : Type ?u.164493
α : Type u_1
M : Type ?u.164499
N : Type ?u.164502
P : Type ?u.164505
M₀ : Type ?u.164508
G : Type ?u.164511
R : Type ?u.164514
inst✝ : CommGroup α
a b : α
l : List α
⊢ alternatingProd (a :: b :: l) = a * (alternatingProd (b :: l))⁻¹
Theorem: LocallyConstant.locallyConstant_eq_of_fiber_zero_eq
File: Mathlib/Topology/LocallyConstant/Basic.lean

tactic: simp only [Set.ext_iff, mem_singleton_iff, mem_preimage] at h
state_before: X✝ : Type ?u.22569
Y : Type ?u.22572
Z : Type ?u.22575
α : Type ?u.22578
inst✝¹ : TopologicalSpace X✝
X : Type u_1
inst✝ : TopologicalSpace X
f g : LocallyConstant X (Fin 2)
h : ↑f ⁻¹' {0} = ↑g ⁻¹' {0}
⊢ f = g

tactic: ext1 x
state_before: X✝ : Type ?u.22569
Y : Type ?u.22572
Z : Type ?u.22575
α : Type ?u.22578
inst✝¹ : TopologicalSpace X✝
X : Type u_1
inst✝ : TopologicalSpace X
f g : LocallyConstant X (Fin 2)
h : ∀ (x : X), ↑f x = 0 ↔ ↑g x = 0
⊢ f = g

tactic: exact Fin.fin_two_eq_of_eq_zero_iff (h x)
state_before: case h
X✝ : Type ?u.22569
Y : Type ?u.22572
Z : Type ?u.22575
α : Type ?u.22578
inst✝¹ : TopologicalSpace X✝
X : Type u_1
inst✝ : TopologicalSpace X
f g : LocallyConstant X (Fin 2)
h : ∀ (x : X), ↑f x = 0 ↔ ↑g x = 0
x : X
⊢ ↑f x = ↑g x
Theorem: Fin.cons_le_cons
File: Mathlib/Data/Fin/Tuple/Basic.lean

tactic: simp only [cons_succ, Pi.le_def]
state_before: m n : ℕ
α : Fin (n + 1) → Type u
x✝ : α 0
q : (i : Fin (n + 1)) → α i
p : (i : Fin n) → α (succ i)
i : Fin n
y✝ : α (succ i)
z : α 0
inst✝ : (i : Fin (n + 1)) → Preorder (α i)
x₀ y₀ : α 0
x y : (i : Fin n) → α (succ i)
⊢ (∀ (i : Fin n), cons x₀ x (succ i) ≤ cons y₀ y (succ i)) ↔ x ≤ y
Theorem: Finset.exists_card_fiber_le_of_card_le_nsmul
File: Mathlib/Combinatorics/Pigeonhole.lean

tactic: simp_rw [cast_card] at hb⊢
state_before: α : Type u
β : Type v
M : Type w
inst✝¹ : DecidableEq β
s : Finset α
t : Finset β
f : α → β
w : α → M
b : M
n : ℕ
inst✝ : LinearOrderedCommSemiring M
ht : Finset.Nonempty t
hb : ↑(card s) ≤ card t • b
⊢ ∃ y, y ∈ t ∧ ↑(card (filter (fun x => f x = y) s)) ≤ b

tactic: refine'
  exists_sum_fiber_le_of_sum_fiber_nonneg_of_sum_le_nsmul
    (fun _ _ => sum_nonneg fun _ _ => zero_le_one) ht hb
state_before: α : Type u
β : Type v
M : Type w
inst✝¹ : DecidableEq β
s : Finset α
t : Finset β
f : α → β
w : α → M
b : M
n : ℕ
inst✝ : LinearOrderedCommSemiring M
ht : Finset.Nonempty t
hb : ∑ a in s, 1 ≤ card t • b
⊢ ∃ y, y ∈ t ∧ ∑ a in filter (fun x => f x = y) s, 1 ≤ b
Theorem: Ordinal.nfp_zero_mul
File: Mathlib/SetTheory/Ordinal/FixedPoint.lean

tactic: rw [← sup_iterate_eq_nfp]
state_before: ⊢ nfp (HMul.hMul 0) = id

tactic: induction' n with n _
state_before: a : Ordinal
n : ℕ
⊢ (HMul.hMul 0^[n]) a ≤ id a

tactic: rw [Function.iterate_succ']
state_before: case succ
a : Ordinal
n : ℕ
n_ih✝ : (HMul.hMul 0^[n]) a ≤ id a
⊢ (HMul.hMul 0^[Nat.succ n]) a ≤ id a

tactic: change 0 * _ ≤ a
state_before: case succ
a : Ordinal
n : ℕ
n_ih✝ : (HMul.hMul 0^[n]) a ≤ id a
⊢ (HMul.hMul 0 ∘ HMul.hMul 0^[n]) a ≤ id a

tactic: rw [zero_mul]
state_before: case succ
a : Ordinal
n : ℕ
n_ih✝ : (HMul.hMul 0^[n]) a ≤ id a
⊢ 0 * (HMul.hMul 0^[n]) a ≤ a

tactic: exact Ordinal.zero_le a
state_before: case succ
a : Ordinal
n : ℕ
n_ih✝ : (HMul.hMul 0^[n]) a ≤ id a
⊢ 0 ≤ a

tactic: rfl
state_before: case zero
a : Ordinal
⊢ (HMul.hMul 0^[Nat.zero]) a ≤ id a
Theorem: Units.mk0_one
File: Mathlib/Algebra/GroupWithZero/Units/Basic.lean

tactic: ext
state_before: α : Type ?u.10924
M₀ : Type ?u.10927
G₀ : Type u_1
M₀' : Type ?u.10933
G₀' : Type ?u.10936
F : Type ?u.10939
F' : Type ?u.10942
inst✝¹ : MonoidWithZero M₀
inst✝ : GroupWithZero G₀
a b : G₀
h : optParam (1 ≠ 0) (_ : 1 ≠ 0)
⊢ mk0 1 h = 1

tactic: rfl
state_before: case a
α : Type ?u.10924
M₀ : Type ?u.10927
G₀ : Type u_1
M₀' : Type ?u.10933
G₀' : Type ?u.10936
F : Type ?u.10939
F' : Type ?u.10942
inst✝¹ : MonoidWithZero M₀
inst✝ : GroupWithZero G₀
a b : G₀
h : optParam (1 ≠ 0) (_ : 1 ≠ 0)
⊢ ↑(mk0 1 h) = ↑1