tasksource/leandojo huggingface dataset:
Theorem: List.pairwise_gt_iota
File: Mathlib/Data/List/Range.lean

tactic: simpa only [iota_eq_reverse_range', pairwise_reverse] using pairwise_lt_range' 1 n
state_before: α : Type u
n : ℕ
⊢ Pairwise (fun x x_1 => x > x_1) (iota n)
Theorem: Bifunctor.comp_fst
File: Mathlib/Control/Bifunctor.lean

tactic: simp [fst, bimap_bimap]
state_before: F : Type u₀ → Type u₁ → Type u₂
inst✝¹ : Bifunctor F
inst✝ : LawfulBifunctor F
α₀ α₁ α₂ : Type u₀
β : Type u₁
f : α₀ → α₁
f' : α₁ → α₂
x : F α₀ β
⊢ fst f' (fst f x) = fst (f' ∘ f) x
Theorem: Ordinal.toNatOrdinal_cast_nat
File: Mathlib/SetTheory/Ordinal/NaturalOps.lean

tactic: rw [← toOrdinal_cast_nat n]
state_before: n : ℕ
⊢ ↑toNatOrdinal ↑n = ↑n

tactic: rfl
state_before: n : ℕ
⊢ ↑toNatOrdinal (↑toOrdinal ↑n) = ↑n
Theorem: Set.pairwise_pair_of_symmetric
File: Mathlib/Data/Set/Pairwise/Basic.lean

tactic: simp [pairwise_insert_of_symmetric hr]
state_before: α : Type u_1
β : Type ?u.14609
γ : Type ?u.14612
ι : Type ?u.14615
ι' : Type ?u.14618
r p q : α → α → Prop
f g : ι → α
s t u : Set α
a b : α
hr : Symmetric r
⊢ Set.Pairwise {a, b} r ↔ a ≠ b → r a b
Theorem: MeasureTheory.AEEqFun.comp₂Measurable_toGerm
File: Mathlib/MeasureTheory/Function/AEEqFun.lean

tactic: simp
state_before: α : Type u_4
β : Type u_1
γ : Type u_2
δ : Type u_3
inst✝¹⁵ : MeasurableSpace α
μ ν : Measure α
inst✝¹⁴ : TopologicalSpace β
inst✝¹³ : TopologicalSpace γ
inst✝¹² : TopologicalSpace δ
inst✝¹¹ : PseudoMetrizableSpace β
inst✝¹⁰ : SecondCountableTopology β
inst✝⁹ : MeasurableSpace β
inst✝⁸ : BorelSpace β
inst✝⁷ : PseudoMetrizableSpace γ
inst✝⁶ : SecondCountableTopology γ
inst✝⁵ : MeasurableSpace γ
inst✝⁴ : BorelSpace γ
inst✝³ : PseudoMetrizableSpace δ
inst✝² : SecondCountableTopology δ
inst✝¹ : MeasurableSpace δ
inst✝ : OpensMeasurableSpace δ
g : β → γ → δ
hg : Measurable (uncurry g)
f₁✝ : α →ₘ[μ] β
f₂✝ : α →ₘ[μ] γ
f₁ : α → β
x✝¹ : AEStronglyMeasurable f₁ μ
f₂ : α → γ
x✝ : AEStronglyMeasurable f₂ μ
⊢ toGerm (comp₂Measurable g hg (mk f₁ x✝¹) (mk f₂ x✝)) = Germ.map₂ g (toGerm (mk f₁ x✝¹)) (toGerm (mk f₂ x✝))
Theorem: Polynomial.trinomial_leading_coeff'
File: Mathlib/Data/Polynomial/UnitTrinomial.lean

tactic: rw [trinomial_def, coeff_add, coeff_add, coeff_C_mul_X_pow, coeff_C_mul_X_pow, coeff_C_mul_X_pow,
  if_neg (hkm.trans hmn).ne', if_neg hmn.ne', if_pos rfl, zero_add, zero_add]
state_before: R : Type u_1
inst✝ : Semiring R
k m n : ℕ
u v w : R
hkm : k < m
hmn : m < n
⊢ coeff (trinomial k m n u v w) n = w
Theorem: UniformSpace.uniformContinuous_quotient_lift₂
File: Mathlib/Topology/UniformSpace/Separation.lean

tactic: rw [UniformContinuous, uniformity_prod_eq_prod, uniformity_quotient, uniformity_quotient,
  Filter.prod_map_map_eq, Filter.tendsto_map'_iff, Filter.tendsto_map'_iff]
state_before: α : Type u
β : Type v
γ : Type w
inst✝² : UniformSpace α
inst✝¹ : UniformSpace β
inst✝ : UniformSpace γ
f : α → β → γ
h : ∀ (a : α) (c : β) (b : α) (d : β), (a, b) ∈ 𝓢 α → (c, d) ∈ 𝓢 β → f a c = f b d
hf : UniformContinuous fun p => f p.fst p.snd
⊢ UniformContinuous fun p => Quotient.lift₂ f h p.fst p.snd

tactic: rwa [UniformContinuous, uniformity_prod_eq_prod, Filter.tendsto_map'_iff] at hf
state_before: α : Type u
β : Type v
γ : Type w
inst✝² : UniformSpace α
inst✝¹ : UniformSpace β
inst✝ : UniformSpace γ
f : α → β → γ
h : ∀ (a : α) (c : β) (b : α) (d : β), (a, b) ∈ 𝓢 α → (c, d) ∈ 𝓢 β → f a c = f b d
hf : UniformContinuous fun p => f p.fst p.snd
⊢ Tendsto
    (((fun x => (Quotient.lift₂ f h x.fst.fst x.fst.snd, Quotient.lift₂ f h x.snd.fst x.snd.snd)) ∘ fun p =>
        ((p.fst.fst, p.snd.fst), p.fst.snd, p.snd.snd)) ∘
      fun p =>
      ((Quotient.mk (separationSetoid α) p.fst.fst, Quotient.mk (separationSetoid α) p.fst.snd),
        Quotient.mk (separationSetoid β) p.snd.fst, Quotient.mk (separationSetoid β) p.snd.snd))
    (𝓤 α ×ˢ 𝓤 β) (𝓤 γ)
Theorem: ClassGroup.induction
File: Mathlib/RingTheory/ClassGroup.lean

tactic: have : I = (Units.mapEquiv (canonicalEquiv R⁰ K (FractionRing R)).toMulEquiv)
  (Units.mapEquiv (canonicalEquiv R⁰ (FractionRing R) K).toMulEquiv I) := by
  simp [← Units.eq_iff]
state_before: R : Type u_1
K : Type u_2
L : Type ?u.669485
inst✝¹⁰ : CommRing R
inst✝⁹ : Field K
inst✝⁸ : Field L
inst✝⁷ : DecidableEq L
inst✝⁶ : Algebra R K
inst✝⁵ : IsFractionRing R K
inst✝⁴ : Algebra K L
inst✝³ : FiniteDimensional K L
inst✝² : Algebra R L
inst✝¹ : IsScalarTower R K L
inst✝ : IsDomain R
P : ClassGroup R → Prop
h : ∀ (I : (FractionalIdeal R⁰ K)ˣ), P (↑mk I)
x : ClassGroup R
I : (FractionalIdeal R⁰ (FractionRing R))ˣ
⊢ P ↑I

tactic: rw [congr_arg (QuotientGroup.mk (s := (toPrincipalIdeal R (FractionRing R)).range)) this]
state_before: R : Type u_1
K : Type u_2
L : Type ?u.669485
inst✝¹⁰ : CommRing R
inst✝⁹ : Field K
inst✝⁸ : Field L
inst✝⁷ : DecidableEq L
inst✝⁶ : Algebra R K
inst✝⁵ : IsFractionRing R K
inst✝⁴ : Algebra K L
inst✝³ : FiniteDimensional K L
inst✝² : Algebra R L
inst✝¹ : IsScalarTower R K L
inst✝ : IsDomain R
P : ClassGroup R → Prop
h : ∀ (I : (FractionalIdeal R⁰ K)ˣ), P (↑mk I)
x : ClassGroup R
I : (FractionalIdeal R⁰ (FractionRing R))ˣ
this :
  I =
    ↑(Units.mapEquiv (RingEquiv.toMulEquiv (canonicalEquiv R⁰ K (FractionRing R))))
      (↑(Units.mapEquiv (RingEquiv.toMulEquiv (canonicalEquiv R⁰ (FractionRing R) K))) I)
⊢ P ↑I

tactic: exact h _
state_before: R : Type u_1
K : Type u_2
L : Type ?u.669485
inst✝¹⁰ : CommRing R
inst✝⁹ : Field K
inst✝⁸ : Field L
inst✝⁷ : DecidableEq L
inst✝⁶ : Algebra R K
inst✝⁵ : IsFractionRing R K
inst✝⁴ : Algebra K L
inst✝³ : FiniteDimensional K L
inst✝² : Algebra R L
inst✝¹ : IsScalarTower R K L
inst✝ : IsDomain R
P : ClassGroup R → Prop
h : ∀ (I : (FractionalIdeal R⁰ K)ˣ), P (↑mk I)
x : ClassGroup R
I : (FractionalIdeal R⁰ (FractionRing R))ˣ
this :
  I =
    ↑(Units.mapEquiv (RingEquiv.toMulEquiv (canonicalEquiv R⁰ K (FractionRing R))))
      (↑(Units.mapEquiv (RingEquiv.toMulEquiv (canonicalEquiv R⁰ (FractionRing R) K))) I)
⊢ P
    ↑(↑(Units.mapEquiv (RingEquiv.toMulEquiv (canonicalEquiv R⁰ K (FractionRing R))))
        (↑(Units.mapEquiv (RingEquiv.toMulEquiv (canonicalEquiv R⁰ (FractionRing R) K))) I))

tactic: simp [← Units.eq_iff]
state_before: R : Type u_1
K : Type u_2
L : Type ?u.669485
inst✝¹⁰ : CommRing R
inst✝⁹ : Field K
inst✝⁸ : Field L
inst✝⁷ : DecidableEq L
inst✝⁶ : Algebra R K
inst✝⁵ : IsFractionRing R K
inst✝⁴ : Algebra K L
inst✝³ : FiniteDimensional K L
inst✝² : Algebra R L
inst✝¹ : IsScalarTower R K L
inst✝ : IsDomain R
P : ClassGroup R → Prop
h : ∀ (I : (FractionalIdeal R⁰ K)ˣ), P (↑mk I)
x : ClassGroup R
I : (FractionalIdeal R⁰ (FractionRing R))ˣ
⊢ I =
    ↑(Units.mapEquiv (RingEquiv.toMulEquiv (canonicalEquiv R⁰ K (FractionRing R))))
      (↑(Units.mapEquiv (RingEquiv.toMulEquiv (canonicalEquiv R⁰ (FractionRing R) K))) I)
Theorem: Cardinal.nat_lt_aleph0
File: Mathlib/SetTheory/Cardinal/Basic.lean

tactic: rw [← nat_succ, ← lift_mk_fin, aleph0, lift_mk_le.{0, 0, u}]
state_before: α β : Type u
n : ℕ
⊢ succ ↑n ≤ ℵ₀

tactic: exact ⟨⟨(↑), fun a b => Fin.ext⟩⟩
state_before: α β : Type u
n : ℕ
⊢ Nonempty (Fin (Nat.succ n) ↪ ℕ)
Theorem: WittVector.mul_coeff_zero
File: Mathlib/RingTheory/WittVector/Defs.lean

tactic: simp [mul_coeff, peval]
state_before: p : ℕ
R : Type u_1
hp : Fact (Nat.Prime p)
inst✝ : CommRing R
x y : 𝕎 R
⊢ coeff (x * y) 0 = coeff x 0 * coeff y 0
Theorem: ContinuousMap.HomotopicRel.equivalence
File: Mathlib/Topology/Homotopy/Basic.lean

tactic: apply symm
state_before: F : Type ?u.344889
X : Type u
Y : Type v
Z : Type w
Z' : Type x
inst✝³ : TopologicalSpace X
inst✝² : TopologicalSpace Y
inst✝¹ : TopologicalSpace Z
inst✝ : TopologicalSpace Z'
S : Set X
⊢ ∀ {x y : C(X, Y)}, HomotopicRel x y S → HomotopicRel y x S

tactic: apply trans
state_before: F : Type ?u.344889
X : Type u
Y : Type v
Z : Type w
Z' : Type x
inst✝³ : TopologicalSpace X
inst✝² : TopologicalSpace Y
inst✝¹ : TopologicalSpace Z
inst✝ : TopologicalSpace Z'
S : Set X
⊢ ∀ {x y z : C(X, Y)}, HomotopicRel x y S → HomotopicRel y z S → HomotopicRel x z S
Theorem: Finsupp.onFinset_prod
File: Mathlib/Algebra/BigOperators/Finsupp.lean

tactic: simp (config := { contextual := true }) [*]
state_before: α : Type u_1
ι : Type ?u.133454
γ : Type ?u.133457
A : Type ?u.133460
B : Type ?u.133463
C : Type ?u.133466
inst✝⁵ : AddCommMonoid A
inst✝⁴ : AddCommMonoid B
inst✝³ : AddCommMonoid C
t : ι → A → C
h0 : ∀ (i : ι), t i 0 = 0
h1 : ∀ (i : ι) (x y : A), t i (x + y) = t i x + t i y
s✝ : Finset α
f✝ : α → ι →₀ A
i : ι
g✝ : ι →₀ A
k : ι → A → γ → B
x : γ
β : Type ?u.136596
M : Type u_2
M' : Type ?u.136602
N : Type u_3
P : Type ?u.136608
G : Type ?u.136611
H : Type ?u.136614
R : Type ?u.136617
S : Type ?u.136620
inst✝² : Zero M
inst✝¹ : Zero M'
inst✝ : CommMonoid N
s : Finset α
f : α → M
g : α → M → N
hf : ∀ (a : α), f a ≠ 0 → a ∈ s
hg : ∀ (a : α), g a 0 = 1
⊢ ∀ (x : α), x ∈ s → ¬x ∈ (onFinset s f hf).support → g x (↑(onFinset s f hf) x) = 1
Theorem: Vector.ofFn_get
File: Mathlib/Data/Vector/Basic.lean

tactic: rcases v with ⟨l, rfl⟩
state_before: n : ℕ
α : Type u_1
v : Vector α n
⊢ ofFn (get v) = v

tactic: apply toList_injective
state_before: case mk
α : Type u_1
l : List α
⊢ ofFn (get { val := l, property := (_ : List.length l = List.length l) }) =
    { val := l, property := (_ : List.length l = List.length l) }

tactic: dsimp
state_before: case mk.a
α : Type u_1
l : List α
⊢ toList (ofFn (get { val := l, property := (_ : List.length l = List.length l) })) =
    toList { val := l, property := (_ : List.length l = List.length l) }

tactic: simpa only [toList_ofFn] using List.ofFn_get _
state_before: case mk.a
α : Type u_1
l : List α
⊢ toList (ofFn (get { val := l, property := (_ : List.length l = List.length l) })) = l
Theorem: geometric_hahn_banach_closed_compact
File: Mathlib/Analysis/NormedSpace/HahnBanach/Separation.lean

tactic: simpa using ht
state_before: 𝕜 : Type ?u.97824
E : Type u_1
inst✝⁵ : TopologicalSpace E
inst✝⁴ : AddCommGroup E
inst✝³ : TopologicalAddGroup E
inst✝² : Module ℝ E
inst✝¹ : ContinuousSMul ℝ E
s✝ t✝ : Set E
x y : E
inst✝ : LocallyConvexSpace ℝ E
hs₁ : Convex ℝ s✝
hs₂ : IsClosed s✝
ht₁ : Convex ℝ t✝
ht₂ : IsCompact t✝
disj : Disjoint s✝ t✝
f : E →L[ℝ] ℝ
s t : ℝ
hs : ∀ (a : E), a ∈ t✝ → ↑f a < s
st : s < t
ht : ∀ (b : E), b ∈ s✝ → t < ↑f b
⊢ ∀ (a : E), a ∈ s✝ → ↑(-f) a < -t

tactic: simpa using st
state_before: 𝕜 : Type ?u.97824
E : Type u_1
inst✝⁵ : TopologicalSpace E
inst✝⁴ : AddCommGroup E
inst✝³ : TopologicalAddGroup E
inst✝² : Module ℝ E
inst✝¹ : ContinuousSMul ℝ E
s✝ t✝ : Set E
x y : E
inst✝ : LocallyConvexSpace ℝ E
hs₁ : Convex ℝ s✝
hs₂ : IsClosed s✝
ht₁ : Convex ℝ t✝
ht₂ : IsCompact t✝
disj : Disjoint s✝ t✝
f : E →L[ℝ] ℝ
s t : ℝ
hs : ∀ (a : E), a ∈ t✝ → ↑f a < s
st : s < t
ht : ∀ (b : E), b ∈ s✝ → t < ↑f b
⊢ -t < -s

tactic: simpa using hs
state_before: 𝕜 : Type ?u.97824
E : Type u_1
inst✝⁵ : TopologicalSpace E
inst✝⁴ : AddCommGroup E
inst✝³ : TopologicalAddGroup E
inst✝² : Module ℝ E
inst✝¹ : ContinuousSMul ℝ E
s✝ t✝ : Set E
x y : E
inst✝ : LocallyConvexSpace ℝ E
hs₁ : Convex ℝ s✝
hs₂ : IsClosed s✝
ht₁ : Convex ℝ t✝
ht₂ : IsCompact t✝
disj : Disjoint s✝ t✝
f : E →L[ℝ] ℝ
s t : ℝ
hs : ∀ (a : E), a ∈ t✝ → ↑f a < s
st : s < t
ht : ∀ (b : E), b ∈ s✝ → t < ↑f b
⊢ ∀ (b : E), b ∈ t✝ → -s < ↑(-f) b
Theorem: Int.zero_dvd
File: Std/Data/Int/DivMod.lean

tactic: rw [e, Int.zero_mul]
state_before: n : Int
x✝ : 0 ∣ n
k : Int
e : n = 0 * k
⊢ n = 0
Theorem: InnerProductGeometry.sin_eq_zero_iff_angle_eq_zero_or_angle_eq_pi
File: Mathlib/Geometry/Euclidean/Angle/Unoriented/Basic.lean

tactic: rw [sin_eq_zero_iff_cos_eq, cos_eq_one_iff_angle_eq_zero, cos_eq_neg_one_iff_angle_eq_pi]
state_before: V : Type u_1
inst✝¹ : NormedAddCommGroup V
inst✝ : InnerProductSpace ℝ V
x y : V
⊢ sin (angle x y) = 0 ↔ angle x y = 0 ∨ angle x y = π
Theorem: UniformSpace.ball_mem_nhds
File: Mathlib/Topology/UniformSpace/Basic.lean

tactic: rw [UniformSpace.mem_nhds_iff]
state_before: α : Type ua
β : Type ub
γ : Type uc
δ : Type ud
ι : Sort ?u.59981
inst✝ : UniformSpace α
x : α
V : Set (α × α)
V_in : V ∈ 𝓤 α
⊢ ball x V ∈ 𝓝 x

tactic: exact ⟨V, V_in, Subset.rfl⟩
state_before: α : Type ua
β : Type ub
γ : Type uc
δ : Type ud
ι : Sort ?u.59981
inst✝ : UniformSpace α
x : α
V : Set (α × α)
V_in : V ∈ 𝓤 α
⊢ ∃ V_1, V_1 ∈ 𝓤 α ∧ ball x V_1 ⊆ ball x V
Theorem: Finmap.union_assoc
File: Mathlib/Data/Finmap.lean

tactic: simp only [AList.toFinmap_eq, union_toFinmap, AList.union_assoc]
state_before: α : Type u
β : α → Type v
inst✝ : DecidableEq α
s₁✝ s₂✝ s₃✝ : Finmap β
s₁ s₂ s₃ : AList β
⊢ ⟦s₁⟧ ∪ ⟦s₂⟧ ∪ ⟦s₃⟧ = ⟦s₁⟧ ∪ (⟦s₂⟧ ∪ ⟦s₃⟧)
Theorem: two_nsmul_lie_lmul_lmul_add_add_eq_zero
File: Mathlib/Algebra/Jordan/Basic.lean

tactic: symm
state_before: A : Type u_1
inst✝¹ : NonUnitalNonAssocRing A
inst✝ : IsCommJordan A
a b c : A
⊢ 2 • (⁅↑L a, ↑L (b * c)⁆ + ⁅↑L b, ↑L (c * a)⁆ + ⁅↑L c, ↑L (a * b)⁆) = 0

tactic: calc
  0 = ⁅L (a + b + c), L ((a + b + c) * (a + b + c))⁆ := by
    rw [(commute_lmul_lmul_sq (a + b + c)).lie_eq]
  _ = _ := by rw [aux0, aux1, aux2, aux3, nsmul_add, nsmul_add]
state_before: A : Type u_1
inst✝¹ : NonUnitalNonAssocRing A
inst✝ : IsCommJordan A
a b c : A
⊢ 0 = 2 • (⁅↑L a, ↑L (b * c)⁆ + ⁅↑L b, ↑L (c * a)⁆ + ⁅↑L c, ↑L (a * b)⁆)

tactic: rw [(commute_lmul_lmul_sq (a + b + c)).lie_eq]
state_before: A : Type u_1
inst✝¹ : NonUnitalNonAssocRing A
inst✝ : IsCommJordan A
a b c : A
⊢ 0 = ⁅↑L (a + b + c), ↑L ((a + b + c) * (a + b + c))⁆

tactic: rw [aux0, aux1, aux2, aux3, nsmul_add, nsmul_add]
state_before: A : Type u_1
inst✝¹ : NonUnitalNonAssocRing A
inst✝ : IsCommJordan A
a b c : A
⊢ ⁅↑L (a + b + c), ↑L ((a + b + c) * (a + b + c))⁆ = 2 • (⁅↑L a, ↑L (b * c)⁆ + ⁅↑L b, ↑L (c * a)⁆ + ⁅↑L c, ↑L (a * b)⁆)
Theorem: ENNReal.div_eq_one_iff
File: Mathlib/Data/Real/ENNReal.lean

tactic: rw [← (eq_div_iff hb₀ hb₁).mp h.symm, mul_one]
state_before: α : Type ?u.311957
β : Type ?u.311960
a✝ b✝ c d : ℝ≥0∞
r p q : ℝ≥0
a b : ℝ≥0∞
hb₀ : b ≠ 0
hb₁ : b ≠ ⊤
h : a / b = 1
⊢ a = b
Theorem: Polynomial.iterate_derivative_X_add_pow
File: Mathlib/Data/Polynomial/Derivative.lean

tactic: induction' k with k IH
state_before: R : Type u
S : Type v
T : Type w
ι : Type y
A : Type z
a b : R
n✝ : ℕ
inst✝ : CommSemiring R
n k : ℕ
c : R
⊢ (↑derivative^[k]) ((X + ↑C c) ^ n) = ↑(∏ i in range k, (n - i)) * (X + ↑C c) ^ (n - k)

tactic: simp
state_before: case zero
R : Type u
S : Type v
T : Type w
ι : Type y
A : Type z
a b : R
n✝ : ℕ
inst✝ : CommSemiring R
n : ℕ
c : R
⊢ (↑derivative^[Nat.zero]) ((X + ↑C c) ^ n) = ↑(∏ i in range Nat.zero, (n - i)) * (X + ↑C c) ^ (n - Nat.zero)

tactic: simp only [Function.iterate_succ_apply', IH, derivative_mul, zero_mul, derivative_nat_cast,
  zero_add, Finset.prod_range_succ, C_eq_nat_cast, Nat.sub_sub, ← mul_assoc,
  derivative_X_add_C_pow, Nat.succ_eq_add_one, Nat.cast_mul]
state_before: case succ
R : Type u
S : Type v
T : Type w
ι : Type y
A : Type z
a b : R
n✝ : ℕ
inst✝ : CommSemiring R
n : ℕ
c : R
k : ℕ
IH : (↑derivative^[k]) ((X + ↑C c) ^ n) = ↑(∏ i in range k, (n - i)) * (X + ↑C c) ^ (n - k)
⊢ (↑derivative^[Nat.succ k]) ((X + ↑C c) ^ n) = ↑(∏ i in range (Nat.succ k), (n - i)) * (X + ↑C c) ^ (n - Nat.succ k)
Theorem: List.card_append_disjoint
File: Mathlib/Data/List/Card.lean

tactic: simp
state_before: α : Type u_1
β : Sort ?u.49007
inst✝¹ : DecidableEq α
inst✝ : DecidableEq β
x✝¹ : List α
x✝ : Disjoint [] x✝¹
⊢ card ([] ++ x✝¹) = card [] + card x✝¹

tactic: have disj' : Disjoint as bs := fun _ h1 h2 ↦ disj (mem_cons_of_mem a h1) h2
state_before: α : Type u_1
β : Sort ?u.49007
inst✝¹ : DecidableEq α
inst✝ : DecidableEq β
a : α
as bs : List α
disj : Disjoint (a :: as) bs
⊢ card (a :: as ++ bs) = card (a :: as) + card bs

tactic: cases Decidable.em (a ∈ as) with
| inl h =>
  simp [h, card_append_disjoint disj']
| inr h =>
  have h1 : a ∉ bs := fun h' ↦ disj (mem_cons_self a as) h'
  simp [h, h1, card_append_disjoint disj']
  rw [Nat.add_right_comm]
state_before: α : Type u_1
β : Sort ?u.49007
inst✝¹ : DecidableEq α
inst✝ : DecidableEq β
a : α
as bs : List α
disj : Disjoint (a :: as) bs
disj' : Disjoint as bs
⊢ card (a :: as ++ bs) = card (a :: as) + card bs

tactic: simp [h, card_append_disjoint disj']
state_before: case inl
α : Type u_1
β : Sort ?u.49007
inst✝¹ : DecidableEq α
inst✝ : DecidableEq β
a : α
as bs : List α
disj : Disjoint (a :: as) bs
disj' : Disjoint as bs
h : a ∈ as
⊢ card (a :: as ++ bs) = card (a :: as) + card bs

tactic: have h1 : a ∉ bs := fun h' ↦ disj (mem_cons_self a as) h'
state_before: case inr
α : Type u_1
β : Sort ?u.49007
inst✝¹ : DecidableEq α
inst✝ : DecidableEq β
a : α
as bs : List α
disj : Disjoint (a :: as) bs
disj' : Disjoint as bs
h : ¬a ∈ as
⊢ card (a :: as ++ bs) = card (a :: as) + card bs

tactic: simp [h, h1, card_append_disjoint disj']
state_before: case inr
α : Type u_1
β : Sort ?u.49007
inst✝¹ : DecidableEq α
inst✝ : DecidableEq β
a : α
as bs : List α
disj : Disjoint (a :: as) bs
disj' : Disjoint as bs
h : ¬a ∈ as
h1 : ¬a ∈ bs
⊢ card (a :: as ++ bs) = card (a :: as) + card bs

tactic: rw [Nat.add_right_comm]
state_before: case inr
α : Type u_1
β : Sort ?u.49007
inst✝¹ : DecidableEq α
inst✝ : DecidableEq β
a : α
as bs : List α
disj : Disjoint (a :: as) bs
disj' : Disjoint as bs
h : ¬a ∈ as
h1 : ¬a ∈ bs
⊢ card as + card bs + 1 = card as + 1 + card bs
Theorem: MeasureTheory.Integrable.inner_const
File: Mathlib/MeasureTheory/Function/L2Space.lean

tactic: rw [← memℒp_one_iff_integrable] at hf ⊢
state_before: α : Type u_2
m : MeasurableSpace α
p : ℝ≥0∞
μ : Measure α
E : Type u_1
𝕜 : Type u_3
inst✝² : IsROrC 𝕜
inst✝¹ : NormedAddCommGroup E
inst✝ : InnerProductSpace 𝕜 E
f : α → E
hf : Integrable f
c : E
⊢ Integrable fun x => inner (f x) c

tactic: exact hf.inner_const c
state_before: α : Type u_2
m : MeasurableSpace α
p : ℝ≥0∞
μ : Measure α
E : Type u_1
𝕜 : Type u_3
inst✝² : IsROrC 𝕜
inst✝¹ : NormedAddCommGroup E
inst✝ : InnerProductSpace 𝕜 E
f : α → E
hf : Memℒp f 1
c : E
⊢ Memℒp (fun x => inner (f x) c) 1
Theorem: intervalIntegral.integral_lt_integral_of_ae_le_of_measure_setOf_lt_ne_zero
File: Mathlib/MeasureTheory/Integral/IntervalIntegral.lean

tactic: rw [← sub_pos, ← integral_sub hgi hfi, integral_of_le hab,
  MeasureTheory.integral_pos_iff_support_of_nonneg_ae]
state_before: ι : Type ?u.20041361
𝕜 : Type ?u.20041364
E : Type ?u.20041367
F : Type ?u.20041370
A : Type ?u.20041373
inst✝² : NormedAddCommGroup E
inst✝¹ : CompleteSpace E
inst✝ : NormedSpace ℝ E
f g : ℝ → ℝ
a b : ℝ
μ : MeasureTheory.Measure ℝ
hab : a ≤ b
hfi : IntervalIntegrable f μ a b
hgi : IntervalIntegrable g μ a b
hle : f ≤ᵐ[Measure.restrict μ (Ioc a b)] g
hlt : ↑↑(Measure.restrict μ (Ioc a b)) {x | f x < g x} ≠ 0
⊢ (∫ (x : ℝ) in a..b, f x ∂μ) < ∫ (x : ℝ) in a..b, g x ∂μ

tactic: exacts [hle.mono fun x => sub_nonneg.2, hgi.1.sub hfi.1]
state_before: case hf
ι : Type ?u.20041361
𝕜 : Type ?u.20041364
E : Type ?u.20041367
F : Type ?u.20041370
A : Type ?u.20041373
inst✝² : NormedAddCommGroup E
inst✝¹ : CompleteSpace E
inst✝ : NormedSpace ℝ E
f g : ℝ → ℝ
a b : ℝ
μ : MeasureTheory.Measure ℝ
hab : a ≤ b
hfi : IntervalIntegrable f μ a b
hgi : IntervalIntegrable g μ a b
hle : f ≤ᵐ[Measure.restrict μ (Ioc a b)] g
hlt : ↑↑(Measure.restrict μ (Ioc a b)) {x | f x < g x} ≠ 0
⊢ 0 ≤ᵐ[Measure.restrict μ (Ioc a b)] fun x => g x - f x

case hfi
ι : Type ?u.20041361
𝕜 : Type ?u.20041364
E : Type ?u.20041367
F : Type ?u.20041370
A : Type ?u.20041373
inst✝² : NormedAddCommGroup E
inst✝¹ : CompleteSpace E
inst✝ : NormedSpace ℝ E
f g : ℝ → ℝ
a b : ℝ
μ : MeasureTheory.Measure ℝ
hab : a ≤ b
hfi : IntervalIntegrable f μ a b
hgi : IntervalIntegrable g μ a b
hle : f ≤ᵐ[Measure.restrict μ (Ioc a b)] g
hlt : ↑↑(Measure.restrict μ (Ioc a b)) {x | f x < g x} ≠ 0
⊢ Integrable fun x => g x - f x

tactic: refine' pos_iff_ne_zero.2 (mt (measure_mono_null _) hlt)
state_before: ι : Type ?u.20041361
𝕜 : Type ?u.20041364
E : Type ?u.20041367
F : Type ?u.20041370
A : Type ?u.20041373
inst✝² : NormedAddCommGroup E
inst✝¹ : CompleteSpace E
inst✝ : NormedSpace ℝ E
f g : ℝ → ℝ
a b : ℝ
μ : MeasureTheory.Measure ℝ
hab : a ≤ b
hfi : IntervalIntegrable f μ a b
hgi : IntervalIntegrable g μ a b
hle : f ≤ᵐ[Measure.restrict μ (Ioc a b)] g
hlt : ↑↑(Measure.restrict μ (Ioc a b)) {x | f x < g x} ≠ 0
⊢ 0 < ↑↑(Measure.restrict μ (Ioc a b)) (support fun x => g x - f x)

tactic: exact fun x hx => (sub_pos.2 hx.out).ne'
state_before: ι : Type ?u.20041361
𝕜 : Type ?u.20041364
E : Type ?u.20041367
F : Type ?u.20041370
A : Type ?u.20041373
inst✝² : NormedAddCommGroup E
inst✝¹ : CompleteSpace E
inst✝ : NormedSpace ℝ E
f g : ℝ → ℝ
a b : ℝ
μ : MeasureTheory.Measure ℝ
hab : a ≤ b
hfi : IntervalIntegrable f μ a b
hgi : IntervalIntegrable g μ a b
hle : f ≤ᵐ[Measure.restrict μ (Ioc a b)] g
hlt : ↑↑(Measure.restrict μ (Ioc a b)) {x | f x < g x} ≠ 0
⊢ {x | f x < g x} ⊆ support fun x => g x - f x
Theorem: MeasureTheory.OuterMeasure.diff_null
File: Mathlib/MeasureTheory/Measure/OuterMeasure.lean

tactic: refine' le_antisymm (m.mono <| diff_subset _ _) _
state_before: α : Type u_1
β : Type ?u.20498
R : Type ?u.20501
R' : Type ?u.20504
ms : Set (OuterMeasure α)
m✝ m : OuterMeasure α
s t : Set α
ht : ↑m t = 0
⊢ ↑m (s \ t) = ↑m s

tactic: calc
  m s ≤ m (s ∩ t) + m (s \ t) := le_inter_add_diff _
  _ ≤ m t + m (s \ t) := (add_le_add_right (m.mono <| inter_subset_right _ _) _)
  _ = m (s \ t) := by rw [ht, zero_add]
state_before: α : Type u_1
β : Type ?u.20498
R : Type ?u.20501
R' : Type ?u.20504
ms : Set (OuterMeasure α)
m✝ m : OuterMeasure α
s t : Set α
ht : ↑m t = 0
⊢ ↑m s ≤ ↑m (s \ t)

tactic: rw [ht, zero_add]
state_before: α : Type u_1
β : Type ?u.20498
R : Type ?u.20501
R' : Type ?u.20504
ms : Set (OuterMeasure α)
m✝ m : OuterMeasure α
s t : Set α
ht : ↑m t = 0
⊢ ↑m t + ↑m (s \ t) = ↑m (s \ t)
Theorem: eq_one_div_of_mul_eq_one_right
File: Mathlib/Algebra/Group/Basic.lean

tactic: rw [eq_inv_of_mul_eq_one_right h, one_div]
state_before: α : Type u_1
β : Type ?u.22415
G : Type ?u.22418
inst✝ : DivisionMonoid α
a b c : α
h : a * b = 1
⊢ b = 1 / a
Theorem: Int.mul_eq_zero
File: Std/Data/Int/Lemmas.lean

tactic: exact match Int.lt_trichotomy a 0, Int.lt_trichotomy b 0 with
| .inr (.inl heq₁), _ => .inl heq₁
| _, .inr (.inl heq₂) => .inr heq₂
| .inl hlt₁, .inl hlt₂ => absurd h <| Int.ne_of_gt <| Int.mul_pos_of_neg_of_neg hlt₁ hlt₂
| .inl hlt₁, .inr (.inr hgt₂) => absurd h <| Int.ne_of_lt <| Int.mul_neg_of_neg_of_pos hlt₁ hgt₂
| .inr (.inr hgt₁), .inl hlt₂ => absurd h <| Int.ne_of_lt <| Int.mul_neg_of_pos_of_neg hgt₁ hlt₂
| .inr (.inr hgt₁), .inr (.inr hgt₂) => absurd h <| Int.ne_of_gt <| Int.mul_pos hgt₁ hgt₂
state_before: a b : Int
h : a * b = 0
⊢ a = 0 ∨ b = 0
Theorem: Setoid.IsPartition.sUnion_eq_univ
File: Mathlib/Data/Setoid/Partition.lean

tactic: simp only [exists_unique_iff_exists] at ht
state_before: α : Type u_1
c : Set (Set α)
hc : IsPartition c
x : α
t : Set α
ht : (fun b => ∃! x_1, x ∈ b) t ∧ ∀ (y : Set α), (fun b => ∃! x_1, x ∈ b) y → y = t
⊢ t ∈ c ∧ x ∈ t

tactic: tauto
state_before: α : Type u_1
c : Set (Set α)
hc : IsPartition c
x : α
t : Set α
ht : (∃ x_1, x ∈ t) ∧ ∀ (y : Set α), (∃ x_1, x ∈ y) → y = t
⊢ t ∈ c ∧ x ∈ t
Theorem: Ordinal.Principal.iterate_lt
File: Mathlib/SetTheory/Ordinal/Principal.lean

tactic: induction' n with n hn
state_before: op : Ordinal → Ordinal → Ordinal
a o : Ordinal
hao : a < o
ho : Principal op o
n : ℕ
⊢ (op a^[n]) a < o

tactic: rwa [Function.iterate_zero]
state_before: case zero
op : Ordinal → Ordinal → Ordinal
a o : Ordinal
hao : a < o
ho : Principal op o
⊢ (op a^[Nat.zero]) a < o

tactic: rw [Function.iterate_succ']
state_before: case succ
op : Ordinal → Ordinal → Ordinal
a o : Ordinal
hao : a < o
ho : Principal op o
n : ℕ
hn : (op a^[n]) a < o
⊢ (op a^[Nat.succ n]) a < o

tactic: exact ho hao hn
state_before: case succ
op : Ordinal → Ordinal → Ordinal
a o : Ordinal
hao : a < o
ho : Principal op o
n : ℕ
hn : (op a^[n]) a < o
⊢ (op a ∘ op a^[n]) a < o
Theorem: Multiset.toDfinsupp_le_toDfinsupp
File: Mathlib/Data/Dfinsupp/Multiset.lean

tactic: simp [Multiset.le_iff_count, Dfinsupp.le_def]
state_before: α : Type u_1
β : α → Type ?u.75810
inst✝ : DecidableEq α
s t : Multiset α
⊢ ↑toDfinsupp s ≤ ↑toDfinsupp t ↔ s ≤ t